CLR VIA C#委托
1.什么是委托？委托就是一种回调函数的机制，将函数作为一个参数传递给其他对象，当该对象需要的时候调用委托来达到回调函数的目的。
通俗点的说法是：你将一件事情交给别人去做。例如你QQ里的自动回复，为了第一时间回复别人，你不可能一直守在QQ面前一有消息通知你就回复。所以你只好定义一个回复的方法，将这个方法交给QQ，告诉QQ当有消息过来的时候就调用你这个方法。QQ会给你这个方法传一个参数"对不起，我现在很忙balabala..."，然后自动回复给对方
==========================================================我是解释的分割=========================================================
其实这里有两种情况，单就翻译而言，我觉得上面的解释比较符合“委托”的意思，就是你让别人帮你做你应该去做的事。而事件是一种特殊的委托，是别人通知你该做某事了，而做事的人还是你自己。实际委托是一个类型，把一个方法传递给委托会新创建一个对象，这个对象对方法进行包装。所以不管是哪种情况，都是委托对象调用方法。
=============================================================================================================================
2.其实委托很早就有了，说白了他只是函数指针在C#中的实现而已，不过在C#里他是类型安全的，并且可以顺序调用多个委托，支持静态方法和实例方法的调用。
3.正所谓无图无真相，没代码说JB，下面来看下委托实现的简单代码（以下代码来自CLRVIAC#）
using System; using System.Linq; using System.IO; using System.Text; using System.Threading; using System.Windows.Forms; using System.Reflection; public sealed class Program { public static void Main() { DelegateIntro.Go(); } } internal sealed class DelegateIntro { // 申明一个委托类型，他的实例（既然委托是一个类型，那么他其实会创建一个实例）引用一个方法，该方法接收一个Int32型的参数，返回空值 internal delegate void Feedback(Int32 value); public static void Go() { StaticDelegateDemo(); } private static void StaticDelegateDemo() { Console.WriteLine("----- Static Delegate Demo -----"); Counter(1, 3, null); Counter(1, 3, new Feedback(DelegateIntro.FeedbackToConsole)); Counter(1, 3, new Feedback(FeedbackToMsgBox)); Console.WriteLine(); } private static void Counter(Int32 from, Int32 to, Feedback fb) { for (Int32 val = from; val <= to; val++) { if (fb != null) fb(val); } } private static void FeedbackToConsole(Int32 value) { Console.WriteLine("Item=" + value); } private static void FeedbackToMsgBox(Int32 value) { MessageBox.Show("Item=" + value); } }
以上是委托调用静态方法的例子，记住Counter这个函数接收3个参数，将遍历从from到to的值，并将它传递给FeedBack这个委托对象fb饮用的方法，然后调用该方法。
正如前面所说，这里创建了一个委托对象Feedback的一个实例
new Feedback(DelegateIntro.FeedbackToConsole)
，这个实例通过构造器传入的参数（方法签名）对方法进行了包装。然后将这个实例传入Counter函数中。需要注意的是这个委托实例包装的是一个静态方法，所以实例的内部并没有对其他对象的引用。
委托调用实例方法的例子如下
using System; using System.Linq; using System.IO; using System.Text; using System.Threading; using System.Windows.Forms; using System.Reflection; public sealed class Program { public static void Main() { DelegateIntro.Go(); } }
internal sealed class DelegateIntro { // 申明一个委托类型，他的实例（既然委托是一个类型，那么他其实会创建一个实例）引用一个方法，该方法接收一个Int32型的参数，返回空值 internal delegate void Feedback(Int32 value); public static void Go() { InstanceDelegateDemo(); } private static void InstanceDelegateDemo() { Console.WriteLine("----- Instance Delegate Demo -----"); DelegateIntro di = new DelegateIntro(); Counter(1, 3, new Feedback(di.FeedbackToFile)); } private static void Counter(Int32 from, Int32 to, Feedback fb) { for (Int32 val = from; val <= to; val++) { // If any callbacks are specified, call them if (fb != null) fb(val); } } private void FeedbackToFile(Int32 value) { StreamWriter sw = new StreamWriter("Status", true); sw.WriteLine("Item=" + value); sw.Close(); } }
这里委托对象封装的是一个实例方法，所以内部会持有这个实例的一个引用，这个应用可以通过委托对象的target属性获得。
创建一个委托链的方式如下
using System; using System.Linq; using System.IO; using System.Text; using System.Threading; using System.Windows.Forms; using System.Reflection; public sealed class Program { public static void Main() { DelegateIntro.Go(); } } internal sealed class DelegateIntro { // 申明一个委托类型，他的实例（既然委托是一个类型，那么他其实会创建一个实例）引用一个方法，该方法接收一个Int32型的参数，返回空值 internal delegate void Feedback(Int32 value); public static void Go() { ChainDelegateDemo1(new DelegateIntro()); ChainDelegateDemo2(new DelegateIntro()); } private static void ChainDelegateDemo1(DelegateIntro di) { Console.WriteLine("----- Chain Delegate Demo 1 -----"); Feedback fb1 = new Feedback(FeedbackToConsole); Feedback fb2 = new Feedback(FeedbackToMsgBox); Feedback fb3 = new Feedback(di.FeedbackToFile); Feedback fbChain = null; fbChain = (Feedback)Delegate.Combine(fbChain, fb1); fbChain = (Feedback)Delegate.Combine(fbChain, fb2); fbChain = (Feedback)Delegate.Combine(fbChain, fb3); Counter(1, 2, fbChain); Console.WriteLine(); fbChain = (Feedback)Delegate.Remove(fbChain, new Feedback(FeedbackToMsgBox)); Counter(1, 2, fbChain); } private static void ChainDelegateDemo2(DelegateIntro di) { Console.WriteLine("----- Chain Delegate Demo 2 -----"); Feedback fb1 = new Feedback(FeedbackToConsole); Feedback fb2 = new Feedback(FeedbackToMsgBox); Feedback fb3 = new Feedback(di.FeedbackToFile); Feedback fbChain = null; fbChain += fb1; fbChain += fb2; fbChain += fb3; Counter(1, 2, fbChain); Console.WriteLine(); fbChain -= new Feedback(FeedbackToMsgBox); Counter(1, 2, fbChain); } private static void Counter(Int32 from, Int32 to, Feedback fb) { for (Int32 val = from; val <= to; val++) { // If any callbacks are specified, call them if (fb != null) fb(val); } } private static void FeedbackToConsole(Int32 value) { Console.WriteLine("Item=" + value); } private static void FeedbackToMsgBox(Int32 value) { MessageBox.Show("Item=" + value); } private void FeedbackToFile(Int32 value) { StreamWriter sw = new StreamWriter("Status", true); sw.WriteLine("Item=" + value); sw.Close(); } }
我们看到ChainDelegateDemo1里使用了Delegate.Combine这个静态方法来创建一个委托链，而ChainDelegateDemo2使用的是+=这个运算符的重载。
实际上CLR内部的情况正如ChainDelegateDemo1所示，调用了Delegate.Combine来创建委托链。+=号只是C#编译器提供的语法糖而已。
相似的，我们也可以使用Delegate.Remove或者-=来从委托链中移除一个委托。
4.委托和观察者模式。
首先看看观察者模式的定义：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。[GOF 《设计模式》]
重点在于：
当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知
所以这种模式中会有两个对象存在：观察者（订阅者），通知者（发布者）
观察者希望发布者通知他何时去更新，发布者希望能够增加或者减少发布者的数量并且通知观察者。简单的代码如下
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication4 { //定义一个通知者类，当需要更新的时候通知观察者进行更新 class NotifyClass { public delegate void Update(NotifyClass nc); public Update UpdateEvent; public Int32 i_Update; public void Notify() { if (UpdateEvent != null) { UpdateEvent(this); } } } //OB1类中只有一个方法监听通知类的通知事件 class Observer1 { public void Ob1NotifiedUpdate(NotifyClass nc) { Console.WriteLine(nc.i_Update); } } class Observer2 { public void Ob2NotifiedUpdate(NotifyClass nc) { Console.WriteLine(nc.i_Update+" from ob2"); } } class Program { static void Main(string[] args) { NotifyClass a = new NotifyClass(); a.UpdateEvent += (new Observer1().Ob1NotifiedUpdate); a.UpdateEvent += (new Observer2().Ob2NotifiedUpdate);
a.i_Update=100; a.Notify(); Console.Read(); } } }
我们可以知道，观察者模式的情况其实是发布者通知观察者需要更新，然后观察者去更新。但是正如我之前说的，使用委托的实际情况是委托对象将方法包装起来，然后由委托对象去调用包装起来的方法。并不是由观察者去调用的。或者我们可以理解为真正监听发布者的不是观察者，而是通过观察者方法构建的委托对象。
所以我觉得下面的实现方式更加符合观察者模式
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication4 { //定义一个通知者类，当需要更新的时候通知观察者进行更新 class NotifyClass { public interface IUpdate { void Updated(NotifyClass nc); } public List<IUpdate> UpdateEvent=new List<IUpdate>(); public Int32 i_Update; public void Notify() { if (UpdateEvent != null) { foreach (IUpdate iu in UpdateEvent) { iu.Updated(this); } } } public void AddListener(IUpdate iu) { UpdateEvent.Add(iu); } public void RemoveListener(IUpdate iu) { UpdateEvent.Remove(iu); } } //OB1类中只有一个方法监听通知类的通知事件 class Observer1:NotifyClass.IUpdate {public void Updated(NotifyClass nc) { Console.WriteLine(nc.i_Update); } } class Observer2:NotifyClass.IUpdate { public void Updated(NotifyClass nc) { Console.WriteLine(nc.i_Update+" from ob2"); } } class Program { static void Main(string[] args) { NotifyClass a = new NotifyClass(); Observer1 ob1 = new Observer1(); a.AddListener(ob1); a.i_Update = 100; a.Notify(); Console.Read(); } } }
