注：里面使用了一个自己写的C++委托类Delegate，不是.net中的委托，关于这个委托详见我的C++委托类最终版。本文所写的代码是跨平台的纯C++实现。

一、简要说明。这里讲的“异步调用代理组件”，简要描述如下。假如有一个耗时的方法(不论它是本地调用还是远程调用)，这个调用耗时的原因是由于某些原因的阻塞，比如IO，通常可以把这个操作交给一个线程去处理，为了通用、高效，往往会实现一个领导者/追随者线程池。常见的处理方式是把每一个调用封装为一个CALL对象，把参数存储在这个对象中，然后调用它的处理方法，在这个处理方法中调用实际的处理函数，返回值将会存储在CALL对象的一个成员变量中。从我使用过的框架来看，大部分是采用编写一个接口描述语言，并由一些工具自动生成相应的同步/异步调用过程。有的还要求你为每一个调用编写一个派生类，甚至需要另外一个类处理返回值或异常，这几个类完成一个同步->异步的“映射”，处理起来非常繁琐。这些复杂性都是由于线程模型的复杂性引起的。二、思路。我构思了一个异步调用的基础组件，大致描述如下：

1

、每一个调用需要绑定一个实际调用的函数call和一个处理调用结果的函数call_result，它们的类型映身如下：

a.

如果call类型是void(...)，则call_result类型也是void(...)
b. 如果call类型是return_type(...)，即有返回值的，则call_result类型是void(return_type, ...)假定这个类的名字是Call，那么它的使用方式是：

void call_1 (int);

void call_result_1 (int);

Call <void(int)> call_1 (call_1, call_result_1);

int call_2 (int);

void call_result_2 (int, int);

Call <void(int)> call_2 (call_2, call_result_2);其中还要求能够接受绑定了this指针的成员函数(实际上就是对象指针、成员函数指针对)、仿函数，前面做委托类时已经可以做到这点了，所以暂时不考虑细节。

2

、现在假如要完成一个异步调用，整个过程就包括：a.生成一个异步调用对象并返回b.工作线程取出调用对象并执行，调用完成并回调通知。以上面的call_1为例，这3个步骤如下：

a.

生成一个异步调用对象并返回：
// 生成调用并保存参数，放入处理队列

Call <void(int)>* pCall = new Call <void(int)>(call_1, call_result_1);

pCall->init_arguments (arguments);

asynch_call_queue.push(call_1);

b.工作线程取出调用对象并执行：
CallBase* pCall = asynch_call_queue.front ();

asynch_call_queue.pop ();

pCall->call (); // 将执行调用并回调通知。

delete pCall; // 处理后事本文的重点并不在线程队列上，而是放在如何生成这个这个映射上面。三、实现。从上面可以整理出一个最简单的部分：
struct CallBase

{

    virtual ~CallBase () {}

    virtual void call () = 0;

};

typedef queue <CallBase*> AsynchCallQueue;

只要从CallBase上派生模板类Call即可，由于需要编写多个偏特化版本，比较耗时，这里先实现一个R(T)和void(T)特化版本：

template <typename T>

class Call

{

     Call ();

};

template <typename Ret, typename A>

class Call <Ret(A)> : public CallBase

{

     typename Delegate <Ret(A)> _call;

     typename Delegate <void(Ret,A)> _call_result;

     Ret      _response;

     A        _param1;

public:

     template <typename F1, typename F2>

     Call (F1 f1, F2 f2)

     {

         _call += f1;

         _call_result += f2;

     }

     void init_arguments (A a)

     {

         _param1 = a;

     }

     virtual void call ()

     {

         _response = _call (_param1);

         _call_result (_response, _param1);

     }

};

template <typename A>

class Call <void(A)> : public CallBase

{

     typename Delegate <void(A)> _call;

     typename Delegate <void(A)> _call_result;

     A        _param1;

public:

     template <typename F1, typename F2>

     Call (F1 f1, F2 f2)

     {

         _call += f1;

         _call_result += f2;

     }

     void init_arguments (A a)

     {

         _param1 = a;

     }

     virtual void call ()

     {

         _call (_param1);

         _call_result (_param1);

     }

};

四、简单测试效果：

int test1 (int n)

{

     cout << "test1: " << n << endl;

     return 3;

}

void test1_result (int ret, int n)

{

     cout << "test1_result: " << ret << ", " << n << endl;

}

void test2 (int n)

{

     cout << "test2" << n << endl;

}

void test2_result (int n)

{

     cout << "test2_result: " << n << endl;

}

AsynchCallQueue asynch_call_queue;

// 此处三行定义是由于VC2005 Beta 2的一个偏特化BUG，如果不定义，则会提示无法决议。

// g++编译器下可以直接去掉这几行。

Delegate <void(int,int)> d;

Delegate <void(int)> d1;

Delegate <int(int)> d2;

int main ()

{

     // 生成调用并放入队列

     {

         Call <int(int)>* pCall1 = new Call <int(int)> (test1, test1_result);

         pCall1->init_arguments (3);

         asynch_call_queue.push (pCall1);

         Call <void(int)>* pCall2 = new Call <void(int)> (test2, test2_result);

         pCall2->init_arguments (5);

         asynch_call_queue.push (pCall2);

     }

     // 模拟另一线程取出并执行

     {

         CallBase* pCall;

         while (!asynch_call_queue.empty ())

         {

              pCall = asynch_call_queue.front ();

              pCall->call ();

              asynch_call_queue.pop ();

              delete pCall;

         }

     }

     return 0;

}

五、补充。

这里说的“异步调用代理组件”，其实就是Call类，由于使用了委托类，所以绑定异步调用更灵活。

本文只是简单的一点思路，离实用的距离还有：

1、   未加入线程池，未实现同步队列；

2、   模板类参数类型未严格约束，可能导致某些编译错误很难找出错误原因；

3、   这个模型没有处理“生成调用和回调处于同一线程”这个要求，这个会增加一些复杂度，比如需要为每个call映射线程ID、要为每个call分配全局唯一ID，为了让调用过程由线程池完成，调用结果由生成调用的线程完成，需要把这2个部分分离；

4、   需要加入调用超时设置；

5、   基于第3条和第4条，还需要实现使用异步模型模拟同步调用机制；

6、这里给出的代码只适用于传值参数(指针也适合)，引用类型暂未考虑。

以上只是现在的初步设想，可能有遗漏之处。

六、发点劳骚，提点建议。

我不明白为何C++标准不把委托置于标准之内，c++0x里面好像也没看到，不过还需要几年时间，也可能会加入。

另外在写委托模板类和这里的Call类时，就觉得处理不同个数的参数实在繁琐，假如C++模板中加入下面这个东西多好啊。。。(我称它为模板宏，其实就是加入一个typelist关键字并运行这种机制，相应还有valuelist，不过想法还不成熟)

template <typename Ret, typelist ArgTypes>

class Call <Ret(ArgTypes)>

{

     typename Delegate <Ret(ArgTypes)> _call;

     typename Delegate <void(Ret,ArgTypes)> _call_result;

     ArgTypes _params;

     Ret      _response;

public:

     template <typename F1, typename F2>

     Call (F1 f1, F2 f2)

     {

         _call += f1;

         _call_result += f2;

     }

     void init_arguments (ArgTypes args)

     {

         _params = args;

     }

     virtual void call ()

     {

         _response = _call (_params);

         _call_result (_response, _params);

     }

}

template <typename Ret, typelist ArgTypes>

class Call <Ret(ArgTypes)>

{

     typename Delegate <void(ArgTypes)> _call;

     typename Delegate <void(ArgTypes)> _call_result;

     ArgTypes _params;

public:

     template <typename F1, typename F2>

     Call (F1 f1, F2 f2)

     {

         _call += f1;

         _call_result += f2;

     }

     void init_arguments (ArgTypes args)

     {

         _params = args;

     }

     virtual void call ()

     {

          _call (_params);

         _call_result (_params);

     }

}

一个typelist就代替了这么多版本的偏特化，不知道这个想法是不是可行。