.Net委托类型解析

不像Windows API中使用C语言风格的函数指针这种不安全的方式进行回调。.Net中此功能使用使用更为安全和面向对象的委托(delegate)来完成。委托是一个类型安全的对象，它指向程序中另一个以后会被调用的方法（或多个方法）。

委托类型包含3个重要信息：

• 它所调用的方法的名称
• 该方法的参数（可选）
• 该方法的返回值（可选）

当上述信息被提供后，委托可以在运行时动态调用其指向的方法。很重要的一点：.Net中每个委托都被自动赋予同步或异步访问方法的能力。

定义委托

在C#中使用delegate关键字创建一个委托。我们称这种类为委托类。委托类的实例成为委托对象。从概念上说，委托对象是一种指向一个或多个方法（静态或非静态）的引用。要求是此委托匹配它指向的方法的签名。

如下委托可以指向一任何传入两个整数返回一个整数的方法。

C#

1	public delegate int BinaryOp(int x, int y);

• 定义委托后，系统生成一个派生自MulticastDelegate类的密封类。此类中有3个方法：
• Invoke()方法，用来以同步方式调用委托维护的每个方法。（不能在C#中显示调用此方法，Invoke()在后台被调用）
• BeginInvoke()与EndInvoke()方法在第二个线程上异步调用当前方法。

开发人员创建第二个执行线程的原因调用比较耗时的方法。（相当于委托顺带实现了一些System.Threading命名空间管理的线程问题）

这个委托的密封类大概如下：

C#

1 2 3 4 5 6 7

sealed class BinaryOp : System.MulticastDelegate {       public BinaryOp(object target, uint functionAddress);       public int Invoke(int x, int y);       public IAsyncResult BeginInvoke(int x, int y, AsyncCallback cb, object state);       public int EndInvoke(IAsyncResult result); }

下面给一个简单的委托示例：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// 这个委托指向任何一个传入两个整数并返回一个整数的方法     public delegate int BinaryOp(int x, int y);     #region SimpleMath class     public class SimpleMath     {         public int Add(int x, int y)         { return x + y; }         public int Subtract(int x, int y)         { return x - y; }         public static int SquareNumber(int a)         { return a * a; }     }     #endregion     class Program     {         static void Main(string[] args)         {             Console.WriteLine('***** Simple Delegate Example *****n');             // 创建一个指向SimpleMath.Add()方法的BinaryOp对象             SimpleMath m = new SimpleMath();             BinaryOp b = new BinaryOp(m.Add);             // 使用委托调用调用Add()方法             // 此处也是Invoke()被调用的位置             Console.WriteLine('n10 + 10 is {0}', b(10, 10));             Console.ReadLine();         }     }

委托类型安全的体现

如果传入一个与委托声明不匹配的方法，将在编译时报错。如上例中如果传入int SquareNumber(int)，将会导致一个编译时错误。

获取委托中调用函数列表的方法，示例：

假设有名为delObj的委托对象，使用如下方式得到调用函数的信息

C#

1 2 3

Delegate d in delObj.GetInvocationList()     Console.WriteLine('Method Name: {0}', d.Method);     Console.WriteLine('Target Name: {0}', d.Target);

Method属性表示调用的函数的签名，Target表示调用的函数所在的对象的类型名，所以如果委托调用的是一个静态方法则Target不会有任何显示，只有当委托调用的是一个实例方法时，Target属性才有值。

更完整的委托应用（示例来自C#与.Net3.0高级程序设计），代码：

汽车类：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

using System; using System.Collections.Generic; using System.Text; namespace CarDelegate {     public class Car     {         // 定义委托类型         public delegate void AboutToBlow(string msg);         public delegate void Exploded (string msg);         // 定义各自委托类型的对象         private AboutToBlow almostDeadList;         private Exploded explodedList;         // 将成员添加到调用列表         public void OnAboutToBlow(AboutToBlow clientMethod)         { almostDeadList += clientMethod; }         public void OnExploded(Exploded clientMethod)         { explodedList += clientMethod; }         // 由调用列表移除方法         public void RemoveAboutToBlow(AboutToBlow clientMethod)         { almostDeadList -= clientMethod; }         public void RemoveExploded(Exploded clientMethod)         { explodedList -= clientMethod; }         // 内部状态成员         private int currSpeed;         private int maxSpeed;         private string petName;         // 汽车坏了吗？         bool carIsDead;         public Car()         {             maxSpeed = 100;         }         public Car(string name, int max, int curr)         {             currSpeed = curr;             maxSpeed = max;             petName = name;         }         public void SpeedUp(int delta)         {             // 如果汽车坏了，触发Exploded事件             if (carIsDead)             {                 if (explodedList != null)                     explodedList('Sorry, this car is dead');             }             else             {                 currSpeed += delta;                 // 几乎要坏了？                 if (10 == maxSpeed - currSpeed                     && almostDeadList != null)                 {                     almostDeadList('Careful buddy!  Gonna blow!');                 }                 // 还好！                 if (currSpeed >= maxSpeed)                     carIsDead = true;                 else                     Console.WriteLine('->CurrSpeed = {0}', currSpeed);             }         }     } }

主函数：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

namespace CarDelegate {     class Program     {         static void Main(string[] args)         {             // 制造一辆车             Car c1 = new Car('SlugBug', 100, 10);             // 注册事件处理函数                       Car.Exploded d = new Car.Exploded(CarExploded);             c1.OnAboutToBlow(new Car.AboutToBlow(CarIsAlmostDoomed));             c1.OnAboutToBlow(new Car.AboutToBlow(CarAboutToBlow));             c1.OnExploded(d);             // 加速 (这将触发事件)             Console.WriteLine('n***** 加速 *****');             for (int i = 0; i < 6; i++)                 c1.SpeedUp(20);             // 由调用列表移除CarExploded方法             c1.RemoveExploded(d);             Console.WriteLine('n***** 加速 *****');             for (int i = 0; i < 6; i++)                 c1.SpeedUp(20);             Console.ReadLine();         }         public static void CarAboutToBlow(string msg)         { Console.WriteLine(msg); }         public static void CarIsAlmostDoomed(string msg)         { Console.WriteLine('Critical Message from Car: {0}', msg); }         public static void CarExploded(string msg)         { Console.WriteLine(msg); }     } }

对多路广播的支持

.Net委托内置多路，即一个委托可以维护一个可调用方法的列表而不只是单独一个方法，使用重载过的+=运算符可以向一个委托对象添加多个方法。关于对对路广播的支持可以参考上述示例。

在多路广播的支持中有一个需要注意的问题，一个委托调用的多个方法需要无参数且无返回值，因为在调用委托时，即使传入了参数也不知道具体应该传给哪一个方法，即使这些方法有返回值也不知道该接受那个函数的返回值。所以说直接不要调用有参数及返回值的方法，这点与事件关联多个事件处理方法时对处理方法签名的要求相同（可以参见本系列介绍事件的文章）。

注意：我们可以用调用方法的语法”调用”委托对象。这样会调用委托对象所引用的方法。（事件的触发与委托的调用相同，本来事件就是一个委托类型的对象）。这些方法的调用是在调用委托的方法所在的线程中完成的。这种调用称同步调用。

C#2.0编译器的委托类推测功能

C#编译器引入了在创建委托变量时可以推测其类型的能力。这样就可以将一个方法赋给隐式创建的委托对象。

示例：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class Program {   delegate void Deleg1();   delegate string Deleg2( string s );   static void f1() {     System.Console.WriteLine('f1() called.');   }   static string f2(string s) {     string _s=string.Format( 'f2() called with the param '{0}'.' , s );     System.Console.WriteLine( _s );     return _s;   }   public static void Main() {      Deleg1 d1 = f1; // 代替 Deleg1 d1 = new Deleg1( f1 );      d1();      Deleg2 d2 = f2; // 代替 Deleg2 d2 = new Deleg2( f2 );      string s = d2('hello');   } }

委托协变(covariance)

允许创建一个委托，其返回的对象的类型是继承关系的，示例代码：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// 简单的集成关系的两个类     class Car     {         public override string ToString()         {             return 'A stateless car';         }     }     class SportsCar : Car     {         public override string ToString()         {             return 'A stateless sports car';         }     }      class Program     {         // 定义一个返回Car或SportsCar的委托         public delegate Car ObtainVehicalDelegate();         // 委托指向目标         public static Car GetBasicCar()         { return new Car(); }         public static SportsCar GetSportsCar()         { return new SportsCar(); }         static void Main(string[] args)         {             ObtainVehicalDelegate targetA = new ObtainVehicalDelegate(GetBasicCar);             Car c = targetA();             Console.WriteLine(c);             // 协变允许指定这样的目标方法             ObtainVehicalDelegate targetB = new ObtainVehicalDelegate(GetSportsCar);             SportsCar sc = (SportsCar)targetB();             Console.WriteLine(sc);             Console.ReadLine();         }     }

委托逆变，其中参数具有集成关系，委托签名的参数类型（派生类型）比方法具有的参数类型（基类型）更具体。定义一个参数类型是派生类型的委托，这个委托可以接收具有基类型参数的方法，因为派生类型隐式转换成了基类型。注意此方法必须接收与委托签名相同的参数类型（派生类型），虽然方法的签名中参数是基类型。

接下来说一下委托在多线程程序中的应用，主角有两个：ThreadStart和ParameterizedThreadStart，它们都定义与System.Threading命名空间下。

使用这两个委托，你可以以编程方式创建此线程来分担一些任务，步骤如下：

1. 创建一个方法作为新线程的入口点。
2. 创建一个ParameterizedThreadStart（或ThreadStart）委托，并把之前所定义的方法传给委托的构造函数。
3. 创建一个Thread对象，并把ParameterizedThreadStart或ThreadStart委托作为构造函数的参数。
4. 建立任意初始化线程的特性（名称、优先级等）。
5. 调用Thread.Start()方法。

完成上述步骤，在第2步建立的委托所指向的方法将在线程中尽快开始执行。

ThreadStart委托指向一个没有参数、无返回值的方法，它在调用一个被设计用来仅仅在后台运行、而没有更多的交互时非常有用。它的局限在于无法给这个函数出入参数，所以在.Net2.0中出现了ParameterizedThreadStart了方法，它可以接受一个包含了任意个数的参数（传给它要调用的方法的）的Object类型对象做参数（即允许用户为新线程要执行的方法传入一个对象作为参数）。但注意这两种委托指向的函数的返回值都必须是void。

看看示例代码，首先是ThreadStart委托的：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public class Printer     {         public void PrintNumbers()         {             //具体实现省略         }     }     class Program     {         static void Main(string[] args)         {             Printer p = new Printer();             Thread bgroundThread = new Thread(new ThreadStart(p.PrintNumbers));             // 控制此线程是否在后台运行？             bgroundThread.IsBackground = true;             bgroundThread.Start();         } }

接下来的代码示例了ParameterizedThreadStart委托的使用：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

//包装参数的类     class AddParams     {         public int a;         public int b;         public AddParams(int numb1, int numb2)         {             a = numb1;             b = numb2;         }     }     class Program     {         static void Main(string[] args)         {             Console.WriteLine('主线程ID：{0}', Thread.CurrentThread.GetHashCode());             //生成要传入的参数             AddParams ap = new AddParams(10, 10);             Thread t = new Thread(new ParameterizedThreadStart(Add));             t.Start(ap);         }         //ParameterizedThreadStart委托调用的方法         //使用AddParams类对象做参数         public static void Add(object data)         {             if (data is AddParams)             {                 Console.WriteLine('后台线程ID： {0}', Thread.CurrentThread.GetHashCode());                 AddParams ap = (AddParams)data;                 Console.WriteLine('{0} + {1} is {2}', ap.a, ap.b, ap.a + ap.b);             }         } }

详细通过上面两段简单的代码示例，你已经对ThreadStart和ParameterizedThreadStart的使用有了全面的了解。

另外有一点需要说的，有些情况下可以省略这个委托对象的构造，即构造Thread对象时，直接向Thread的构造函数传入一个方法的名称，而不用先构造一个委托的对象。传入的方法既可以是静态方法也可以是实例方法。

    另外委托在异步编程中的作用见异步编程的文章

参考资料：

C#与.Net3.0高级程序设计

C#与.Net2.0实战

CLR via C# 第二版