<<TableOfContents>>
= 委托!反继承! =
== 代码 ==
完成了一般的委托功能，一个委托上挂多个函数，可以设置函数列表为空时，是否抛出异常。返回值是函数列表中最后一个函数调用的返回,使用方法可参见test部分。
* 修改：__call__忘了加字典参数。--LiJie(2005.06.28)
* 修改：增加-、-=操作符，增加clear()、bind()、unbind()函数。--LiJie(2005.06.29 14:30)
{{{
#!python
class delegate:
def __init__(self, *calls, **opts):
for call in calls:
if not callable(call):
raise RuntimeError, str(call) + ' not a callable object'
self.calls = () + calls
self.emptyExcept = opts.get('emptyExcept', False)
self.proto = opts.get('proto')
def __call__(self, *args, **kwargs):
if self.emptyExcept and not self.calls:
raise RuntimeError, 'No callable objects'
try:
result = None
for call in self.calls:
result = call (*args, **kwargs)
return result
except TypeError:
raise RuntimeError, 'Invalid callable type: ' + str(call)
def __add__(self, call):
if not callable(call):
raise RuntimeError, str(call) + ' not a callable object'
return delegate(*(self.calls + (call,)))
def __iadd__(self, *calls):
self.calls += calls
return self
def __sub__(self, call):
return delegate (*[x for x in self.calls if x != call])
def __isub__(self, call):
self.calls = tuple([x for x in self.calls if x != call])
return self
def __str__(self):
if self.proto:
return '<delegate object, proto type: %s>' % repr(self.proto)
return repr(self)
def clear (self):
self.calls = []
def bind (self, call):
self.__iadd__(call)
def unbind (self, call):
if call not in self.calls:
raise RuntimeError, str(call) + ' not bind'
self.calls = tuple ([x for x in self.calls if x != call])
if __name__ == '__main__':
def a(v1, v2, **kwargs):
print '\ta:', v1, v2
def b(*args, **kwargs):
print '\tb:', args, kwargs
def c(v1, v2, **kwargs):
print '\tc:', v1, v2, 'hello=', kwargs.get('hello')
class Test:
def hello(self, v1, v2, **kwargs):
print '\tTest.hello:', v1, v2
class Test1:
def __call__(self, v1, v2, **kwargs):
print '\tTest1.__call__:', v1, v2
print '======== test delegate.__init__ and delegate.__call__'
print '\t==== a, b, c, Test.hello, Test1'
f = delegate(a, b, c, Test().hello, Test1())
f (3, 4, hello='world')
print '======== test delegate.__add__'
print '\t==== a, b, c, Test.hello, Test1, a'
f1 = f + a
f1 (5, 6)
print '======== test delegate.__iadd__'
print '\t==== a, b'
f2 = delegate(a, b)
f2 (3, 7)
print '\t==== a, b, c'
f2 += c
f2 (9, 10)
print '======== test delegate.__sub__'
print '\t==== a, b, c'
f3 = delegate (a, b, c)
f3 (11,11)
print '\t==== b, c'
f3 = f3 - a
f3 (13, 13)
print '\t==== b'
f3 = f3 - c
f3 (15, 15)
print '======== test delegate.__isub__'
print '\t==== a, b, c'
f4 = delegate(a, b, c)
f4 (17, 17)
print '\t==== b, c'
f4 -= a
f4 (19, 19)
print '\t==== c'
f4 -= b
f4 (21, 21)
print '======== test delegate.__call__ return value'
f3 = delegate(lambda x, y: x*y)
assert f3(10, 11) == 10*11
f3 = delegate(lambda x, y: x*y, lambda x, y: x**y)
assert f3(10, 11) == 10**11
print '======== test delegate.__call__ with empty exception (empty)'
f4 = delegate (emptyExcept=True)
try:
f4 (3, 5)
except RuntimeError, ex:
print 'Exception:', ex
print '======== test delegate.__call__ with empty exception (not empty)'
f4 += a
f4 (3, 5)
print '======== test delegate.bind'
print '\t==== a'
f = delegate (a)
f (911, 119)
print '\t==== a, b'
f.bind (b)
f (199, 991)
print '======== test delegate.unbind'
print '\t==== b'
f.unbind (a)
f (177, 771)
print '\t==== (empty)'
f.unbind (b)
f (133, 331)
print '======== test delegate.clear'
print '\t==== a, b'
f = delegate (a, b)
f (137, 138)
print '\t==== (empty)'
f.clear ()
f (139, 139)
print '======== (finished)'
}}}
=== 讨论 ===
* 不太清楚这个功能的具体实用性。在NewEdit中有类似的处理，它用来处理代码的插入点。不过有两种处理方式：一种是链式执行，不需要考虑返回值的，可以执行多个函数。一种是中断式执行，即要判断返回值，如果返回值为真，则不再继续执行，并且这个返回值要返回给调用者。因此前面的方式有些象过程，后面则是一个函数式的调用。 -- [[limodou]]
==== 功用1--扩展接口设计 ====
* 这个是模拟其它语言中的委托功能，委托实际上是个非常重要的功能，为模块接口设计提供了更广阔的选择，举个例子：
{{{
#!python
class NetConnection:
def onConnected (self):
pass
def onDisconnected (self):
pass
def onReceived (self, data):
pass
def connect (self, address):
pass
def disconnect (self):
pass
def send (self, data):
pass
class AutoReconnectConnection(NetConnection):
def onConnected (self):
pass
def onDisconnected (self):
pass
class AutoReconnectCommander(AutoReconnectConnection):
def onReceived (self, data):
pass
}}}
NetConnection类完成基本的网络连接，AutoReconnectConnection类有断线后自动重连的功能，AutoReconnectCommander则是把接收到的数据包转为指令或消息格式，这是一个普通的继承结构，没什么问题，使用时只要生成AutoReconnectCommander对象调用相关方法即可，接收到的数据在AutoReconnectCommander类中处理。
不过还有其它选择，这里用刚刚完成的delegate来做，示例如下：
{{{
#!python
class NetConnection:
def __init__ (self):
self.onConnected = delegate (proto='onConnected()')
self.onDisconnected = delegate (proto='onDisconnected()')
self.onReceived = delegate(proto='onReceived(data)')
def connect (self, address):
pass
def disconnect (self):
pass
class Commander:
def __init__(self):
self.send = delegate (proto='send(data)')
def onReceived (self, data):
pass
class AutoReconnectProcessor:
def __init__ (self):
self.connect = delegate (proto='connect(address)')
def onConnected (self):
pass
def onDisconnected (self):
pass
}}}
注：delegate (proto='onConnected()')括号中的proto='...'其实现在没有使用，只是为了方便随时查阅要挂载的函数的原型。
这个调用过程会麻烦一些：
{{{
#!python
# create objects
connection = NetConnection ()
commander = Commander ()
auto_reconnect_processor = AutoReconnectProcessor()
# process delegate
connection.onConnected += auto_reconnect_processor.onConnected
connection.onDisconnected += auto_reconnect_processor.onDisconnected
connection.onReceived += commander.onReceived
command.send += connection.send
auto_reconnect_processor.connect = connection.connect
}}}
这个要很多步骤才完成一个初始化。但它带来了很多好处：
1. 对象之间的行为绑定修改起来非常容易，比如这里要让某个连接断线后不重连，只要把它们之间的关系去掉即可；
2. 插入行为非常容易，比如需要在接收到数据以后，把收到的数据复制一份到某文件，只要实现一个对象，并且具有与onReceived接口相容的调用形式同，并添加委托关系即可；要把发送的数据打印在屏幕，只需要实现一个与send相容的函数，在里面执行输出到屏幕，再添加委托关系即可；
3. 每个部分的测试应该会比继承关系更容易，现在只需要为委托接口添加测试、输出或其它方式的测试代码即可。
== 总述 ==
* 总之，就像是电路板一样，实现一个个的小元件，用这种方式插到一块。每个元件之间尽量解除了藕合，对测试来说是大有益处的。就算是对整个系统做测试，也会容易很多，测试过程中要做的修改一般只需要修改委托关系即可。就像在已经完成电路板上夹上个万用表进行测试一样方便，如果某个元件工作不正常，通过简单替换成另一个功能类似的元件，重新加上委托关系即可。使用委托，唯一需要确定的是接口，对象之间根本不知道内部情况，这也与主流的软件开发思想一致。你所说的NewEdit中的处理，我想应该是类似任务列表和消息处理吧，任务列就是一起执行一组方法列表，依次执行；一般消息处理只要一组方法中，有一个处理并返回真值，则不再执行后续。如果是我所描述的这样，那么这里的delegate应该和任务列表功能相似。有些语言的delegate只支持绑定一个方法，C#的delegate支持绑定多个方法，我这里是按C#的方式来实现的，因为在前一个C++项目中使用了一个自己做的delegate，效果是好到非常(测试比较好做)，所以这次有个python项目，我就直接先实现这个了。-- LiJie
* 的确 NewEdit 中有你所说的任务表和消息处理。不过感觉使用 + 法重载如果对你的类不是很清楚的话理解起来有些困难。可以提供类似于bind()或attach()之类的函数调用方式，我想更清楚一些。-- [[limodou]]
* +运算符在C#委托中看到的，一起还有-、-=、+、+=、=，使用非常方便，不过在python里，应该是无法直接重载=运算符吧？虽说可以使用property函数，不过会让调用者额外增加几行代码，所以不考虑。我打算把-、-=加进去，再加个clear方法，clear和+=结合使用就相当于=运算符的作用了，当然一起提供bind或attach可能会符合更多人习惯。-- LiJie
* 感谢Zoom Quiet整理版面，也算是给我做个示范，下次就知道怎么排了。-- LiJie