`

C#/.NET中委托和事件的机制和应用

阅读更多
 引自 http://www.cnblogs.com/stone/archive/2005/04/30/148129.aspx

本文摘自人民邮电出版社出版的《Windows Forms程序设计》(Chris Sells著,荣耀、蒋贤哲译)。通过一个栩栩如生的虚构故事解释了C#/.NET中委托和事件的机制和应用。
  
  1 委托
  
  从前,在南方的一个异国他乡,有一个叫Peter的勤劳的工人,他对老板(boss)百依百顺,然而他的boss却是个卑鄙多疑的家伙,他坚 持要求Peter不断汇报工作进展。由于Peter不希望被boss盯着干活,于是他向boss承诺随时汇报工作进度。Peter通过如下所示的类型化的 引用(typed reference)定期回调boss来实现这个承诺:
  
 
c# 代码
 
  1. class Worker {  
  2.    public void Advise(Boss boss) {this.boss = boss; }  
  3.    public void DoWork() {  
  4.        Console.WriteLine("Worker: work started");  
  5.        if( boss != null ) boss.WorkStarted();  
  6.         
  7.        Console.WriteLine("Worker: work progressing");  
  8.        if( boss != null ) boss.WorkProgressing();  
  9.     
  10.        Console.WriteLine("Worker: work completed");  
  11.        if( boss != null ) {  
  12.            int grade = boss.WorkCompleted();  
  13.            Console.WriteLine("Worker grade= " + grade);  
  14.        }  
  15.    }  
  16.    Boss boss;  
  17.   }  
  18.     
  19. class Boss {  
  20.    public void WorkStarted() {/* boss不关心 */ }  
  21.    public void WorkProgressing() {/* boss不关心 */ }  
  22.    public int WorkCompleted() {  
  23.        Console.WriteLine("It's about time!");  
  24.        return 2; /* 10分以内 */  
  25.    }  
  26. }  
  27.     
  28. class Universe {  
  29.    static void Main() {  
  30.        Worker peter = new Worker();  
  31.        Boss boss = new Boss();  
  32.        peter.Advise(boss);  
  33.        peter.DoWork();  
  34.         
  35.        Console.WriteLine("Main: worker completed work");  
  36.        Console.ReadLine();  
  37.    }  
  38. }  

  
  1.1 接口
  
  现在,Peter成了一个特殊人物,他不但能够忍受卑鄙的boss,和周围的世界(universe)也建立了紧密的联系。Peter感到 universe对他的工作进程同样感兴趣。不幸的是,如果不为universe添加一个特殊的Advise方法和特殊的回调,除了保证boss能够被通 知外,Peter并不能向universe通知工作进度。Peter希望能从那些通知方法的实现中分离出潜在的通知列表,为此,他决定将方法分离到一个接 口中:
  
 
c# 代码
 
  1. interface IWorkerEvents {  
  2.    void WorkStarted();  
  3.    void WorkProgressing();  
  4.    int WorkCompleted();  
  5. }  
  6.     
  7. class Worker {  
  8.    public void Advise(IWorkerEvents events) {this.events = events; }  
  9.    public void DoWork() {  
  10.        Console.WriteLine("Worker: work started");  
  11.        if( events != null ) events.WorkStarted();  
  12.         
  13.        Console.WriteLine("Worker: work progressing");  
  14.        if(events != null ) events.WorkProgressing();  
  15.         
  16.        Console.WriteLine("Worker: work completed");  
  17.        if(events != null ) {  
  18.            int grade = events.WorkCompleted();  
  19.            Console.WriteLine("Worker grade= " + grade);  
  20.        }  
  21.    }  
  22.    IWorkerEvents events;  
  23. }  
  24.     
  25. class Boss : IWorkerEvents {  
  26.    public void WorkStarted() {/* boss不关心 */ }  
  27.    public void WorkProgressing() {/* boss不关心 */ }  
  28.    public int WorkCompleted() {  
  29.        Console.WriteLine("It's about time!");  
  30.        return 3; /* 10分以内 */  
  31.    }  
  32. }  

  
  1.2 委托
  
  不幸的是,由于Peter忙于说服boss实现这个接口,以至于没有顾得上通知universe也实现该接口,但他希望尽可能做到这一点,至少他已经抽象了对boss的引用,因此,别的实现了IWorkerEvents接口的什么人也可以得到工作进度通知。
  
  然而, Peter的boss仍然极其不满。“Peter!”boss咆哮者,“你为什么要通知我什么时候开始工作、什么时候正在进行工作?我不关心这些事件,你 不但强迫我实现这些方法,你还浪费了你的宝贵的工作时间等我从事件中返回。当我的实现需要占用很长时间时,你等我的时间也要大大延长!你难道不能想想别的 办法不要老是来烦我吗?”
  
  因此,Peter意识到尽管在很多情况下接口很有用,但在处理事件时,接口的粒度还不够精细。他希望能做到仅仅通知监听者真正感兴趣的事件。为此,Peter决定把接口中的方法分解为若干个独立的委托函数,每一个都好象是只包含一个方法的微型接口:
  
 
c# 代码
 
  1. delegate void WorkStarted();  
  2.   delegate void WorkProgressing();  
  3.   delegate int WorkCompleted();  
  4.     
  5. class Worker {  
  6.    public void DoWork() {  
  7.        Console.WriteLine("Worker: work started");  
  8.        if( started != null ) started();  
  9.         
  10.        Console.WriteLine("Worker: work progressing");  
  11.        if( progressing != null ) progressing();  
  12.         
  13.        Console.WriteLine("Worker: work completed");  
  14.        if( completed != null ) {  
  15.            int grade = completed();  
  16.            Console.WriteLine("Worker grade= " + grade);  
  17.        }  
  18.    }  
  19.    public WorkStarted started;  
  20.    public WorkProgressing progressing;  
  21.    public WorkCompleted completed;  
  22. }  
  23.     
  24. class Boss {  
  25.    public int WorkCompleted() {  
  26.        Console.WriteLine("Better...");  
  27.        return 4; /* 10分以内 */  
  28.    }  
  29. }  
  30.     
  31. class Universe {  
  32.    static void Main() {  
  33.        Worker peter = new Worker();  
  34.        Boss boss = new Boss();  
  35.         
  36.        // 注意:我们已将Advise方法替换为赋值运算符  
  37.        peter.completed = new WorkCompleted(boss.WorkCompleted);  
  38.        peter.DoWork();  
  39.        Console.WriteLine("Main: worker completed work");  
  40.        Console.ReadLine();  
  41.    }  
  42. }  

  
  1.3 静态订阅者
  
  利用委托,Peter达到了不拿boss不关心的事件去烦他的目标,然而Peter还是不能够使universe成为其订阅者之一。因为 universe是一个全封闭的实体,所以将委托挂钩在实例成员上不妥的(设想一下Universe的多个实例需要多少资源)。相反,Peter需要将委 托挂钩到静态成员上,因为委托也完全支持静态成员:
  
 
c# 代码
 
  1. class Universe {  
  2.    static void WorkerStartedWork() {  
  3.        Console.WriteLine("Universe notices worker starting work");  
  4.    }  
  5.     
  6.    static int WorkerCompletedWork() {  
  7.        Console.WriteLine("Universe pleased with worker's work");  
  8.        return 7;  
  9.    }  
  10.     
  11.    static void Main() {  
  12.        Worker peter = new Worker();  
  13.        Boss boss = new Boss();  
  14.         
  15.        // 注意:在下面的三行代码中,  
  16.        // 使用赋值运算符不是一个好习惯,  
  17.        // 请接着读下去,以便了解添加委托的正确方式。  
  18.        peter.completed = new WorkCompleted(boss.WorkCompleted);  
  19.        peter.started = new WorkStarted(Universe.WorkerStartedWork);  
  20.        peter.completed = new WorkCompleted(Universe.WorkerCompletedWork);  
  21.        peter.DoWork();  
  22.         
  23.        Console.WriteLine("Main: worker completed work");  
  24.        Console.ReadLine();  
  25.    }  
  26. }  

  
  2 事件
  
  不幸的是,由于universe现在变得太忙并且不习惯于注意某一个人,universe已经设法用自己的委托取代了Peter的boss的 委托,这显然是将Worker类的委托字段设为public而造成的意外的副作用。同样,如果Peter的boss不耐烦了,他自己就可以触发Peter 的委托(Peter的boss可是有暴力倾向的)
  
  // Peter的boss自己控制一切
  if( peter.completed != null ) peter.completed();
  
  Peter希望确保不会发生这两种情况。他意识到必须为每一个委托加入注册和反注册函数,这样订阅者就可以添加或移去它们自个儿,但谁都不能 够清空整个事件列表或者触发它的事件。peter自己没去实现这些方法,相反,他使用event关键字让C#编译器帮他构建这些方法:
  
  class Worker {
  ...
   public event WorkStarted started;
   public event WorkProgressing progressing;
   public event WorkCompleted completed;
  }
  
  Peter晓得event关键字使委托具有这样的属性:只允许C#客户用+=或-=操作符添加或移去它们自己,这样就迫使boss和universe举止文雅一些:
  
 
c# 代码
 
  1. static void Main(){  
  2.    Worker peter = new Worker();  
  3.    Boss boss = new Boss();  
  4.    peter.completed += new WorkCompleted(boss.WorkCompleted);  
  5.    peter.started += new WorkStarted(Universe.WorkerStartedWork);  
  6.    peter.completed += new WorkCompleted(Universe.WorkerCompletedWork);  
  7.    peter.DoWork();  
  8.     
  9.    Console.WriteLine("Main: worker completed work");  
  10.    Console.ReadLine();  
  11. }  

  
  2.1 获取所有结果
  
  至此,Peter终于松了一口气。他已经设法满足了所有订阅者的需求,而且不会和特定实现紧密耦合。然而,他又注意到尽管boss和 universe都为他的工作打了分,但他只得到了一个打分。在有多个订阅者的情形下,Peter希望能得到所有订阅者的评分结果。因此,他决定“进入委 托”,提取订阅者列表,以便手工分别调用它们:
  
  public void DoWork() {
   ...
   Console.WriteLine("Worker: work completed");
   if( completed != null ) {
   foreach( WorkCompleted wc in completed.GetInvocationList() ) {
   int grade = wc();
   Console.WriteLine("Worker grade= " + grade);
   }
   }
  }
  
  2.2 异步通知:触发和忽略
  
  不料,在此期间,boss和universe被别的什么事纠缠上了,这就意味着他们给Peter的工作打分的时间被大大延长了:
  
  class Boss {
   public int WorkCompleted() {
   System.Threading.Thread.Sleep(3000);
   Console.WriteLine("Better..."); return 6; /* 10分以内 */
   }
  }
  
  class Universe {
   static int WorkerCompletedWork() {
   System.Threading.Thread.Sleep(4000);
   Console.WriteLine("Universe is pleased with worker's work");
   return 7;
   }
   ...
  }
  
  不幸的是,由于Peter是同时通知每一个订阅者并等待他们打分的,这些需要返回评分的通知现在看来要占用他不少工作时间,因此,Peter决定忽略评分并且异步触发事件:
  
  public void DoWork() {
   ...
   Console.WriteLine("Worker: work completed");
   if( completed != null ) {
   foreach( WorkCompleted wc in completed.GetInvocationList() ) {
   wc.BeginInvoke(null, null);
   }
   }
  }
  
  2.3 异步通知:轮询
  
  这个聪明的小把戏允许Peter在通知订阅者的同时能立即返回工作,让进程的线程池调用委托。然而没过多久Peter就发现订阅者给他的打分 被搞丢了。他知道自己工作做得不错,并乐意universe作为一个整体(而不仅仅是他的boss)表扬他。因此,Peter异步触发事件,但定期轮询, 以便察看可以获得的评分:
  
  public void DoWork() {
   ...
   Console.WriteLine("Worker: work completed");
   if( completed != null ) {
   foreach( WorkCompleted wc in completed.GetInvocationList() ) {
   IAsyncResult res = wc.BeginInvoke(null, null);
   while( !res.IsCompleted ) System.Threading.Thread.Sleep(1);
   int grade = wc.EndInvoke(res);
   Console.WriteLine("Worker grade= " + grade);
   }
   }
  }
  
  2.4 异步通知:委托
  
  不幸的是,Peter又回到了问题的起点,就像他一开始希望避免boss站在一旁边监视他工作一样。因此,Peter决定使用另一个委托作为异步工作完成时的通知方式,这样他就可以立即回去工作,而当工作被打分时,仍然可以接到通知:
  
  public void DoWork() {
   ...
   Console.WriteLine("Worker: work completed");
   if( completed != null ) {
   foreach( WorkCompleted wc in completed.GetInvocationList() ) {
   wc.BeginInvoke(new AsyncCallback(WorkGraded), wc);
   }
   }
  }
  
  void WorkGraded(IAsyncResult res) {
   WorkCompleted wc = (WorkCompleted)res.AsyncState;
   int grade = wc.EndInvoke(res);
   Console.WriteLine("Worker grade= " + grade);
  }
  
  3 普天同乐
  
  Peter、boss和universe最终都满意了。boss和universe都可以仅被通知其感兴趣的事件,并减少了实现的负担和不必 要的来回调用。Peter可以通知他们每一个人,而不必管需要多长时间才能从那些目标方法中返回,并仍然可以异步得到评分结果。结果得到如下完整的解决方 案:
  
 
c# 代码
 
  1. delegate void WorkStarted();  
  2. delegate void WorkProgressing();  
  3. delegate int WorkCompleted();  
  4.     
  5. class Worker {  
  6.    public void DoWork() {  
  7.        Console.WriteLine("Worker: work started");  
  8.        if( started != null ) started();  
  9.         
  10.        Console.WriteLine("Worker: work progressing");  
  11.        if( progressing != null ) progressing();  
  12.         
  13.        Console.WriteLine("Worker: work completed");  
  14.        if( completed != null ) {  
  15.             
  16.            foreach( WorkCompleted wc in completed.GetInvocationList() ) {  
  17.                wc.BeginInvoke(new AsyncCallback(WorkGraded), wc);  
  18.            }  
  19.        }  
  20.    }  
  21.     
  22.    void WorkGraded(IAsyncResult res) {  
  23.        WorkCompleted wc = (WorkCompleted)res.AsyncState;  
  24.        int grade = wc.EndInvoke(res);  
  25.        Console.WriteLine("Worker grade= " + grade);  
  26.    }  
  27.     
  28.    public event WorkStarted started;  
  29.    public event WorkProgressing progressing;  
  30.    public event WorkCompleted completed;  
  31. }  
  32.     
  33. class Boss {  
  34.    public int WorkCompleted() {  
  35.        System.Threading.Thread.Sleep(3000);  
  36.        Console.WriteLine("Better..."); return 6; /* 10分以内 */  
  37.    }  
  38. }  
  39.     
  40. class Universe {  
  41.    static void WorkerStartedWork() {  
  42.        Console.WriteLine("Universe notices worker starting work");  
  43.    }  
  44.     
  45.    static int WorkerCompletedWork() {  
  46.        System.Threading.Thread.Sleep(4000);  
  47.        Console.WriteLine("Universe is pleased with worker's work");  
  48.        return 7;  
  49.    }  
  50.     
  51.    static void Main() {  
  52.        Worker peter = new Worker();  
  53.        Boss boss = new Boss();  
  54.        peter.completed += new WorkCompleted(boss.WorkCompleted);  
  55.        peter.started += new WorkStarted(Universe.WorkerStartedWork);  
  56.        peter.completed += new WorkCompleted(Universe.WorkerCompletedWork);  
  57.        peter.DoWork();  
  58.         
  59.        Console.WriteLine("Main: worker completed work");  
  60.        Console.ReadLine();  
  61.    }  
  62. }     

  
  Peter知道异步获取结果会带来一些问题。由于异步触发事件,所以目标方法有可能执行于另一个线程中,就像Peter的“目标方法何时完 成”的通知那样。然而,Peter熟悉第14章“多线程用户界面”,因此,他知道在构建WinForms应用程序时如何去处理此类问题。
  
  从此,他们一直过得都很快乐。
分享到:
评论

相关推荐

    C#/.NET笔试题集.rar

    C#和.NET是微软开发的一种面向对象的编程语言和框架,广泛应用于软件开发,尤其是在企业级应用、桌面应用以及Web应用领域。这份"C#/.NET笔试题集.rar"压缩包显然是为准备C#和.NET技术面试或笔试的人设计的,包含了...

    .NET委托与事件用例

    本文将深入探讨.NET委托和事件,以及它们如何在实际应用中发挥作用。 首先,我们需要了解什么是委托。委托在.NET中可以被视为类型安全的函数指针,它允许我们将方法作为参数传递,或者存储方法以便稍后调用。这种...

    .net C# 委托 调用事件

    本教程将深入探讨C#中的委托及其在ASP.NET中的应用,特别是如何利用委托来调用事件。 一、委托的基本概念 1. **定义委托** 委托是类的一种,它定义了一种方法签名,即接受的参数类型和返回类型。你可以通过`...

    C# 委托 和 事件在 .net Framework中的应用

    在.NET Framework中,C#的委托和事件是两种强大的特性,它们在构建可复用、模块化和响应式代码方面发挥着关键作用。首先,让我们深入理解委托。 委托在C#中可以被视为一种类型,它封装了对方法的引用。简单来说,...

    asp.net 事件和委托 简单例子

    ASP.NET中的事件和委托是.NET框架中非常重要的概念,它们在构建动态、响应用户交互的Web应用程序时起着核心作用。本文将通过一个简单的C#示例,深入探讨这两个概念及其在实际编程中的应用。 首先,让我们理解什么是...

    《C#与.NET 4高级程序设计》(Pro C# 2010 and the .NET 4 Platform)第5版[PDF]

    - **委托、事件与匿名方法**:讲解了这些高级特性在构建事件驱动程序中的作用。 - **Windows窗体**:教授如何使用Windows Forms创建图形用户界面。 - **绘图与GDI+**:介绍了如何使用GDI+库绘制图形。 - **WPF**:...

    C#及VB.NET的委托示例

    在.NET框架中,C#和VB.NET提供了强大的事件处理机制,这一机制的核心概念就是“委托”。委托在编程中可以理解为一种类型,它代表了一组方法的集合,这些方法具有相同的返回类型和参数列表。本示例将深入探讨如何在C#...

    C#.NET 开发者手册

    5. 委托和事件:委托是C#.NET中的函数指针,允许将方法作为参数传递,常用于事件处理。事件则是一种通信机制,允许对象之间异步传递消息。 6. 构造函数和析构函数:构造函数用于初始化对象,而析构函数则在对象生命...

    C#与.NET3.5高级程序设计(第4版) 中文1

    2.6 使用Visual C# 2008 Express构建.NET应用程序 38 2.7 使用Visual Studio 2008构建.NET应用程序 40 2.8 其他.NET开发工具 49 2.9 小结 50 第二部分 C#核心编程结构 第3章 C#核心编程结构Ⅰ 52 3.1 一...

    .net C# 泛型事件委托

    在.NET框架中,C#语言提供了丰富的特性来帮助开发者创建高效、可复用的代码,其中泛型和事件委托是两个关键概念。泛型能够提供类型安全的数据结构,而事件委托则是实现对象间通信的重要机制。当我们把两者结合起来,...

    C#中委托与事件的区别

    委托(Delegate)和事件(Event)是C#中非常重要的两种机制,它们在.NET框架中扮演着极其重要的角色。理解这两种概念,对于深入学习C#编程语言,构建高效、可维护的程序架构至关重要。首先我们来探讨一下委托的概念...

    C#/asp.net面试宝典

    5. C#中委托与事件的概念及其关系。 6. override与重载的区别。 7. 在B/S架构系统中,不使用Session、Cookie、Application的方法传递变量值。 8. 页面上TextBox控件的遍历与赋值。 9. 冒泡排序算法的编程实现。 10. ...

    Visual Basic .NET 和 Visual C# .NET 程序员需要解决的安全问题

    在.NET框架中,Visual Basic .NET和Visual C# .NET程序员必须关注安全问题,尤其是在开发Windows应用程序和Web应用程序时。本文主要针对Visual Studio .NET和.NET框架的最终版本,介绍了在实现、调试和部署阶段中...

    .NET委托 .NET委托

    根据提供的信息,我们可以深入探讨.NET委托(Delegate)的相关概念及其在C#中的应用。下面将详细解释委托的基本概念、用途以及如何在实际编程场景中使用它们。 ### 委托的基本概念 在.NET框架中,委托是一种引用...

    C.NET中的委托和事件.pdf

    ### C#.NET中的委托和事件 #### 委托 在C#.NET中,委托是一种引用类型的数据结构,它封装了方法的引用。通过委托,我们可以将方法作为参数进行传递,或者...希望本文能够帮助读者深入理解C#.NET中的委托和事件机制。

    Visual C# .NET程序设计经典

    8. **事件和委托**:C#中的事件和委托是实现组件间通信的关键,它们在Windows Forms和WPF等用户界面编程中起到至关重要的作用。 9. **LINQ(Language Integrated Query)**:.NET Framework引入了LINQ,使得在C#中...

    Professional C# 5.0 and .NET 4.5.1.pdf_c#5.0_

    《Professional C# 5.0 and .NET 4.5.1》是针对C#编程语言和.NET Framework 4.5.1...通过阅读和实践书中的内容,读者不仅可以了解C# 5.0的新特性,还能学习到如何有效地利用.NET Framework 4.5.1构建高性能的应用程序。

    c#与.net 4高级程序设计

    1. **C#高级特性**:C#不仅包括基础的变量、控制流和函数,还涉及到一些高级特性,如委托、事件、匿名方法、lambda表达式、属性、索引器、运算符重载、枚举和结构等。这些特性使得C#在编写高效、简洁的代码时具有很...

Global site tag (gtag.js) - Google Analytics