委托和事件之2— 一个虚构的故事(转载)

Question

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举止文雅一些： 
   
  static void Main() { 
   Worker peter = new Worker(); 
   Boss boss = new Boss(); 
   peter.completed += new WorkCompleted(boss.WorkCompleted); 
   peter.started += new WorkStarted(Universe.WorkerStartedWork); 
   peter.completed += new WorkCompleted(Universe.WorkerCompletedWork); 
   peter.DoWork(); 
   
   Console.WriteLine("Main: worker completed work"); 
   Console.ReadLine(); 
  } 
   
  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可以通知他们每一个人，而不必管需要多长时间才能从那些目标方法中返回，并仍然可以异步得到评分结果。结果得到如下完整的解决方案： 
   
  delegate void WorkStarted(); 
  delegate void WorkProgressing(); 
  delegate int WorkCompleted(); 
   
  class Worker { 
   public void DoWork() { 
   Console.WriteLine("Worker: work started"); 
   if( started != null ) started(); 
   
   Console.WriteLine("Worker: work progressing"); 
   if( progressing != null ) progressing(); 
   
   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); 
   } 
   
   public event WorkStarted started; 
   public event WorkProgressing progressing; 
   public event WorkCompleted completed; 
  } 
   
  class Boss { 
   public int WorkCompleted() { 
   System.Threading.Thread.Sleep(3000); 
   Console.WriteLine("Better..."); return 6; /* 10分以内 */ 
   } 
  } 
   
  class Universe { 
   static void WorkerStartedWork() { 
   Console.WriteLine("Universe notices worker starting work"); 
   } 
   
   static int WorkerCompletedWork() { 
   System.Threading.Thread.Sleep(4000); 
   Console.WriteLine("Universe is pleased with worker's work"); 
   return 7; 
   } 
   
   static void Main() { 
   Worker peter = new Worker(); 
   Boss boss = new Boss(); 
   peter.completed += new WorkCompleted(boss.WorkCompleted); 
   peter.started += new WorkStarted(Universe.WorkerStartedWork); 
   peter.completed += new WorkCompleted(Universe.WorkerCompletedWork); 
   peter.DoWork(); 
   
   Console.WriteLine("Main: worker completed work"); 
   Console.ReadLine(); 
   } 
  } 
   
  Peter知道异步获取结果会带来一些问题。由于异步触发事件，所以目标方法有可能执行于另一个线程中，就像Peter的“目标方法何时完成”的通知那样。然而，Peter熟悉第14章“多线程用户界面”，因此，他知道在构建WinForms应用程序时如何去处理此类问题。 
   
  从此，他们一直过得都很快乐。