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的函数与“服务员”对应
调用的时候ExitCallers象普通函数一样使用，但是this已经是委托接收方的了。

Delphi更简单， __closure关键字都不用
先声明“服务员”能接受什么样的申请：
type FSynchronizationCaller = function (synchronization_manager:TObject):Boolean of object;
后面的做法与BCB类似

这里着重讲VC的
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


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执行。