实例解析C＋＋/CLI之代理与事件

　代理类型的兼容性

　　一个代理类型只与它自身相兼容，与其他任何代理类型都不兼容，即使其他类型的包装函数均为同一类型。请看例3，非常明显，代理类型D1与函数A::M1与A::M2兼容，代理类型D2也与这些函数兼容，然而，这两个代理类型在标号5、6、8、9中并不能互换使用。

　　例3：

delegate void D1(); delegate void D2(); public struct A { 　static void M1() { /* ... */ } 　static void M2() { /* ... */ } }; void X(D1^ m) { /* ... */ } void Y(D2^ n) { /* ... */ } int main() { 　D1^ d1; 　/*1*/ d1 = gcnew D1(&A::M1); //兼容 　/*2*/ d1 = gcnew D1(&A::M2); //兼容 　D2^ d2; 　/*3*/ d2 = gcnew D2(&A::M1); //兼容 　/*4*/ d2 = gcnew D2(&A::M2); //兼容 　/*5*/ d1 = d2; //不兼容 　/*6*/ d2 = d1; //不兼容 　/*7*/ X(d1); //兼容 　/*8*/ X(d2); //不兼容 　/*9*/ Y(d1); //不兼容 　/*10*/ Y(d2); //兼容 }

　　代理类型的合并

　　一个代理实例实际上能包装多个函数，在这种情况下，被包装的函数集被维护在一个调用列表中，当合并两个代理实例时，它们的调用列表也以指定的顺序连接起来，并产生一个新的列表，而现有的两个列表并没有发生改变。当从调用列表中移除一个或多个函数时，也会产生一个新的列表，且原始列表不会发生变化。请看例4中的代码，每个函数调用后的输出都写在相应函数后。

　　例4：

using namespace System; delegate void D(int x); ref struct Actions { 　static void F1(int i) 　{ 　　Console::WriteLine("Actions::F1: {0}", i); 　} 　static void F2(int i) 　{ 　　Console::WriteLine("Actions::F2: {0}", i); 　} 　void F3(int i) 　{ 　　Console::WriteLine("instance of Actions::F3: {0}", i); 　} }; int main() { 　/*1*/ D^ cd1 = gcnew D(&Actions::F1); //包含F1的调用列表 　cd1(10); 　Actions::F1: 10 　/*2*/ D^ cd2 = gcnew D(&Actions::F2); //包含F2的调用列表 　cd2(15); 　Actions::F2: 15 　/*3*/ D^ cd3 = cd1 + cd2; //包含F1 + F2的调用列表 　cd3(20); 　Actions::F1: 20 　Actions::F2: 20 　/*4*/ cd3 += cd1; //包含F1 + F2 + F1的调用列表 　cd3(25); 　Actions::F1: 25 　Actions::F2: 25 　Actions::F1: 25 　Actions^ t = gcnew Actions(); 　D^ cd4 = gcnew D(t, &Actions::F3); 　/*5*/ cd3 += cd4; //包含F1 + F2 + F1 + t->F3的调用列表 　cd3(30); 　Actions::F1: 30 　Actions::F2: 30 　Actions::F1: 30 　instance of Actions::F3: 30 　/*6*/ cd3 -= cd1; //移除最右边的F1 　cd3(35); //调用F1、F2，t->F3 　Actions::F1: 35 　Actions::F2: 35 　instance of Actions::F3: 35 　/*7*/ cd3 -= cd4; //移除t->F3 　cd3(40); //调用F1、F2 　/*8*/ cd3 -= cd1; //移除F1 　cd3(45); //调用F2 　/*9*/ cd3 -= cd2; //移除F2，调用列表现在为空 　/*10*/Console::WriteLine("cd3 = {0}", 　(cd3 == nullptr ? "null" : "not null")); } Actions::F1: 40 Actions::F2: 40 Actions::F2: 45 cd3 = null

　　代理可通过 + 和 += 操作符来合并，如标号3、4中所示。两个单入口列表会连接成一个新的双入口列表，以先左操作数，后右操作数的顺序。新的列表被cd3引用，而现有的两个列表并未改变。在此要注意的是，不能合并不同类型的代理。

　　正如在标号4中所见，同一个函数可在一个调用列表中包装多次；而在标号5中，也说明了一个调用列表能同时包含类与实例函数。代理可通过 - 或 -= 操作符移除，如标号6中所示。

　　当同一个函数在调用列表中出现多次时，一个对它的移除请求会导致最右边的项被移除。在标号6中，这产生了一个新的三入口列表，其被cd3引用，且前一个列表保持不变（因为先前被cd3引用的列表现在引用计数为零，所以会被垃圾回收）。

　　当一个调用列表中的最后一项被移除时，代理将为nullptr值，此处没有空调用列表的概念，因为，根本就没有列表了。

　　例5中演示了另一个代理合并与移除的例子，正如标号3a与3b中所示，两个多入口调用列表是以先左操作数，后右操作数的顺序连接的。
如果想移除一个多入口列表，只有当此列表为整个列表中严格连续的子集时，操作才会成功。例如，在标号4b中，你可以移除F1和F2，因为它们是相邻的，对标号5b中的两个F2及标号6b中的F1、F2来说，道理也是一样的。但是，在标号7b中，列表中有两个连续的F1，所以操作失败，而结果列表则是最开始的列表，它包含有4个入口。

　　例5：

using namespace System; delegate void D(int x); void F1(int i) { Console::WriteLine("F1: {0}", i); } void F2(int i) { Console::WriteLine("F2: {0}", i); } int main() { 　D^ cd1 = gcnew D(&F1); 　D^ cd2 = gcnew D(&F2); 　/*1*/ D^ list1 = cd1 + cd2; // F1 + F2 　/*2*/ D^ list2 = cd2 + cd1; // F2 + F1 　D^ cd3 = nullptr; 　/*3a*/ cd3 = list2 + list1; // F2 + F1 + F1 + F2 　cd3(10); 　/*3b*/ cd3 = list1 + list2; // F1 + F2 + F2 + F1 　cd3(20); 　/*4a*/ cd3 = list1 + list2; // F1 + F2 + F2 + F1 　/*4b*/ cd3 -= cd1 + cd2; // F2 + F1 　cd3(30); 　/*5a*/ cd3 = list1 + list2; // F1 + F2 + F2 + F1 　/*5b*/ cd3 -= cd2 + cd2; // F1 + F1 　cd3(40); 　/*6a*/ cd3 = list1 + list2; // F1 + F2 + F2 + F1 　/*6b*/ cd3 -= cd2 + cd1; // F1 + F2 　cd3(50); 　/*7a*/ cd3 = list1 + list2; // F1 + F2 + F2 + F1 　/*7b*/ cd3 -= cd1 + cd1; // F1 + F2 + F2 + F1 　cd3(60); }