VC,BCB,C#,Delphi,Java的委托方案

委托(delegate)有委托接收方和委托发出方两个实例。委托接收方需要有一个函数实现，然后“拜托”别人调用。委托发出方需要有一个“服务员”接受委托接收方的“委托”请求，并记录调用入口，在非面向对象的时候用的是函数指针，现

在面向对象，需要保存this后调用才行，所以不同的语言用了不同的实现方法。

BCB, 使用关键字__closure

基本上可以解决。
先声明“服务员”能接受什么样的申请：
typedef

BOOL __fastcall(__closure

*FSynchronizationCaller)(SynchronizationManager

*synchronization_manager);

委托发出方，这里用ExitCallers保存调用入口
class

SynchronizationChecker
{
public:
FSynchronizationCaller

ExitCallers;
};
普通赋值语句就可以保存入口，实现“拜托”的工作
ExitCallers=FirstBranch;//FirstBranch的函数与“服务员”对应<

/span>
调用的时候ExitCallers象普通函数一样使用，但是this已经是委托接收方的了。

Delphi更简单， __closure关键字都不用
先声明“服务员”能接受什么样的申请：
type

FSynchronizationCaller = function

(synchronization_manager:TObject):Boolean of object;
后面的做法与BCB类似

这里着重讲VC的<

br>VC6,VC7：参照fast

delegate。但是比它还要快和易懂
首先声明委托通用类，即所有this的通用化
class

GenClass{};
//设置成与BCB类似的形式
#define __Closure

GenClass::
定义模板
template<class T,typename

FunctionType>
class

Closure
{
public:
   

FunctionType Func;
    T

*This;
};
template<typename

FunctionType,typename RetType=void *>
class

Delegate
{
    typedef

Closure<GenClass,FunctionType>

ClosureType;
    ClosureType

*ClosureClass;
public:
   

Delegate(){ClosureClass=0;}
   

~Delegate(){delete

ClosureClass;}
public:
  

    //--------------for no param

function
    template <class

X>
       

inline void bind(X *pthis, void (X::* function_to_bind)())//for void

return function
   

{
       

typedef void

(X::*LocalFunctionType)();
       

typedef Closure<X,LocalFunctionType>

X_ClosureType;
       

X_ClosureType *c=new

X_ClosureType;
       

c->This=pthis;
       

c->Func=function_to_bind;
       

ClosureClass=(ClosureType *)c;
   

}
    template <class

X>
       

inline void bind(X *pthis, RetType (X::* function_to_bind)())//for

other(not void) return function
   

{
       

typedef RetType

(X::*LocalFunctionType)();
       

typedef Closure<X,LocalFunctionType>

X_ClosureType;
       

X_ClosureType *c=new

X_ClosureType;
       

c->This=pthis;
       

c->Func=function_to_bind;
       

ClosureClass=(ClosureType

*)c;
   

}
    inline RetType

operator()()
   

{
       

typedef RetType (GenClass::*LocalFunctionType)();//convert to void to

void*,if it is

appointed
       

return

(ClosureClass->This->*(LocalFunctionType)ClosureClass->Func)();
   

}
  

    //--------------for 1 param

function
    template <class

X,typename

Param1>
       

inline void bind(X *pthis, void (X::* function_to_bind)(Param1))//for

void return function
   

{
       

typedef void

(X::*LocalFunctionType)(Param1);
       

typedef Closure<X,LocalFunctionType>

X_ClosureType;
       

X_ClosureType *c=new

X_ClosureType;
       

c->This=pthis;
       

c->Func=function_to_bind;
       

ClosureClass=(ClosureType *)c;
   

}
    template <class

X,typename

Param1>
       

inline void bind(X *pthis, RetType (X::*

function_to_bind)(Param1))//for other(not void) return

function
   

{
       

typedef RetType

(X::*LocalFunctionType)(Param1);
       

typedef Closure<X,LocalFunctionType>

X_ClosureType;
       

X_ClosureType *c=new

X_ClosureType;
       

c->This=pthis;
       

c->Func=function_to_bind;
       

ClosureClass=(ClosureType *)c;
   

}
    template <typename

Param1>
       

inline RetType operator()(Param1

p1)
   

{
       

typedef RetType (GenClass::*LocalFunctionType)(Param1);//convert to

void to void*,if it is

appointed
       

return

(ClosureClass->This->*(LocalFunctionType)ClosureClass->Func)(p1);
   

}
};
如果有更多的参数需要扩展响应的模板成员函数。
使用的时候
先声

明“服务员”能接受什么样的申请：
typedef

BOOL (__Closure *myfunc)(int a);
typedef

Delegate<myfunc,BOOL>

MyDelegete_t;

#include

<stdio.h>
struct

A
{
  BOOL f(int a){printf("%d",a);return

TRUE;}//与 myfunc对应
};

LRESULT CALLBACK

About(HWND hDlg, UINT message, WPARAM wParam, LPARAM

lParam)
{
  MyDelegete_t

d;
  A a;
 

d.bind(&a,A::f);
 

d(100);
 

............
}

其余部分与BCB类似，不再赘述。
要理解

C++如何用实现委托的，可以参照fastdelegate，和http:

//www.x5dj.com/UserForum/00100079/00009471.shtml
上述源代码从Duceland

Designer

打开例子后生成代码所得，模板这里下载http://duceland.com/Download/VC6.zip
<

br>
C#:
“服务员”能接受什么样的申请是自动完成的，只有保存要函数入口的地方就可以了，这就是进步啊，虽

然不是原创。
public delegate bool

DSynchronizationCaller(SynchronizationManager

synchronization_manager);
其余部分类似，不再赘述。

Java不是很精通，只好这样了
“服务员”是统一的，默认的
保存调用入口比较麻烦
public class

DSynchronizationCaller{
    public Method

m_Method;
    public Object

m_Object;
    public

boolean bind(Class cls,Object object,String

method_name){
   

    m_Object=object;

   

    // By obtaining a list of all declared

methods.
       

Method[] methods = cls.getDeclaredMethods();
       

for (int i=0; i<methods.length; i++) {
           

if(methods[i].getName().equals(method_name)){
           

    m_Method=methods[i];
           

    return true;
           

}
       

}
       

return false;
   

}

//调用的时候也不是很自然，用invoke

，参数被转入Object[]数组
    public Object

invoke(SynchronizationManager

synchronization_manager){
   

    try {
       

    Object result=m_Method.invoke(m_Object,

new Object[]

{synchronization_manager});
       

    return result;
   

    } catch (Exception e)

{System.err.println(e);}
   

    return null;
    }
};

事件通过bind绑定后用invoke执行。