首页 > 代码库 > C#秘密武器之委托
C#秘密武器之委托
概述
在C#的世界里，委托是无处不在，尤其在.NET自己封装的框架里到处都有其身影，所以掌握委托就很有必要了！那什么是委托呢？其实委托就是一种数据类型，跟int等东东差不多，只不过在使用时要自己先去构建一个委托数据类型（不像int微软已为你准备好），然后声明一个委托类型的变量，并为其赋值，赋值的对象只能是方法，最后通过委托变量就可以进行方法调用了!
委托的简单使用
如下定义了一个委托类型 - Calculator：
delegate int Calculator (int x);
此委托适用于任何有着int返回类型和一个int类型参数的方法，如：
static int Double (int x) { return x * 2; }创建一个委托实例，将该此方法赋值给该委托实例：
Calculator c = new Calculator(Double);
也可以简写成：
Calculator c = Double;
这个方法可以通过委托调用：
int result = c(2);
下面是完整代码：
delegate int Calculator(int x);class Program { static int Double(int x) { return x * 2; } static void Main(string[] args) { Calculator c = Double; int result = c(2); Console.Write(result); Console.ReadKey(); }}一、多路委托
委托类实际继承于MulticastDelegate，这使委托对象支持多路委托，即委托对象可以绑定多个方法。当输入参数后，每个方法会“按顺序”执行！这里不建议委托方法有返回值，即使有返回值，多路委托中的方法也只能返回最后一个方法的返回值！
例如：
MyDelegate d = MyMethod1;// “+=” 用来添加，同理“-=”用来移除。d += MyMethod2;// d -= MyMethod2
调用时，按照方法被添加的顺序依次执行。注意，对于委托，+= （实质是调用的Delegate的Combine方法）和 -= （实质是调用的Delegate的Remove方法）
MyDelegate d;d += MyMethod1;// 相当于MyDelegate d = MyMethod1;
我们先定义一个委托（ProgressReporter），然后定义一个匹配方法（Match）来执行该委托中的所有方法。如下：
public delegate void ProgressReporter(int percentComplete);public class Utility { public static void Match(ProgressReporter p) { if (p != null) { for (int i = 0; i <= 10; i++) { p(i * 10); System.Threading.Thread.Sleep(100); } } }}然后我们需要两个监视进度的方法，一个把进度写到Console，另一个把进度写到文件。如下：
class Program { static void Main(string[] args) { ProgressReporter p = WriteProgressToConsole; p += WriteProgressToFile; Utility.Match(p); Console.WriteLine("Done."); Console.ReadKey(); } static void WriteProgressToConsole(int percentComplete) { Console.WriteLine(percentComplete+"%"); } static void WriteProgressToFile(int percentComplete) { System.IO.File.AppendAllText("progress.txt", percentComplete + "%"); }}运行结果：
注意：同一类型的委托变量可以相加减！
二、委托体现的插件式编程思想
其实就是把委托（方法）作为一种方法的参数来进行传递，由于同一委托可以接收多种不同实现的方法（插件），从而实现了一种插件式编程，实现动态的扩展。
例如，我们有一个Utility类，这个类实现一个通用方法（Calculate）,用来执行任何有一个整型参数和整型返回值的方法。这样说有点抽象，下面来看一个例子：
delegate int Calculator(int x);class Program { static int Double(int x) { return x * 2; } static void Main(string[] args) { int[] values = { 1,2,3,4}; Utility.Calculate(values, Double); foreach (int i in values) Console.Write(i + " "); // 2 4 6 8 Console.ReadKey(); }}class Utility { public static void Calculate(int[] values, Calculator c) { for (int i = 0; i < values.Length; i++) values[i] = c(values[i]); }}这个例子中的Utility是固定不变的，程序实现了整数的Double功能。我们可以把这个Double方法看作是一个插件，如果将来还要实现诸如求平方、求立方的计算，我们只需向程序中不断添加插件就可以了。
如果Double方法是临时的，只调用一次，若在整个程序中不会有第二次调用，那么我们可以在Main方法中更简洁更灵活的使用这种插件式编程，无需先定义方法，使用λ表达式即可，如：
...Utility.Calculate(values, x => x * 2);...
三、静态方法和实例方法对于委托的区别
当一个类的实例的方法被赋给一个委托对象时，在上下文中不仅要维护这个方法，还要维护这个方法所在的实例。System.Delegate 类的Target属性指向的就是这个实例。举个例子：
class Program { static void Main(string[] args) { X x = new X(); ProgressReporter p = x.InstanceProgress; p(1); Console.WriteLine(p.Target == x); // True Console.WriteLine(p.Method); // Void InstanceProgress(Int32) } static void WriteProgressToConsole(int percentComplete) { Console.WriteLine(percentComplete+"%"); } static void WriteProgressToFile(int percentComplete) { System.IO.File.AppendAllText("progress.txt", percentComplete + "%"); }}class X { public void InstanceProgress(int percentComplete) { // do something }}但对于静态方法，System.Delegate 类的Target属性是Null，所以将静态方法赋值给委托时性能更优。
四、泛型委托
如果你知道泛型，那么就很容易理解泛型委托，说白了就是含有泛型参数的委托，例如：
public delegate T Calculator<T> (T arg);
我们可以把前面的例子改成泛型的例子，如下：
public delegate T Calculator<T>(T arg);class Program { static int Double(int x) { return x * 2; } static void Main(string[] args) { int[] values = { 1, 2, 3, 4 }; Utility.Calculate(values, Double); foreach (int i in values) Console.Write(i + " "); // 2 4 6 8 Console.ReadKey(); }}class Utility { public static void Calculate<T>(T[] values, Calculator<T> c) { for (int i = 0; i < values.Length; i++) values[i] = c(values[i]); }}Func委托
委托 Func 支持 0~16 个参数，Func 必须具有返回值
public delegate TResult Func<TResult>（）
public delegate TResult Func<T1,TResult>（T1 obj1）
public delegate TResult Func<T1,T2,TResult>（T1 obj1,T2 obj2）
public delegate TResult Func<T1,T2,T3,TResult>（T1 obj1,T2 obj2,T3 obj3）
............
public delegate TResult Func<T1,T2,T3,......,T16,TResult>（T1 obj1,T2 obj2,T3 obj3,......,T16 obj16）
static void Main(string[] args) { Func<double, bool, double> func = Account; double result=func(1000, true); Console.WriteLine("Result is : "+result); Console.ReadKey(); } static double Account(double a,bool condition) { if (condition) return a * 1.5; else return a * 2; }
Action委托
Action<T> 的返回值为 void，也就是没有返回值！
Action 支持0~16个参数，可以按需求任意使用。
public delegate void Action（）
public delegate void Action<T1>（T1 obj1）
public delegate void Action<T1，T2> （T1 obj1, T2 obj2）
public delegate void Action<T1，T2，T3> （T1 obj1, T2 obj2，T3 obj3）
............
public delegate void Action<T1，T2，T3，......，T16> （T1 obj1, T2 obj2，T3 obj3，......，T16 obj16）
static void Main(string[] args) { Action<string> action=ShowMessage; action("Hello World"); Console.ReadKey(); } static void ShowMessage(string message) { MessageBox.Show(message); }
Predicate<T>委托
Predicate只有一个参数，且返回值总是为bool类型！
public delegate bool Predicate<T>（T obj）
internal class PredicateDelegate { public bool PredicateMethod(int x ) { return x > 50; } } PredicateDelegate predicateDelegate = new PredicateDelegate(); // 只有一个参数 并返回bool 值 Predicate<int> predicate = predicateDelegate.PredicateMethod; bool results =predicate(60); Console.WriteLine(results);
Comparison委托
public delegate int Comparison<in T>(T x, T y)
为返回int类型的内置委托。T是要比较的对象的类型，而返回值是一个有符号整数，指示 x 与 y 的相对值，如下表所示：
值 | 含义 |
|---|---|
小于 0 | x 小于 y。 |
0 | x 等于 y。 |
大于 0 | x 大于 y。 |
此委托由 Array 类的 Sort<T>(T[], Comparison<T>) 方法重载和 List<T> 类的 Sort(Comparison<T>) 方法重载使用，用于对数组或列表中的元素进行排序。
五、匿名方法和Lambda表达式
匿名方法
如果某个委托变量需要绑定的方法只用一次的话，其实是没有必要为方法起名的，直接用匿名方法会比较好！我们总是使用 delegate（）{......} 的方式建立匿名方法！
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(); } }}
Lambda表达式
匿名方法的优雅写法就是Lambda表达式！
注意事项：
①Lambda表达式中的参数列表（参数数量、类型和位置）必须与委托相匹配；
②表达式中的参数列表不一定需要包含类型，除非委托有ref或out关键字（此时必须显示声明）；
③如果没有参数，必须使用一组空的圆括号；
static void Main(string[] args) { Action<int> action = (x) => { x = x + 500; Console.WriteLine("Result is : " + x); }; action.Invoke(1000); Console.ReadKey(); }
六、异步委托
public delegate int Ad(int x,int y); static void Main(string[] args) { xu xus = new xu(); Ad a = new Ad(Add); Console.WriteLine(a(3, 3)); Console.WriteLine("start"); Console.ReadLine(); }static int Add(int x, int y) { Thread.Sleep(2000); return x + y; }
运行这段代码 会先停顿2秒钟之后再显示6 和start 因为我使用了sleep这个方法 它使该线程休眠2秒钟，所以会在2秒之后显示信息，但是这对用户体验来说是非常糟糕的，那我们怎么改善呢？看看如下代码
public delegate int Ad(int x,int y); static void Main(string[] args) { xu xus = new xu(); Ad a = new Ad(Add); Console.WriteLine(a(3, 3)); // Console.WriteLine("start"); IAsyncResult isa= a.BeginInvoke(3, 3, null, null); while (!isa.IsCompleted) { Console.WriteLine("未完成"); } int s= a.EndInvoke(isa); Console.WriteLine(s.ToString()); Console.ReadLine(); } static int Add(int x, int y) { Thread.Sleep(2000); return x + y; } static int ex(int x, int y) { //Thread.Sleep(5000); return x - y; }
这里我们使用了begininvoke方法来异步执行 委托方法返回一个IAsyncResult 类型的值 代表委托执行的状态，使用一个while循环 来判断IsCompleted 如果没有完成异步调用则不断显示“未完成” 如果完成endinvoke 则返回结果。但是这里需要不断的询问操作完成状态 那么我们怎样让委托异步调用完成之后主动通知我们呢？ 看看如下代码
public delegate int Ad(int x,int y); static void Main(string[] args) { xu xus = new xu(); Ad a = new Ad(Add); Console.WriteLine(a(3, 3)); IAsyncResult isa= a.BeginInvoke(3, 3, new AsyncCallback(call), "edit by xyl"); //执行你想执行的代码 这里我们还是用IsCompleted来代替 while (!isa.IsCompleted) { Console.WriteLine("未完成"); } Console.ReadLine(); } static void call(IAsyncResult isa) { AsyncResult ar = (AsyncResult)isa; Ad a = (Ad)ar.AsyncDelegate; Console.WriteLine("this is {0},{1}",a.EndInvoke(isa),ar.AsyncState); } static int Add(int x, int y) { Thread.Sleep(2000); return x + y; } static int ex(int x, int y) { //Thread.Sleep(5000); return x - y; } }
这里我们使用了一个call方法 注意它是没有返回值的。把IAsyncResult转换成AsyncResult注意少了个I然后转换成AD 类型的委托 最后endinvoke 来返回值 这样在委托异步执行完成之后会自动通知方法。
注意：回调函数是在 ThreadPool线程上进行的，因此主线程将继续执行。ThreadPool线程是后台线程，这些线程不会在主线程结束后保持应用程序的运行，因此主线程必须休眠足够长的时间以便回调完成。我们也可以在主线程完成操作后调用IsCompleted属性判断委托函数是否完成。
七、事件
事件其实就是某种类型的委托，在给事件赋值时，用符合该委托的方法就行！
public delegate void PriceChangedHandler (decimal oldPrice, decimal newPrice);public class IPhone6{ public event PriceChangedHandler PriceChanged;}事件的使用和委托完全一样，只是多了些约束。下面是一个简单的事件使用例子：
public delegate void PriceChangedHandler(decimal oldPrice, decimal newPrice);public class IPhone6 { decimal price; public event PriceChangedHandler PriceChanged; public decimal Price { get { return price; } set { if (price == value) return; decimal oldPrice = price; price = value; // 如果调用列表不为空，则触发。 if (PriceChanged != null) PriceChanged(oldPrice, price); } }}class Program { static void Main() { IPhone6 iphone6 = new IPhone6() { Price = 5288 }; // 订阅事件 iphone6.PriceChanged += iphone6_PriceChanged; // 调整价格（事件发生） iphone6.Price = 3999; Console.ReadKey(); } static void iphone6_PriceChanged(decimal oldPrice, decimal price) { Console.WriteLine("年终大促销，iPhone 6 只卖 " + price + " 元， 原价 " + oldPrice + " 元，快来抢！"); }}运行结果：
有人可能会问，如果把上面的event关键字拿掉，结果不是一样的吗，到底有何不同？
没错可以用事件的地方就一定可以用委托代替。
但事件有一系列规则和约束用以保证程序的安全可控，事件只有 += 和 -= 操作，这样订阅者只能有订阅或取消订阅操作，没有权限执行其它操作。如果是委托，那么订阅者就可以使用 = 来对委托对象重新赋值（其它订阅者全部被取消订阅），甚至将其设置为null，甚至订阅者还可以直接调用委托，这些都是很危险的操作，广播者就失去了独享控制权。
事件保证了程序的安全性和健壮性。
事件的标准模式
.NET 框架为事件编程定义了一个标准模式。设定这个标准是为了让.NET框架和用户代码保持一致。System.EventArgs是标准模式的核心，它是一个没有任何成员，用于传递事件参数的基类。
按照标准模式，我们对于上面的iPhone6示例进行重写。首先定义EventArgs：
public class PriceChangedEventArgs : EventArgs { public readonly decimal OldPrice; public readonly decimal NewPrice; public PriceChangedEventArgs(decimal oldPrice, decimal newPrice) { OldPrice = oldPrice; NewPrice = newPrice; }}然后为事件定义委托，必须满足以下条件：
- 必须是 void 返回类型；
- 必须有两个参数，且第一个是object类型，第二个是EventArgs类型（的子类）；
- 它的名称必须以EventHandler结尾。
由于考虑到每个事件都要定义自己的委托很麻烦，.NET 框架为我们预定义好一个通用委托System.EventHandler<TEventArgs>：
public delegate void EventHandler<TEventArgs> (object source, TEventArgs e) where TEventArgs : EventArgs;
如果不使用框架的EventHandler<TEventArgs>，我们需要自己定义一个：
public delegate void PriceChangedEventHandler (object sender, PriceChangedEventArgs e);
如果不需要参数，可以直接使用EventHandler（不需要<TEventArgs>）。有了EventHandler<TEventArgs>，我们就可以这样定义示例中的事件：
public class IPhone6 { ... public event EventHandler<PriceChangedEventArgs> PriceChanged; ...}最后，事件标准模式还需要写一个受保护的虚方法来触发事件，这个方法必须以On为前缀，加上事件名(PriceChanged)，还要接受一个EventArgs参数，如下：
public class IPhone6 { ... public event EventHandler<PriceChangedEventArgs> PriceChanged; protected virtual void OnPriceChanged(PriceChangedEventArgs e) { if (PriceChanged != null) PriceChanged(this, e); } ...}下面给出完整示例：
public class PriceChangedEventArgs : System.EventArgs { public readonly decimal OldPrice; public readonly decimal NewPrice; public PriceChangedEventArgs(decimal oldPrice, decimal newPrice) { OldPrice = oldPrice; NewPrice = newPrice; }}public class IPhone6 { decimal price; public event EventHandler<PriceChangedEventArgs> PriceChanged; protected virtual void OnPriceChanged(PriceChangedEventArgs e) { if (PriceChanged != null) PriceChanged(this, e); } public decimal Price { get { return price; } set { if (price == value) return; decimal oldPrice = price; price = value; // 如果调用列表不为空，则触发。 if (PriceChanged != null) OnPriceChanged(new PriceChangedEventArgs(oldPrice, price)); } }}class Program { static void Main() { IPhone6 iphone6 = new IPhone6() { Price = 5288M }; // 订阅事件 iphone6.PriceChanged +=iphone6_PriceChanged; // 调整价格（事件发生） iphone6.Price = 3999; Console.ReadKey(); } static void iphone6_PriceChanged(object sender, PriceChangedEventArgs e) { Console.WriteLine("年终大促销，iPhone 6 只卖 " + e.NewPrice + " 元， 原价 " + e.OldPrice + " 元，快来抢！"); }}运行结果：
C#秘密武器之委托