C# delegate

之前，用到Invoke，其中涉及到delegate。

C#中的委托类似于C或C++中的函数指针。使用委托使程序员可以将方法引用封装在委托对象内。然后可以将该委托对象传递给可调用所引用方法的代码，而不必在编译时知道将调用哪个方法。与C或C++中的函数指针不同，委托是面向对象、类型安全的，并且是安全的。

通俗的来讲，委托除了必须指定delegate关键字和没有方法实体之外，和指定方法没有更多区别。你可以当它是一个占位符，比如你在写代码的时候并不知道你将要处理的是什么。你只需要知道你将要引入的参数类型和输出类型是什么并定义它即可。这就是书本上所传达的方法签名必须相同的意思。

 

下面我们来定义一个基本的委托：

 

01.public class Test  
02.{  
03.    //定义委托   
04.    public delegate void D_Math(int a, int b);  
05.    public void Add(int a, int b)  
06.    {  
07.        Console.WriteLine("Add方法结果：{0}", a + b);  
08.    }  
09.    public void Cut(int a, int b)  
10.    {  
11.        Console.WriteLine("Cut方法结果：{0}", a - b);  
12.    }  
13.}  
14.[TestClass]  
15.public class UnitTest1  
16.{  
17.    [TestMethod]  
18.    public void TestMethod1()  
19.    {  
20.        Test t = new Test();  
21.        Test.D_Math D = new Test.D_Math(t.Add);//委托实例化,也可Test.D_Math D =t.Add;   
22.        D += t.Cut;//委托可以以队列方式执行多个方法,以+=运算符或者-=来增加或者取消队列中的方法   
23.        D(5, 6);  
24.  
25.    }  
26.} 

执行结果：

以上看出来委托实用的地方了吗？即委托可以执行任何引入参数类型相同且返回类型相同的方法，甚至可以执行签名相同的方法队列。

那么我们的方法签名（即引入参数和输出参数）真的必须与委托完全一致吗？答：不是的，我们不能忽略协变与逆变。

我们这里简单介绍一下协变与逆变的知识。

“协变”是指能够使用与原始指定的派生类型相比，派生程度更大的类型。

“逆变”则是指能够使用派生程度更小的类型。

那么，我们的委托也是接受协变与逆变的。

意思是，如果定义一个delegate，那么不仅仅签名完全相同的方法可以赋值给delegate变量。

如果一个方法的参数表符合delegate声明，但返回的类型是（delegate声明返回类型）的派生类，那也可以将这个方法赋值给这个delegate变量。

如果一个方法的返回类型符合delegate的声明，但参数是（delegate声明参数类型）的祖先类，那也可以将这个方法赋值给这个delegate变量。

如果一个方法的参数和返回类型都符合上面两行的假设，那也可以将这个方法赋值给这个delegate变量。

以下以两个简单示例解释协变与逆变：

协变：

csharp] view plaincopyprint?
01.      public class A { }  
02.    public class B:A { }//B继承自A   
03.    public class Test  
04.    {  
05.        //定义委托   
06.        public delegate A D_Math();  
07.        public B Add()  
08.        {  
09.            return new B();  
10.   
11.        }  
12.        public A Add2()   
13.        {  
14.            return new A();  
15.        }  
16.    }  
17.    [TestClass]  
18.    public class UnitTest1  
19.    {  
20.        [TestMethod]  
21.        public void TestMethod1()  
22.        {  
23.            Test.D_Math d = new Test.D_Math(new Test().Add);//委托返回A,而Add方法返回B,此为协变。   
24.        }  
25.    }  

逆变：

01.public class A { }  
02.   public class B:A { }//B继承自A   
03.   public class Test  
04.   {  
05.       //定义委托   
06.       public delegate void D_Math(B b);  
07.       public void Add(B b)  
08.       {  
09.  
10.       }  
11.       public void Add2(A a)   
12.       {  
13.  
14.       }  
15.   }  
16.   [TestClass]  
17.   public class UnitTest1  
18.   {  
19.       [TestMethod]  
20.       public void TestMethod1()  
21.       {  
22.           Test.D_Math d = new Test.D_Math(new Test().Add2);//委托引入参数B,而Add方法参数为A类型,此为协逆变。   
23.       }  
24.   }  

我认为delegate也算是一种方法，只不过它没有直接定义方法的内容，而是等待别人再来搭载。只要定义了delegate的参数与返回值，我们就可以用它来执行有着相同参数与返回值的其他方法。