首页 > 代码库 > C#3.0新特性——委托详解
C#3.0新特性——委托详解
前言
委托的定义
委托的本质：函数指针。让方法作为变量一样传递。
定义：委托是一种类型安全的函数回调机制， 它不仅能够调用实例方法，也能调用静态方法，并且具备按顺序执行多个方法的能力。
也就是说，委托可以在程序运行时调用不同方法函数，只要这个方法签名和委托签名保持一致。与函数指针不同的是，委托是类型安全的。所谓类型安全，是指在编译时编译器会检测委托对象的签名是否委托声明一致。
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DelegateSamples{ //声明一个委托，参数为string，无返回值 delegate void DelSamples(string msg); class Program { static void Main(string[] args) { DelSamples delSample = new Program().SpeakChinese; //调用实例方法 delSample += SpeakEnglish; //调用静态方法 delSample("KoalaStudio"); Console.ReadKey(); } private void SpeakChinese(string msg) { Console.WriteLine("你好，我是{0}",msg); } private static void SpeakEnglish(string msg) { Console.WriteLine("Hello,I‘m {0}",msg); } }}
委托的声明
简单委托
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DelegateSamples{ //声明一个委托，参数为string，无返回值 delegate void DelSamples(string msg); class Program { static void Main(string[] args) { //使用new关键字 DelSamples delSample = new DelSamples(new Program().SpeakChinese); delSample("Koala工作室"); //不使用new，自动推断委托类型 DelSamples delSample2 = SpeakEnglish; delSample2("KoalaStudio"); //利用Lambda表达式 DelSamples delSample3 = (string msg) => SpeakEnglish(msg); delSample3("KoalaStudio"); Console.ReadKey(); } private void SpeakChinese(string msg) { Console.WriteLine("你好，我是{0}",msg); } private static void SpeakEnglish(string msg) { Console.WriteLine("Hello,I‘m {0}",msg); } }}
匿名委托
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DelegateSamples{ //声明一个委托，参数为string，无返回值 delegate void DelSamples(string msg); class Program { static void Main(string[] args) { //匿名委托 DelSamples delSample4 = delegate(string msg) { Console.WriteLine("你好，我是{0}", msg); }; delSample4("KoalaStudio"); //利用Lambda表达式实现匿名委托 DelSamples delSample5 = (string msg) => { Console.WriteLine("你好，我是{0}", msg); }; delSample5("KoalaStudio"); Console.ReadKey(); } private void SpeakChinese(string msg) { Console.WriteLine("你好，我是{0}",msg); } private static void SpeakEnglish(string msg) { Console.WriteLine("Hello,I‘m {0}",msg); } }}
匿名委托的写法更加优雅，但是需要注意两点：1、在函数内部不能使用跳转语句跳出函数外部；2、不能使用ref和out等关键字
多播委托
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DelegateSamples{ //声明一个委托，参数为string，无返回值 delegate void DelSamples(string msg); class Program { static void Main(string[] args) { //多播委托可以带返回值，但是只有最后一个方法的返回值会被返回。 DelSamples delSample6 = new Program().SpeakChinese; delSample6 += SpeakEnglish; delSample6("KoalaStudio"); Console.ReadKey(); } private void SpeakChinese(string msg) { Console.WriteLine("你好，我是{0}",msg); } private static void SpeakEnglish(string msg) { Console.WriteLine("Hello,I‘m {0}",msg); } }}
多播委托可以连续执行函数,但是如果函数有返回值,那只有最后一个函数的返回值会被正确返回.
泛型委托
Action<T>
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DelegateSamples{ class Program { static void Main(string[] args) { /* Action<T>:封装只有一个参数（类型为T），不包括返回值的签名函数，它包括以下几种情况： * Action<T>、Action<T1,T2>、Action<T1,T2,T3>、Action<T1,T2,T3,T4> * 声明： * delegate void Action(); * delegate void Action<T1>(T1 arg1); * delegate void Action<T1,T2>(T1 arg1,T2 arg2); * delegate void Action<T1,T2,T3>(T1 arg1,T2 arg2,T3 arg3); * delegate void Action<T1,T2,T3,T4>(T1 arg1,T2 arg2,T3 arg3,T4 arg4); */ Action<string> action = SpeakEnglish; action("KoalaStudio"); Action<string, string> action2 = SpeakTwoLanguage; action2("KoalaStudio","Koala工作室"); Console.ReadKey(); } private void SpeakChinese(string msg) { Console.WriteLine("你好，我是{0}",msg); } private static void SpeakEnglish(string msg) { Console.WriteLine("Hello,I‘m {0}",msg); } private static void SpeakTwoLanguage(string msg1, string msg2) { Console.WriteLine("你好，我是{0}",msg1); Console.WriteLine("Hello,I‘m {0}",msg2); } }}
Func<T,TResult>:
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DelegateSamples{ class Program { static void Main(string[] args) { /* Func<T,TResult>:封装一个具有参数（类型为T），返回TResult类型值的签名函数，它包括以下几种情况： * Func<T,TResult>、Func<T1,T2,TResult>、Func<T1,T2,T3,TResult>、Func<T1,T2,T3,T4,TResult> * 声明： * ……略去 */ Func<string,string/*这是返回值类型*/> func = SpeakEnglish; func("KoalaStudio"); Func<string, string, string/*这是返回值类型*/> func2 = SpeakTwoLanguage; func2("KoalaStudio","Koala工作室"); Console.ReadKey(); } private static string SpeakEnglish(string msg) { return string.Format("Hello,I‘m {0}", msg); } private static string SpeakTwoLanguage(string msg1, string msg2) { Console.WriteLine("你好，我是{0}",msg1); Console.WriteLine("Hello,I‘m {0}",msg2); return string.Format("你好，我是{0};Hello,I‘m {1}", msg1,msg2); } }}
Predicate<T>
using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace DelegateSamples{ class Program { static void Main(string[] args) { /* bool Predicate<T>:表示定义一组条件并确定指定对象是否符合这些条件的方法。 * 通常，此类委托由Array和List类的几种方法使用，用于在集合中搜索元素。 * delegate bool Predicate<T>(T obj),如果obj符合此委托表示的方法中定义的条件，则返回true，否则返回false */ List<string> listString = new List<string>() { "a","abc","koala","xyz","take" }; //List对象的FindAll定义：public List<T> FindAll(Predicate<T> match)； //match 类型：System.Predicate<T> 委托，用于定义要搜索的元素应满足的条件。 //返回值 //类型：System.Collections.Generic.List<T> //如果找到，则为一个 List<T>，其中包含与指定谓词所定义的条件相匹配的所有元素；否则为一个空 List<T>。 Predicate<String> match = delegate(string word) { if (word.Length > 4) { return true; } return false; }; List<string> result = listString.FindAll(match); } }}
看到这里相信大家都已经感觉出来了，委托的申明和使用和类非常相似。没错，委托本质上就是一个类。实际上，我们用delegate关键字声明的所有委托都继承自System.MulticastDelegate类，这个类又继承自System.Delegate类，而System.Delegate类则继承自System.Object。尽管如此，我们并不能直接声明一个继承自System.MulticastDelegate类的委托，委托必须用delegate关键字声明。在我们声明委托时，编译器为我们完成了很多复杂的工作，有兴趣的朋友可以查阅相关资料。不过，即使不清楚编译器为我们干了什么也没有关系，只要知道在我们调用委托时，编译器自动为委托创建了BeginInvoke、EndInvoke和Invoke三个方法。BeginInvoke和EndInvoke方法用来实现异步委托调用，后面我们再详细介绍。
DelSamples delSample2 = SpeakEnglish;delSample2("KoalaStudio");//其实是调用编译器生成的Invoke方法delSample2.Invoke("KoalaStudio");写到这儿，其实已经把委托的基本概念介绍完了。接下去的内容会稍微复杂一些，刚刚接触委托的朋友可以跳过这部分，直接阅读委托与事件部分。
协变与逆变
MSDN的解释：从Visual Studio2008开始.NET引入了变体支持，用于委托中匹配方法签名和委托类型。这意味着，我们不仅可以为委托指派具有匹配签名的方法，而且可以指派这样的方法：它们返回与委托类型指定的派生类型相比，派生程度更大的类型（协变），或者接受相比之下，派生程度更小的类型的参数（逆变）。相当拗口，对不对？不知道它想说明什么。稍微休息一下，忘记之前那长串的描述。我们来想一个情形：面向对象的一个典型应用就是继承和多态。假如我们定义了一个委托，它返回的类型是一个基类对象。如果有个方法，它的参数签名符合我们定义的委托参数签名，但是返回的是继承该基类的子类对象，那么这个方法是否能够使用该委托？又比如，我们定义了一个委托，它具有指定的参数签名。如果有个方法，它的参数是委托签名中的方法参数的基类（委托方法签名中的参数派生自调用方法的参数），那么这个方法是否能够使用该委托？答案是可以的！这也就是MSDN想说的：协变就是委托的类型返回值是它所指向函数（即调用的方法）的返回值的基类；逆变就是委托的类型参数是它所指向函数的参数的派生类。协变允许方法具有的派生返回类型比委托中定义的更多。 逆变允许方法具有的派生参数类型比委托类型中的更少。MSDN上提供的一个协变的例子：
class Mammals{}class Dogs : Mammals{}class Program{ // 定义一个委托，返回基类. public delegate Mammals HandlerMethod(); public static Mammals MammalsHandler() { return null; } public static Dogs DogsHandler() { return null; } static void Test() { HandlerMethod handlerMammals = MammalsHandler; // 被允许. HandlerMethod handlerDogs = DogsHandler; }}
// Event hander接受一个EventArgs类型的参数.private void MultiHandler(object sender, System.EventArgs e){ label1.Text = System.DateTime.Now.ToString();}public Form1(){ InitializeComponent(); // KeyDown期望接受的是KeyEventArgs对象，但是我们给的是EventArgs对象 this.button1.KeyDown += this.MultiHandler; this.button1.MouseClick += this.MultiHandler;}
协变和逆变先介绍基本的应用，其它还包括泛型委托的协变和逆变，有兴趣的朋友可以参考MSDN里的例子，这里不再赘述。
异步委托
既然委托可以在运行时调用方法函数，如果调用的方法非常复杂耗时，主线程是不是会被阻塞以等待方法执行？我们看一段代码：
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;namespace DelegateSamples{ public delegate void delSample (); class Program { static void Main(string[] args) { delSample _sample = DoTask; _sample(); Console.WriteLine("执行另一项工作。"); Console.ReadKey(); } public static void DoTask() { Console.WriteLine("开始执行复杂工作。"); //线程阻塞5s，模拟进行复杂的工作。 Thread.Sleep(TimeSpan.FromSeconds(5)); Console.WriteLine("工作执行完毕。"); } }}
从下面的输出结果我们看到，委托调用的是主线程，因此复杂的方法函数会导致主线程阻塞，影响用户体验。那有没有办法可以改变呢？有！异步委托。
异步委托会从线程池中开辟一个新的线程用来调用方法，我们改动一下上面的代码，开启异步委托：
namespace DelegateSamples{ public delegate void delSample (); class Program { static void Main(string[] args) { delSample _sample = DoTask; _sample.BeginInvoke(null, null); Console.WriteLine("执行另一项工作。"); Console.ReadKey(); } public static void DoTask() { Console.WriteLine("开始执行复杂工作。"); //线程阻塞5s，模拟进行复杂的工作。 Thread.Sleep(TimeSpan.FromSeconds(5)); Console.WriteLine("工作执行完毕。"); } }}
看一下返回结果：
好像和我们预想的不太一样，主线程并没有等待委托的执行，而是继续执行下面的操作并退出。这是什么原因？还是和线程有关。默认线程池中的线程都是后台线程，主线程不会等待后台线程的执行，仿佛它根本不存在。那有办法解决这个问题吗？能不能让主线程等待委托线程执行完毕在退出？我们再看一下MSDN给出的解释：BeingInvoke方法启动异步委托，它具有和异步执行的方法相同的参数，同时还有两个可选参数。第一个参数是AsyncCallBack委托，该委托引用在异步调用完成时要调用的方法（即回调函数）；第二个参数是一个用户定义的对象，可以将信息传入回调函数。BeginInvoke立即返回而不等待异步调用完成（这就解释了上面的原因），但是会返回一个用于监控异步调用进度的IAsyncResult。EndInvoke方法检索异步调用的结果。在调用 BeginInvoke 之后随时可以调用该方法。如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成。我们改一下上面的代码：
namespace DelegateSamples{ public delegate void delSample (); class Program { static void Main(string[] args) { delSample _sample = DoTask; IAsyncResult result = _sample.BeginInvoke(null, null); while (result.IsCompleted) { //可以监控异步方法执行是否完成 //do task } _sample.EndInvoke(result); Console.WriteLine("执行另一项工作。"); Console.ReadKey(); } public static void DoTask() { Console.WriteLine("开始执行复杂工作。"); //线程阻塞5s，模拟进行复杂的工作。 Thread.Sleep(TimeSpan.FromSeconds(5)); Console.WriteLine("工作执行完毕。"); } }}
从输出结果看，委托线程确实阻塞了主线程，但是这依然会影响用户体验。我们希望的流程是：主线程调用委托线程后继续执行后面的逻辑业务，等逻辑业务完成后等待委托线程的返回。我们利用WaitHandle等待异步调用来解决这个问题，异步调用完成时会发出WaitHandle信号，我们可以通过调用WaitOne方法等待该信号。
namespace DelegateSamples{ public delegate void delSample (); class Program { static void Main(string[] args) { delSample _sample = DoTask; IAsyncResult result = _sample.BeginInvoke(null, null); //等待1s，执行主线程 result.AsyncWaitHandle.WaitOne(1,false);//_sample(); //_sample.EndInvoke(result); Console.WriteLine("执行另一项工作。"); _sample.EndInvoke(result); Console.ReadKey(); } public static void DoTask() { Console.WriteLine("开始执行复杂工作。"); //线程阻塞5s，模拟进行复杂的工作。 Thread.Sleep(TimeSpan.FromSeconds(5)); Console.WriteLine("工作执行完毕。"); } }}
再看一种回调模式
namespace DelegateSamples{ public delegate void delSample (); class Program { static void Main(string[] args) { delSample _sample = DoTask; _sample.BeginInvoke( delegate(IAsyncResult ar) { _sample.EndInvoke(ar); },null ); Console.WriteLine("执行另一项工作。"); Console.ReadKey(); } public static void DoTask() { Console.WriteLine("开始执行复杂工作。"); //线程阻塞5s，模拟进行复杂的工作。 Thread.Sleep(TimeSpan.FromSeconds(5)); Console.WriteLine("工作执行完毕。"); } }}
委托与事件
既然说了委托，自然离不开事件。在这里我不打算详细阐述事件机制及其相关的内容，后面我会再整理一篇有关事件的文章。我打算从委托出发，看看事件是怎么和委托扯上关系的。先看一段代码：
namespace DelegateSamples{ public class Program { static void Main(string[] args) { Publish publish = new Publish(); Subscribe subscribe = new Subscribe(); publish.delEventHandler += subscribe.OnLeaveMessage; publish.OnFire("我触发了委托！"); //调用委托 publish.delEventHandler("我触发了委托！"); Console.ReadKey(); } } //定义委托 public delegate void FireEventHandler(string msg); public class Publish { public FireEventHandler delEventHandler; public void OnFire(string msg) { if (delEventHandler != null) { delEventHandler(msg); } } } public class Subscribe { public Subscribe(){} public void OnLeaveMessage(string msg) { Console.WriteLine(msg); } }}
namespace DelegateSamples{ public class Program { static void Main(string[] args) { Publish publish = new Publish(); Subscribe subscribe = new Subscribe(); publish.delEventHandler += subscribe.OnLeaveMessage; publish.OnFire("我触发了委托！"); //调用委托 publish.delEventHandler("我触发了委托！"); Console.ReadKey(); } } //定义委托 public delegate void FireEventHandler(string msg); public class Publish { //public FireEventHandler delEventHandler; //不使用委托关键字delegate，采用event关键字 public event FireEventHandler delEventHandler; public void OnFire(string msg) { if (delEventHandler != null) { delEventHandler(msg); } } } public class Subscribe { public Subscribe(){} public void OnLeaveMessage(string msg) { Console.WriteLine(msg); } }}
publish.delEventHandler("我触发了委托！")，编译无法通过，这意味着外部不能直接调用委托变量，尽管他的属性还是public。因为加了event关键字，本质上是生成了私有的委托变量，减少了外部对类内部变量的修改权利。说到这里，我们再来看一下事件和委托的关系。在CLR综合那个事件模型是建立在委托机制上的，这就是他们之间的联系。委托是对方法的抽象，它将方法的调用与实现分离，方法的调用者（即委托的执行者）不知道方法内部的实现，而方法的实现者也不知道方法什么时候会被调用。正是因为委托具有这样的特性，才使得它理所当然的用来实现事件机制。因为事件被触发后执行什么操作，是由触发者决定的，而事件拥有者只知道什么情况下会触发事件，但不知道事件的具体实现。
最后，我们看一下事件的定义。事件用event关键字定义，其类型是一个委托类型，这体现了事件是通过委托来实现的。上面的代码已经展示了最基本的事件定义方式，即：自定义一个委托，然后再申明一个event事件。在.NET3.5开始，由于支持泛型，定义事件时可以不需要再自定义委托，统一采用System.EventHandler<TEventArgs>委托，如何改造上面代码，请大家自行修改。
C#3.0新特性——委托详解