C# 中的委托和事件

C# 中的委托和事件               委托 和 事件在 .Net Framework中的应用非常广泛，然而，较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件就觉得心里憋得慌，混身不自在。本文中，我将通过两个范例由浅入深地讲述什么是委托、为什么要使用委托、事件的由来、.Net Framework中的委托和事件、委托和事件对Observer设计模式的意义，对它们的中间代码也做了讨论。将方法作为方法的参数我们先不管这个标题如何的绕口，也不管委托究竟是个什么东西，来看下面这两个最简单的方法，它们不过是在屏幕上输出一句问候的话语：public void GreetPeople(string name) {  // 做某些额外的事情，比如初始化之类，此处略  EnglishGreeting(name); } public void EnglishGreeting(string name) {  Console.WriteLine('Morning, ' + name); }暂且不管这两个方法有没有什么实际意义。GreetPeople用于向某人问好，当我们传递代表某人姓名的name参数，比如说“Jimmy”，进去的时候，在这个方法中，将调用EnglishGreeting方法，再次传递name参数，EnglishGreeting则用于向屏幕输出 “Morning, Jimmy”。现在假设这个程序需要进行全球化，哎呀，不好了，我是中国人，我不明白“Morning”是什么意思，怎么办呢？好吧，我们再加个中文版的问候方法：public void ChineseGreeting(string name){  Console.WriteLine('早上好, ' + name); }这时候，GreetPeople也需要改一改了，不然如何判断到底用哪个版本的Greeting问候方法合适呢？在进行这个之前，我们最好再定义一个枚举作为判断的依据：public enum Language{  English, Chinese } public void GreetPeople(string name, Language lang){  //做某些额外的事情，比如初始化之类，此处略  swith(lang){  case Language.English:  EnglishGreeting(name);  break;  case Language.Chinese:  ChineseGreeting(name);  break;  } }OK，尽管这样解决了问题，但我不说大家也很容易想到，这个解决方案的可扩展性很差，如果日后我们需要再添加韩文版、日文版，就不得不反复修改枚举和GreetPeople()方法，以适应新的需求。在考虑新的解决方案之前，我们先看看 GreetPeople的方法签名：public void GreetPeople(string name, Language lang)我们仅看 string name，在这里，string 是参数类型，name 是参数变量，当我们赋给name字符串“jimmy”时，它就代表“jimmy”这个值；当我们赋给它“jerry”时，它又代表着“jerry”这个值。然后，我们可以在方法体内对这个name进行其他操作。哎，这简直是废话么，刚学程序就知道了。如果你再仔细想想，假如GreetPeople()方法可以接受一个参数变量，这个变量可以代表另一个方法，当我们给这个变量赋值 EnglishGreeting的时候，它代表着 EnglsihGreeting() 这个方法；当我们给它赋值ChineseGreeting 的时候，它又代表着ChineseGreeting()方法。我们将这个参数变量命名为 MakeGreeting，那么不是可以如同给name赋值时一样，在调用 GreetPeople()方法的时候，给这个MakeGreeting 参数也赋上值么(ChineseGreeting或者EnglsihGreeting等)？然后，我们在方法体内，也可以像使用别的参数一样使用MakeGreeting。但是，由于MakeGreeting代表着一个方法，它的使用方式应该和它被赋的方法(比如ChineseGreeting)是一样的，比如：MakeGreeting(name);好了，有了思路了，我们现在就来改改GreetPeople()方法，那么它应该是这个样子了：public void GreetPeople(string name, *** MakeGreeting){  MakeGreeting(name); }注意到 *** ，这个位置通常放置的应该是参数的类型，但到目前为止，我们仅仅是想到应该有个可以代表方法的参数，并按这个思路去改写GreetPeople方法，现在就出现了一个大问题：这个代表着方法的MakeGreeting参数应该是什么类型的？NOTE：这里已不再需要枚举了，因为在给MakeGreeting赋值的时候动态地决定使用哪个方法，是ChineseGreeting还是 EnglishGreeting，而在这个两个方法内部，已经对使用“morning”还是“早上好”作了区分。聪明的你应该已经想到了，现在是委托该出场的时候了，但讲述委托之前，我们再看看MakeGreeting参数所能代表的 ChineseGreeting()和EnglishGreeting()方法的签名：public void EnglishGreeting(string name) public void ChineseGreeting(string name)如同name可以接受String类型的“true”和“1”，但不能接受bool类型的true和int类型的1一样。MakeGreeting的 参数类型定义 应该能够确定 MakeGreeting可以代表的方法种类，再进一步讲，就是MakeGreeting可以代表的方法 的 参数类型和返回类型。于是，委托出现了：它定义了MakeGreeting参数所能代表的方法的种类，也就是MakeGreeting参数的类型。NOTE：如果上面这句话比较绕口，我把它翻译成这样：string 定义了name参数所能代表的值的种类，也就是name参数的类型。本例中委托的定义：public delegate void GreetingDelegate(string name);可以与上面EnglishGreeting()方法的签名对比一下，除了加入了delegate关键字以外，其余的是不是完全一样？现在，让我们再次改动GreetPeople()方法，如下所示：public void GreetPeople(string name, GreetingDelegate MakeGreeting){  MakeGreeting(name); }如你所见，委托GreetingDelegate出现的位置与 string相同，string是一个类型，那么GreetingDelegate应该也是一个类型，或者叫类(Class)。但是委托的声明方式和类却完全不同，这是怎么一回事？实际上，委托在编译的时候确实会编译成类。因为Delegate是一个类，所以在任何可以声明类的地方都可以声明委托。更多的内容将在下面讲述，现在，请看看这个范例的完整代码：using System; using System.Collections.Generic; using System.Text; namespace Delegate {  //定义委托，它定义了可以代表的方法的类型  public delegate void GreetingDelegate(string name);  class Program {  private static void EnglishGreeting(string name) {  Console.WriteLine('Morning, ' + name);  }  private static void ChineseGreeting(string name) {  Console.WriteLine('早上好, ' + name);  }  //注意此方法，它接受一个GreetingDelegate类型的方法作为参数  private static void GreetPeople(string name, GreetingDelegate MakeGreeting) {  MakeGreeting(name);  }  static void Main(string[] args) {  GreetPeople('Jimmy Zhang', EnglishGreeting);  GreetPeople('jerry', ChineseGreeting);  Console.ReadKey();  }  }  } 输出如下： Morning, Jimmy Zhang 早上好, jerry我们现在对委托做一个总结：委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。将方法绑定到委托看到这里，是不是有那么点如梦初醒的感觉？于是，你是不是在想：在上面的例子中，我不一定要直接在GreetPeople()方法中给 name参数赋值，我可以像这样使用变量：static void Main(string[] args) {  string name1, name2;  name1 = 'Jimmy Zhang';  name2 = 'jerry';  GreetPeople(name1, EnglishGreeting);  GreetPeople(name2, ChineseGreeting);  Console.ReadKey(); }而既然委托GreetingDelegate 和 类型 string 的地位一样，都是定义了一种参数类型，那么，我是不是也可以这么使用委托？static void Main(string[] args) {  GreetingDelegate delegate1, delegate2;  delegate1 = EnglishGreeting;  delegate2 = ChineseGreeting;  GreetPeople('Jimmy Zhang', delegate1);  GreetPeople('jerry', delegate2);  Console.ReadKey(); }如你所料，这样是没有问题的，程序一如预料的那样输出。这里，我想说的是委托不同于string的一个特性：可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法。在这个例子中，语法如下：static void Main(string[] args) {  GreetingDelegate delegate1;  delegate1 = EnglishGreeting; // 先给委托类型的变量赋值  delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法  // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法  GreetPeople('Jimmy Zhang', delegate1);  Console.ReadKey(); } 输出为： Morning, Jimmy Zhang 早上好, Jimmy Zhang实际上，我们可以也可以绕过GreetPeople方法，通过委托来直接调用EnglishGreeting和ChineseGreeting：static void Main(string[] args) {  GreetingDelegate delegate1;  delegate1 = EnglishGreeting; // 先给委托类型的变量赋值  delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法  // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法  delegate1 ('Jimmy Zhang');  Console.ReadKey(); }NOTE：这在本例中是没有问题的，但回头看下上面GreetPeople()的定义，在它之中可以做一些对于EnglshihGreeting和ChineseGreeting来说都需要进行的工作，为了简便我做了省略。注意这里，第一次用的“=”，是赋值的语法；第二次，用的是“+=”，是绑定的语法。如果第一次就使用“+=”，将出现“使用了未赋值的局部变量”的编译错误。我们也可以使用下面的代码来这样简化这一过程：GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting); delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法看到这里，应该注意到，这段代码第一条语句与实例化一个类是何其的相似，你不禁想到：上面第一次绑定委托时不可以使用“+=”的编译错误，或许可以用这样的方法来避免：GreetingDelegate delegate1 = new GreetingDelegate(); delegate1 += EnglishGreeting; // 这次用的是 “+=”，绑定语法。 delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法但实际上，这样会出现编译错误： “GreetingDelegate”方法没有采用“0”个参数的重载。尽管这样的结果让我们觉得有点沮丧，但是编译的提示：“没有0个参数的重载”再次让我们联想到了类的构造函数。我知道你一定按捺不住想探个究竟，但再此之前，我们需要先把基础知识和应用介绍完。既然给委托可以绑定一个方法，那么也应该有办法取消对方法的绑定，很容易想到，这个语法是“-=”：static void Main(string[] args) {  GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);  delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法  // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法  GreetPeople('Jimmy Zhang', delegate1);  Console.WriteLine();  delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定  // 将仅调用 ChineseGreeting  GreetPeople('jerry', delegate1);  Console.ReadKey(); } 输出为： Morning, Jimmy Zhang 早上好, Jimmy Zhang 早上好, jerry让我们再次对委托作个总结：使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。  对.net事件的看法对.net事件的看法一、事件的本质事件是软件系统里的两个子系统之间，或者两个模块之间，或者两个对象之间发送消息，并处理消息的过程。在面向对象的世界里，就可以统一认为是两个对象之间的行为。两个对象之间发送的这种消息，对发送方来讲是产生一个事件，对接受方来讲是需要处理某个事件。这种消息可以是用户操作产生的或者软件系统里的某个对象产生的。对象之间的事件处理从上图可见，对象一产生一个事件，这个事件发生以后需要对象二执行某种动作。这就是事件机制。对象一是事件的产生者，或者发送者；对象二是事件的接收者或者订阅者。对象一产生某种消息，需要对象二响应并处理这给消息，这就是事件的本质。以往的很多软件系统都在采用事件机制处理很多问题。例如从最本质的计算机体系中的软中断处理，到masm中的jump，到c/c++中的回调函数等等。只不过越高级的软件系统处理事件或者其提供的很多处理方法越接近人的思维，而越远离机器思维。构建软件系统的方法从本质上就是从机器思维走向人的思维的过程。二、事件机制的好处1、直接调用采用事件机制有什么好处？事件发送者为什么不直接调用事件接受者提供的处理函数呢？调用机制如果所示，两个对象之间的调用机制。对象B调用对象A的方法，可以通过函数指针或者跳转（汇编语言）等实现。这种方法造成的结果是A和B的紧密耦合，即B对A有很强的依赖性。可以看成B是事件的发布者，A是事件的响应和处理者。不过这种机制用事件机制解释从理论上就比较牵强了。同一种事物，其实现的思想不一样。现在假设有个对象C也要响应B的事件。那么，按照上面的这种机制，需求修改对象B的代码，调用对象C的方法。这样机制造成了非常强的依赖关系。代码的修改和扩展非常麻烦。如果对象越多，这种关系越多，整个系统越复杂。如果一个系统里面对象很多，这种依赖关系也很多的情况下，这种调用关系就会十分复杂，对系统的健壮性和优良性会造成影响。2、回调机制如果按照c#的委托思想，B需要事先提供对事件处理函数的某些回调指针。这样，其它对象，例如A和C就去修改它的回调指针，把自己的方法联系到上面。但是它们之间的耦合关系就比上面简单了。回调机制回调机制的思想已经比较接近委托的概念。其实委托在本质上也就和回调指针差不多，只是概念上更加高级。对象B作为事件的发布者，事先定义一些回调函数指针，然后在本地合适的地方调用这些指针指向的函数。而事件订阅者或者处理者A和C所作的就是让给这些空指针赋值，把自己的事件处理方法赋给它，从而实现B调用A和C的方法。在 C 或 C++ 中与委托最为相似的是函数指针。然而，函数指针只能引用静态函数，而委托可以引用静态方法和实例方法。当委托引用实例方法时，委托不仅存储对方法入口点的引用，还存储对为其调用该方法的类实例的引用。与函数指针不同，委托是面向对象、类型安全并且安全的。三、事件机制的实现1、委托的局限如果单纯用委托，对于事件的发布者B来说，假设它发布事件e，对于事件e，它目前已经知道有A和C对象需要订阅这个事件。所以，它就申明两个委托对象引用（本质上类似于函数指针），然后让A和C对象来采用类似回调的机制订阅和响应事件。如果后来，有个对象D也需要订阅B的事件e，它怎么办呢？一种情况是D修改B的一个委托对象引用，把自己的处理方法包装成一个委托对象付给它。这样，D就抢夺了A或者C的订阅。否则，就需要修改B的代码，添加一个类似的委托对象引用，以便让D来使用。这样做的后果是事件发布者B需要申明很多委托对象的引用变量。结果是弄得代码维护比较混乱，并且使用者也很多，依赖关系也不容易搞清楚，容易发生错误。2、事件的引入有了委托，就提供了类似回调一样的功能。但是，回调机制需要事件发布者和事件订阅者双方的共同参与和努力。也就是，每增加一个订阅者，那么发布者对象就需要提供一个委托引用，让订阅者挂钩。如果事件的发布者发布一个事件以后就不在关心谁来订阅它，那么以后的处理就交给了使用者，而发布者不再关心事件处理者的问题。订阅机制C#事件的事件就是这种订阅机制，真正的订阅。发布者不需要关心订阅者。C#事件给订阅者提供了对事件响应的注册和反注册功能。订阅和撤销完全是事件接受方的行为。C#事件机制的实现包括以下几步：1、 事件发布者定义一个委托类型；2、 事件发布者定义一个事件，并且关联到已经定义的委托上。3、 事件订阅者需要产生一个委托实例，并把它添加到委托列表。所以，事件event可以看成是一个事件列表，订阅者可以注册和撤销自己的响应和处理机制，但是它没有办法更改整个列表（原则上）。所以，提供了更强、更安全的方式。四、事件机制的代码实例应用程序结构图如图所示，事件发布对象发布一个事件；事件订阅对象订阅和处理该事件。using System;namespace EventExample{///

/// MainClass : 主应用程序类///

class MainClass{///

///应用程序的主入口点。///

[STAThread]static void Main(string[] args){EventPublisher publisher = new EventPublisher();EventReader1 reader1 = new EventReader1(publisher);EventReader2 reader2 = new EventReader2(publisher);publisher.DoSomthing();Console.WriteLine('This program already finished!');Console.ReadLine();}}///

/// EventPublisher : 事件的发布者。///

public class EventPublisher{// 第一步是申明委托public delegate int sampleEventDelegate(string messageInfo);// 第二步是申明与上述委托相关的事件public event sampleEventDelegate sampleEvent;public EventPublisher(){}public void DoSomthing(){/* ... */// 激发事件if(this.sampleEvent != null){this.sampleEvent('hello world!');}/* ... */}}///

/// EventReader1 : 事件的订阅者1。///

public class EventReader1{public EventReader1(EventPublisher publisher){publisher.sampleEvent +=new EventExample.EventPublisher.sampleEventDelegate(ResponseEvent);}private int ResponseEvent(string msg){Console.WriteLine(msg + ' --- This is from reader1');return 0;}}///

/// EventReader2 : 事件的订阅者2。///

public class EventReader2{public EventReader2(EventPublisher publisher){publisher.sampleEvent +=new EventExample.EventPublisher.sampleEventDelegate(ResponseEvent);publisher.sampleEvent +=new EventExample.EventPublisher.sampleEventDelegate(ResponseEvent);}private int ResponseEvent(string msg){Console.WriteLine(msg + ' --- This is from reader2');Console.WriteLine('Please:down enter key!');Console.ReadLine();Console.WriteLine('ok');return 0;}}}程序运行结果总结：事件发布者发布的事件在实质上可以看成对外提供的回调函数指针列表。这个列表的容量可以动态增长。事件订阅者可以把自己的事件注册到这个列表或者撤销注册，但是它从原则上无法更改或者对其它订阅者的注册产生影响。事件发布者通过两种手段使得订阅者正确地使用事件机制：一是定义一种delegate委托类型，事件订阅者只能按照这种类型定义事件的处理方法；二是定义与这个委托相关的event对象，使得订阅者只负责注册和撤销自己的处理过程而不能随意对别人的处理过程产生影响。从运行结果和reader2对象把同一个处理方法注册了两次的前提可以看到，对于一个事件，同一个订阅者可以把同一个处理过程注册多次，而这个方法最终也会被执行多次。执行事件订阅列表中方法的顺序不能被保证；而且，在这里采用的是同步调用方法，只有一个响应函数执行完毕，其它函数才会被执行。如果要方法不被阻塞（包括这里的等待用户输入等），就需要采用异步调用方式。 委托、事件与Observer设计模式范例说明上面的例子已不足以再进行下面的讲解了，我们来看一个新的范例，因为之前已经介绍了很多的内容，所以本节的进度会稍微快一些：假设我们有个高档的热水器，我们给它通上电，当水温超过95度的时候：1、扬声器会开始发出语音，告诉你水的温度；2、液晶屏也会改变水温的显示，来提示水已经快烧开了。现在我们需要写个程序来模拟这个烧水的过程，我们将定义一个类来代表热水器，我们管它叫：Heater，它有代表水温的字段，叫做temperature；当然，还有必不可少的给水加热方法BoilWater()，一个发出语音警报的方法MakeAlert()，一个显示水温的方法，ShowMsg()。namespace Delegate {  class Heater {  private int temperature; // 水温  // 烧水  public void BoilWater() {  for (int i = 0; i <= 100; i++) {  temperature = i;  if (temperature > 95) {  MakeAlert(temperature);  ShowMsg(temperature);  }  }  }  // 发出语音警报  private void MakeAlert(int param) {  Console.WriteLine('Alarm：嘀嘀嘀，水已经 {0} 度了：' , param);  }  // 显示水温  private void ShowMsg(int param) {  Console.WriteLine('Display：水快开了，当前温度：{0}度。' , param);  } } class Program {  static void Main() {  Heater ht = new Heater();  ht.BoilWater();  } } }Observer设计模式简介上面的例子显然能完成我们之前描述的工作，但是却并不够好。现在假设热水器由三部分组成：热水器、警报器、显示器，它们来自于不同厂商并进行了组装。那么，应该是热水器仅仅负责烧水，它不能发出警报也不能显示水温；在水烧开时由警报器发出警报、显示器显示提示和水温。这时候，上面的例子就应该变成这个样子：// 热水器 public class Heater {  private int temperature;  // 烧水  private void BoilWater() {  for (int i = 0; i <= 100; i++) {  temperature = i;  }  } } // 警报器 public class Alarm{  private void MakeAlert(int param) {  Console.WriteLine('Alarm：嘀嘀嘀，水已经 {0} 度了：' , param);  } } // 显示器 public class Display{  private void ShowMsg(int param) {  Console.WriteLine('Display：水已烧开，当前温度：{0}度。' , param);  } }这里就出现了一个问题：如何在水烧开的时候通知报警器和显示器？在继续进行之前，我们先了解一下Observer设计模式，Observer设计模式中主要包括如下两类对象：1         Subject：监视对象，它往往包含着其他对象所感兴趣的内容。在本范例中，热水器就是一个监视对象，它包含的其他对象所感兴趣的内容，就是temprature字段，当这个字段的值快到100时，会不断把数据发给监视它的对象。2         Observer：监视者，它监视Subject，当Subject中的某件事发生的时候，会告知Observer，而Observer则会采取相应的行动。在本范例中，Observer有警报器和显示器，它们采取的行动分别是发出警报和显示水温。在本例中，事情发生的顺序应该是这样的：3         警报器和显示器告诉热水器，它对它的温度比较感兴趣(注册)。4         热水器知道后保留对警报器和显示器的引用。5         热水器进行烧水这一动作，当水温超过95度时，通过对警报器和显示器的引用，自动调用警报器的MakeAlert()方法、显示器的ShowMsg()方法。类似这样的例子是很多的，GOF对它进行了抽象，称为Observer设计模式：Observer设计模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。实现范例的Observer设计模式我们之前已经对委托和事件介绍很多了，现在写代码应该很容易了，现在在这里直接给出代码，并在注释中加以说明。using System; using System.Collections.Generic; using System.Text; namespace Delegate {  // 热水器  public class Heater {  private int temperature;  public delegate void BoilHandler(int param); //声明委托  public event BoilHandler BoilEvent; //声明事件  // 烧水  public void BoilWater() {  for (int i = 0; i <= 100; i++) {  temperature = i;  if (temperature > 95) {  if (BoilEvent != null) { //如果有对象注册  BoilEvent(temperature); //调用所有注册对象的方法  }  }  }  }  }  // 警报器  public class Alarm {  public void MakeAlert(int param) {  Console.WriteLine('Alarm：嘀嘀嘀，水已经 {0} 度了：', param);  }  }  // 显示器  public class Display {  public static void ShowMsg(int param) { //静态方法  Console.WriteLine('Display：水快烧开了，当前温度：{0}度。', param);  }  }  class Program {  static void Main() {  Heater heater = new Heater();  Alarm alarm = new Alarm();  heater.BoilEvent += alarm.MakeAlert; //注册方法  heater.BoilEvent += (new Alarm()).MakeAlert; //给匿名对象注册方法  heater.BoilEvent += Display.ShowMsg; //注册静态方法  heater.BoilWater(); //烧水，会自动调用注册过对象的方法  }  } } 输出为： Alarm：嘀嘀嘀，水已经 96 度了： Alarm：嘀嘀嘀，水已经 96 度了： Display：水快烧开了，当前温度：96度。 // 省略....Net Framework中的委托与事件尽管上面的范例很好地完成了我们想要完成的工作，但是我们不仅疑惑：为什么.Net Framework 中的事件模型和上面的不同？为什么有很多的EventArgs参数？在回答上面的问题之前，我们先搞懂 .Net Framework的编码规范：·         委托类型的名称都应该以EventHandler结束。·         委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。·         事件的命名为 委托去掉 EventHandler之后剩余的部分。·         继承自EventArgs的类型应该以EventArgs结尾。再做一下说明：6         委托声明原型中的Object类型的参数代表了Subject，也就是监视对象，在本例中是 Heater(热水器)。回调函数(比如Alarm的MakeAlert)可以通过它访问触发事件的对象(Heater)。7         EventArgs 对象包含了Observer所感兴趣的数据，在本例中是temperature。上面这些其实不仅仅是为了编码规范而已，这样也使得程序有更大的灵活性。比如说，如果我们不光想获得热水器的温度，还想在Observer端(警报器或者显示器)方法中获得它的生产日期、型号、价格，那么委托和方法的声明都会变得很麻烦，而如果我们将热水器的引用传给警报器的方法，就可以在方法中直接访问热水器了。现在我们改写之前的范例，让它符合 .Net Framework 的规范：using System; using System.Collections.Generic; using System.Text; namespace Delegate {  // 热水器  public class Heater {  private int temperature;  public string type = 'RealFire 001'; // 添加型号作为演示  public string area = 'China Xian'; // 添加产地作为演示  //声明委托  public delegate void BoiledEventHandler(Object sender, BoiledEventArgs e);  public event BoiledEventHandler Boiled; //声明事件  // 定义BoiledEventArgs类，传递给Observer所感兴趣的信息  public class BoiledEventArgs : EventArgs {  public readonly int temperature;  public BoiledEventArgs(int temperature) {  this.temperature = temperature;  }  }  // 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视  protected virtual void OnBoiled(BoiledEventArgs e) {  if (Boiled != null) { // 如果有对象注册  Boiled(this, e); // 调用所有注册对象的方法  }  }  // 烧水。  public void BoilWater() {  for (int i = 0; i <= 100; i++) {  temperature = i;  if (temperature > 95) {  //建立BoiledEventArgs 对象。  BoiledEventArgs e = new BoiledEventArgs(temperature);  OnBoiled(e); // 调用 OnBolied方法  }  }  }  }  // 警报器  public class Alarm {  public void MakeAlert(Object sender, Heater.BoiledEventArgs e) {  Heater heater = (Heater)sender; //这里是不是很熟悉呢？  //访问 sender 中的公共字段  Console.WriteLine('Alarm：{0} - {1}: ', heater.area, heater.type);  Console.WriteLine('Alarm: 嘀嘀嘀，水已经 {0} 度了：', e.temperature);  Console.WriteLine();  }  }  // 显示器  public class Display {  public static void ShowMsg(Object sender, Heater.BoiledEventArgs e) { //静态方法  Heater heater = (Heater)sender;  Console.WriteLine('Display：{0} - {1}: ', heater.area, heater.type);  Console.WriteLine('Display：水快烧开了，当前温度：{0}度。', e.temperature);  Console.WriteLine();  }  }  class Program {  static void Main() {  Heater heater = new Heater();  Alarm alarm = new Alarm();  heater.Boiled += alarm.MakeAlert; //注册方法  heater.Boiled += (new Alarm()).MakeAlert; //给匿名对象注册方法  heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert); //也可以这么注册  heater.Boiled += Display.ShowMsg; //注册静态方法  heater.BoilWater(); //烧水，会自动调用注册过对象的方法  }  } } 输出为： Alarm：China Xian - RealFire 001: Alarm: 嘀嘀嘀，水已经 96 度了： Alarm：China Xian - RealFire 001: Alarm: 嘀嘀嘀，水已经 96 度了： Alarm：China Xian - RealFire 001: Alarm: 嘀嘀嘀，水已经 96 度了： Display：China Xian - RealFire 001: Display：水快烧开了，当前温度：96度。 // 省略 ...