引言

如果你看過(guò)了 C#中的委托和事件 一文，我想你對(duì)委托和事件已經(jīng)有了一個(gè)基本的認(rèn)識(shí)。但那些遠(yuǎn)不是委托和事件的全部?jī)?nèi)容，還有很多的地方?jīng)]有涉及。本文將討論委托和事件一些更為細(xì)節(jié)的問(wèn)題，包括一些大家常問(wèn)到的問(wèn)題，以及事件訪問(wèn)器、異常處理、超時(shí)處理和異步方法調(diào)用等內(nèi)容。

為什么要使用事件而不是委托變量？

在 C#中的委托和事件 中，我提出了兩個(gè)為什么在類型中使用事件向外部提供方法注冊(cè)，而不是直接使用委托變量的原因。主要是從封裝性和易用性上去考慮，但是還漏掉了一點(diǎn)，事件應(yīng)該由事件發(fā)布者觸發(fā)，而不應(yīng)該由客戶端（客戶程序）來(lái)觸發(fā)。這句話是什么意思呢？請(qǐng)看下面的范例：

NOTE：注意這里術(shù)語(yǔ)的變化，當(dāng)我們單獨(dú)談?wù)撌录?，我們說(shuō)發(fā)布者(publisher)、訂閱者(subscriber)、客戶端(client)。當(dāng)我們討論Observer模式，我們說(shuō)主題(subject)和觀察者(observer)?？蛻舳送ǔＪ前琈ain()方法的Program類。

class Program {
   static void Main(string[] args) {
     Publishser pub = new Publishser();
     Subscriber sub = new Subscriber();
     
     pub.NumberChanged += new NumberChangedEventHandler(sub.OnNumberChanged);
     pub.DoSomething();     // 應(yīng)該通過(guò)DoSomething()來(lái)觸發(fā)事件
    pub.NumberChanged(100);   // 但可以被這樣直接調(diào)用，對(duì)委托變量的不恰當(dāng)使用
  }
 }

// 定義委托
public delegate void NumberChangedEventHandler(int count);

// 定義事件發(fā)布者
public class Publishser {
   private int count;
   public NumberChangedEventHandler NumberChanged;     // 聲明委托變量
  //public event NumberChangedEventHandler NumberChanged; // 聲明一個(gè)事件

  public void DoSomething() {
     // 在這里完成一些工作 ...

     if (NumberChanged != null) {  // 觸發(fā)事件
      count++;
       NumberChanged(count);
     }
   }
 }

// 定義事件訂閱者
public class Subscriber {
   public void OnNumberChanged(int count) {
     Console.WriteLine("Subscriber notified: count = {0}", count);
   }
 }

上面代碼定義了一個(gè)NumberChangedEventHandler委托，然后我們創(chuàng)建了事件的發(fā)布者Publisher和訂閱者Subscriber。當(dāng)使用委托變量時(shí)，客戶端可以直接通過(guò)委托變量觸發(fā)事件，也就是直接調(diào)用pub.NumberChanged(100)，這將會(huì)影響到所有注冊(cè)了該委托的訂閱者。而事件的本意應(yīng)該為在事件發(fā)布者在其本身的某個(gè)行為中觸發(fā)，比如說(shuō)在方法DoSomething()中滿足某個(gè)條件后觸發(fā)。通過(guò)添加event關(guān)鍵字來(lái)發(fā)布事件，事件發(fā)布者的封裝性會(huì)更好，事件僅僅是供其他類型訂閱，而客戶端不能直接觸發(fā)事件（語(yǔ)句pub.NumberChanged(100)無(wú)法通過(guò)編譯），事件只能在事件發(fā)布者Publisher類的內(nèi)部觸發(fā)（比如在方法pub.DoSomething()中），換言之，就是NumberChanged(100)語(yǔ)句只能在Publisher內(nèi)部被調(diào)用。

大家可以嘗試一下，將委托變量的聲明那行代碼注釋掉，然后取消下面事件聲明的注釋。此時(shí)程序是無(wú)法編譯的，當(dāng)你使用了event關(guān)鍵字之后，直接在客戶端觸發(fā)事件這種行為，也就是直接調(diào)用pub.NumberChanged(100)，是被禁止的。事件只能通過(guò)調(diào)用DoSomething()來(lái)觸發(fā)。這樣才是事件的本意，事件發(fā)布者的封裝才會(huì)更好。

就好像如果我們要定義一個(gè)數(shù)字類型，我們會(huì)使用int而不是使用object一樣，給予對(duì)象過(guò)多的能力并不見(jiàn)得是一件好事，應(yīng)該是越合適越好。盡管直接使用委托變量通常不會(huì)有什么問(wèn)題，但它給了客戶端不應(yīng)具有的能力，而使用事件，可以限制這一能力，更精確地對(duì)類型進(jìn)行封裝。

NOTE：這里還有一個(gè)約定俗稱的規(guī)定，就是訂閱事件的方法的命名，通常為“On事件名”，比如這里的OnNumberChanged。

為什么委托定義的返回值通常都為void？

盡管并非必需，但是我們發(fā)現(xiàn)很多的委托定義返回值都為void，為什么呢？這是因?yàn)槲凶兞靠梢怨┒鄠€(gè)訂閱者注冊(cè)，如果定義了返回值，那么多個(gè)訂閱者的方法都會(huì)向發(fā)布者返回?cái)?shù)值，結(jié)果就是后面一個(gè)返回的方法值將前面的返回值覆蓋掉了，因此，實(shí)際上只能獲得最后一個(gè)方法調(diào)用的返回值。可以運(yùn)行下面的代碼測(cè)試一下。除此以外，發(fā)布者和訂閱者是松耦合的，發(fā)布者根本不關(guān)心誰(shuí)訂閱了它的事件、為什么要訂閱，更別說(shuō)訂閱者的返回值了，所以返回訂閱者的方法返回值大多數(shù)情況下根本沒(méi)有必要。

class Program {
   static void Main(string[] args) {
     Publishser pub = new Publishser();
     Subscriber1 sub1 = new Subscriber1();
     Subscriber2 sub2 = new Subscriber2();
     Subscriber3 sub3 = new Subscriber3();

     pub.NumberChanged += new GeneralEventHandler(sub1.OnNumberChanged);
     pub.NumberChanged += new GeneralEventHandler(sub2.OnNumberChanged);
     pub.NumberChanged += new GeneralEventHandler(sub3.OnNumberChanged);
     pub.DoSomething();     // 觸發(fā)事件
  }
 }

// 定義委托
public delegate string GeneralEventHandler();

// 定義事件發(fā)布者
public class Publishser {
   public event GeneralEventHandler NumberChanged; // 聲明一個(gè)事件
  public void DoSomething() {
     if (NumberChanged != null) {  // 觸發(fā)事件
      string rtn = NumberChanged();
       Console.WriteLine(rtn);   // 打印返回的字符串，輸出為Subscriber3
    }
   }
 }

// 定義事件訂閱者
public class Subscriber1 { 
   public string OnNumberChanged() {
     return "Subscriber1";
   }
 }
public class Subscriber2 { /* 略，與上類似，返回Subscriber2*/ }
public class Subscriber3 { /* 略，與上類似，返回Subscriber3*/ }

如果運(yùn)行這段代碼，得到的輸出是Subscriber3，可以看到，只得到了最后一個(gè)注冊(cè)方法的返回值。

如何讓事件只允許一個(gè)客戶訂閱？

少數(shù)情況下，比如像上面，為了避免發(fā)生“值覆蓋”的情況（更多是在異步調(diào)用方法時(shí)，后面會(huì)討論），我們可能想限制只允許一個(gè)客戶端注冊(cè)。此時(shí)怎么做呢？我們可以向下面這樣，將事件聲明為private的，然后提供兩個(gè)方法來(lái)進(jìn)行注冊(cè)和取消注冊(cè)：

// 定義事件發(fā)布者
public class Publishser {
   private event GeneralEventHandler NumberChanged;  // 聲明一個(gè)私有事件
  // 注冊(cè)事件
  public void Register(GeneralEventHandler method) {
     NumberChanged = method;
   }
   // 取消注冊(cè)
  public void UnRegister(GeneralEventHandler method) {
     NumberChanged -= method;
   }

   public void DoSomething() {
     // 做某些其余的事情
    if (NumberChanged != null) {  // 觸發(fā)事件
      string rtn = NumberChanged();
       Console.WriteLine("Return: {0}", rtn);   // 打印返回的字符串，輸出為Subscriber3
    }
   }
 }

NOTE：注意上面，在UnRegister()中，沒(méi)有進(jìn)行任何判斷就使用了NumberChanged-=method語(yǔ)句。這是因?yàn)榧词筸ethod方法沒(méi)有進(jìn)行過(guò)注冊(cè)，此行語(yǔ)句也不會(huì)有任何問(wèn)題，不會(huì)拋出異常，僅僅是不會(huì)產(chǎn)生任何效果而已。

注意在Register()方法中，我們使用了賦值操作符“=”，而非“+=”，通過(guò)這種方式就避免了多個(gè)方法注冊(cè)。上面的代碼盡管可以完成我們的需要，但是此時(shí)大家還應(yīng)該注意下面兩點(diǎn)：

1、將NumberChanged聲明為委托變量還是事件都無(wú)所謂了，因?yàn)樗撬接械?，即便將它聲明為一個(gè)委托變量，客戶端也看不到它，也就無(wú)法通過(guò)它來(lái)觸發(fā)事件、調(diào)用訂閱者的方法。而只能通過(guò)Register()和UnRegister()方法來(lái)注冊(cè)和取消注冊(cè)，通過(guò)調(diào)用DoSomething()方法觸發(fā)事件（而不是NumberChanged本身，這在前面已經(jīng)討論過(guò)了）。

2、我們還應(yīng)該發(fā)現(xiàn)，這里采用的、對(duì)NumberChanged委托變量的訪問(wèn)模式和C#中的屬性是多么類似?。看蠹抑?，在C#中通常一個(gè)屬性對(duì)應(yīng)一個(gè)類型成員，而在類型的外部對(duì)成員的操作全部通過(guò)屬性來(lái)完成。盡管這里對(duì)委托變量的處理是類似的效果，但卻使用了兩個(gè)方法來(lái)進(jìn)行模擬，有沒(méi)有辦法像使用屬性一樣來(lái)完成上面的例子呢？答案是有的，C#中提供了一種叫事件訪問(wèn)器（Event Accessor）的東西，它用來(lái)封裝委托變量。如下面例子所示：

class Program {
   static void Main(string[] args) {
     Publishser pub = new Publishser();
     Subscriber1 sub1 = new Subscriber1();
     Subscriber2 sub2 = new Subscriber2();

     pub.NumberChanged -= sub1.OnNumberChanged; // 不會(huì)有任何反應(yīng)
    pub.NumberChanged += sub2.OnNumberChanged; // 注冊(cè)了sub2
    pub.NumberChanged += sub1.OnNumberChanged; // sub1將sub2的覆蓋掉了
    
     pub.DoSomething();     // 觸發(fā)事件
  }
 }

// 定義委托
public delegate string GeneralEventHandler();

// 定義事件發(fā)布者
public class Publishser {
   // 聲明一個(gè)委托變量
  private GeneralEventHandler numberChanged;
   // 事件訪問(wèn)器的定義
  public event GeneralEventHandler NumberChanged {
     add {
       numberChanged = value;
     }
     remove {
       numberChanged -= value;
     }
   }
   
   public void DoSomething() {
     // 做某些其他的事情
    if (numberChanged != null) {  // 通過(guò)委托變量觸發(fā)事件
      string rtn = numberChanged();
       Console.WriteLine("Return: {0}", rtn);   // 打印返回的字符串
    }
   }
 }

// 定義事件訂閱者
public class Subscriber1 {
   public string OnNumberChanged() {
     Console.WriteLine("Subscriber1 Invoked!");
     return "Subscriber1";
   }
 }
public class Subscriber2 {/* 與上類同，略 */}
public class Subscriber3 {/* 與上類同，略 */}

上面代碼中類似屬性的public event GeneralEventHandler NumberChanged {add{...}remove{...}}語(yǔ)句便是事件訪問(wèn)器。使用了事件訪問(wèn)器以后，在DoSomething方法中便只能通過(guò)numberChanged委托變量來(lái)觸發(fā)事件，而不能NumberChanged事件訪問(wèn)器（注意它們的大小寫不同）觸發(fā)，它只用于注冊(cè)和取消注冊(cè)。下面是代碼輸出：

獲得多個(gè)返回值與異常處理

現(xiàn)在假設(shè)我們想要獲得多個(gè)訂閱者的返回值，以List<string>的形式返回，該如何做呢？我們應(yīng)該記得委托定義在編譯時(shí)會(huì)生成一個(gè)繼承自MulticastDelegate的類，而這個(gè)MulticastDelegate又繼承自Delegate，在Delegate內(nèi)部，維護(hù)了一個(gè)委托鏈表，鏈表上的每一個(gè)元素，為一個(gè)只包含一個(gè)目標(biāo)方法的委托對(duì)象。而通過(guò)Delegate基類的GetInvocationList()靜態(tài)方法，可以獲得這個(gè)委托鏈表。隨后我們遍歷這個(gè)鏈表，通過(guò)鏈表中的每個(gè)委托對(duì)象來(lái)調(diào)用方法，這樣就可以分別獲得每個(gè)方法的返回值：

class Program4 {
   static void Main(string[] args) {
     Publishser pub = new Publishser();
     Subscriber1 sub1 = new Subscriber1();
     Subscriber2 sub2 = new Subscriber2();
     Subscriber3 sub3 = new Subscriber3();

     pub.NumberChanged += new DemoEventHandler(sub1.OnNumberChanged);
     pub.NumberChanged += new DemoEventHandler(sub2.OnNumberChanged);
     pub.NumberChanged += new DemoEventHandler(sub3.OnNumberChanged);

     List<string> list = pub.DoSomething(); //調(diào)用方法，在方法內(nèi)觸發(fā)事件

    foreach (string str in list) {
       Console.WriteLine(str);
     }      
   }
 }

public delegate string DemoEventHandler(int num);

// 定義事件發(fā)布者
public class Publishser {
   public event DemoEventHandler NumberChanged;  // 聲明一個(gè)事件

  public List<string> DoSomething() {
     // 做某些其他的事

    List<string> strList = new List<string>();
     if (NumberChanged == null) return strList;

     // 獲得委托數(shù)組
    Delegate[] delArray = NumberChanged.GetInvocationList();

     foreach (Delegate del in delArray) {
       // 進(jìn)行一個(gè)向下轉(zhuǎn)換
      DemoEventHandler method = (DemoEventHandler)del;
       strList.Add(method(100));    // 調(diào)用方法并獲取返回值
    }
     
     return strList;
   }
 }

// 定義事件訂閱者
public class Subscriber1 {
   public string OnNumberChanged(int num) {
     Console.WriteLine("Subscriber1 invoked, number:{0}", num);
     return "[Subscriber1 returned]";
   }
 }
public class Subscriber3 {與上面類同，略}
public class Subscriber3 {與上面類同，略}

如果運(yùn)行上面的代碼，可以得到這樣的輸出：

可見(jiàn)我們獲得了三個(gè)方法的返回值。而我們前面說(shuō)過(guò)，很多情況下委托的定義都不包含返回值，所以上面介紹的方法似乎沒(méi)有什么實(shí)際意義。其實(shí)通過(guò)這種方式來(lái)觸發(fā)事件最常見(jiàn)的情況應(yīng)該是在異常處理中，因?yàn)楹苡锌赡茉谟|發(fā)事件時(shí)，訂閱者的方法會(huì)拋出異常，而這一異常會(huì)直接影響到發(fā)布者，使得發(fā)布者程序中止，而后面訂閱者的方法將不會(huì)被執(zhí)行。因此我們需要加上異常處理，考慮下面一段程序：

class Program5 {
   static void Main(string[] args) {
     Publisher pub = new Publisher();
     Subscriber1 sub1 = new Subscriber1();
     Subscriber2 sub2 = new Subscriber2();
     Subscriber3 sub3 = new Subscriber3();

     pub.NumberChanged += new DemoEventHandler(sub1.OnNumberChanged);
     pub.NumberChanged += new DemoEventHandler(sub2.OnNumberChanged);
     pub.NumberChanged += new DemoEventHandler(sub3.OnNumberChanged);
   }
 }

public class Publisher {
   public event EventHandler MyEvent;
   public void DoSomething() {
     // 做某些其他的事情
    if (MyEvent != null) {
       try {
         MyEvent(this, EventArgs.Empty);
       } catch (Exception e) {
         Console.WriteLine("Exception: {0}", e.Message);
       }
     }
   }
 }

public class Subscriber1 {
   public void OnEvent(object sender, EventArgs e) {
     Console.WriteLine("Subscriber1 Invoked!");
   }
 }

public class Subscriber2 {
   public void OnEvent(object sender, EventArgs e) {
     throw new Exception("Subscriber2 Failed");
   }
 }
public class Subscriber3 {/* 與Subsciber1類同，略*/}

注意到我們?cè)赟ubscriber2中拋出了異常，同時(shí)我們?cè)赑ublisher中使用了try/catch語(yǔ)句來(lái)處理異常。運(yùn)行上面的代碼，我們得到的結(jié)果是：

可以看到，盡管我們捕獲了異常，使得程序沒(méi)有異常結(jié)束，但是卻影響到了后面的訂閱者，因?yàn)镾ubscriber3也訂閱了事件，但是卻沒(méi)有收到事件通知（它的方法沒(méi)有被調(diào)用）。此時(shí)，我們可以采用上面的辦法，先獲得委托鏈表，然后在遍歷鏈表的循環(huán)中處理異常，我們只需要修改一下DoSomething方法就可以了：

public void DoSomething() {
   if (MyEvent != null) {
     Delegate[] delArray = MyEvent.GetInvocationList();
     foreach (Delegate del in delArray) {
       EventHandler method = (EventHandler)del;  // 強(qiáng)制轉(zhuǎn)換為具體的委托類型
      try {
         method(this, EventArgs.Empty);
       } catch (Exception e) {
         Console.WriteLine("Exception: {0}", e.Message);
       }
     }
   }
 }

注意到Delegate是EventHandler的基類，所以為了觸發(fā)事件，先要進(jìn)行一個(gè)向下的強(qiáng)制轉(zhuǎn)換，之后才能在其上觸發(fā)事件，調(diào)用所有注冊(cè)對(duì)象的方法。除了使用這種方式以外，還有一種更靈活方式可以調(diào)用方法，它是定義在Delegate基類中的DynamicInvoke()方法：

public object DynamicInvoke(params object[] args);

這可能是調(diào)用委托最通用的方法了，適用于所有類型的委托。它接受的參數(shù)為object[]，也就是說(shuō)它可以將任意數(shù)量的任意類型作為參數(shù)，并返回單個(gè)object對(duì)象。上面的DoSomething()方法也可以改寫成下面這種通用形式：

public void DoSomething() {
   // 做某些其他的事情
  if (MyEvent != null) {
     Delegate[] delArray = MyEvent.GetInvocationList();
     foreach (Delegate del in delArray) {          
       try {
         // 使用DynamicInvoke方法觸發(fā)事件
        del.DynamicInvoke(this, EventArgs.Empty);  
       } catch (Exception e) {
         Console.WriteLine("Exception: {0}", e.Message);
       }
     }
   }
 }

注意現(xiàn)在在DoSomething()方法中，我們?nèi)∠讼蚓唧w委托類型的向下轉(zhuǎn)換，現(xiàn)在沒(méi)有了任何的基于特定委托類型的代碼，而DynamicInvoke又可以接受任何類型的參數(shù)，且返回一個(gè)object對(duì)象。所以我們完全可以將DoSomething()方法抽象出來(lái)，使它成為一個(gè)公共方法，然后供其他類來(lái)調(diào)用，我們將這個(gè)方法聲明為靜態(tài)的，然后定義在Program類中：

// 觸發(fā)某個(gè)事件，以列表形式返回所有方法的返回值
public static object[] FireEvent(Delegate del, params object[] args){

   List<object> objList = new List<object>();

   if (del != null) {
     Delegate[] delArray = del.GetInvocationList();
     foreach (Delegate method in delArray) {
       try {
         // 使用DynamicInvoke方法觸發(fā)事件
        object obj = method.DynamicInvoke(args);
         if (obj != null)
           objList.Add(obj);
       } catch { }
     }
   }
   return objList.ToArray();
 }

隨后，我們?cè)贒oSomething()中只要簡(jiǎn)單的調(diào)用一下這個(gè)方法就可以了：

public void DoSomething() {
   // 做某些其他的事情
  Program5.FireEvent(MyEvent, this, EventArgs.Empty);
 }

注意FireEvent()方法還可以返回一個(gè)object[]數(shù)組，這個(gè)數(shù)組包括了所有訂閱者方法的返回值。而在上面的例子中，我沒(méi)有演示如何獲取并使用這個(gè)數(shù)組，為了節(jié)省篇幅，這里也不再贅述了，在本文附帶的代碼中，有關(guān)于這部分的演示，有興趣的朋友可以下載下來(lái)看看。

委托中訂閱者方法超時(shí)的處理

訂閱者除了可以通過(guò)異常的方式來(lái)影響發(fā)布者以外，還可以通過(guò)另一種方式：超時(shí)。一般說(shuō)超時(shí)，指的是方法的執(zhí)行超過(guò)某個(gè)指定的時(shí)間，而這里我將含義擴(kuò)展了一下，凡是方法執(zhí)行的時(shí)間比較長(zhǎng)，我就認(rèn)為它超時(shí)了，這個(gè)“比較長(zhǎng)”是一個(gè)比較模糊的概念，2秒、3秒、5秒都可以視為超時(shí)。超時(shí)和異常的區(qū)別就是超時(shí)并不會(huì)影響事件的正確觸發(fā)和程序的正常運(yùn)行，卻會(huì)導(dǎo)致事件觸發(fā)后需要很長(zhǎng)才能夠結(jié)束。在依次執(zhí)行訂閱者的方法這段期間內(nèi)，客戶端程序會(huì)被中斷，什么也不能做。因?yàn)楫?dāng)執(zhí)行訂閱者方法時(shí)（通過(guò)委托，相當(dāng)于依次調(diào)用所有注冊(cè)了的方法），當(dāng)前線程會(huì)轉(zhuǎn)去執(zhí)行方法中的代碼，調(diào)用方法的客戶端會(huì)被中斷，只有當(dāng)方法執(zhí)行完畢并返回時(shí)，控制權(quán)才會(huì)回到客戶端，從而繼續(xù)執(zhí)行下面的代碼。我們來(lái)看一下下面一個(gè)例子：

class Program6 {
   static void Main(string[] args) {

     Publisher pub = new Publisher();
     Subscriber1 sub1 = new Subscriber1();
     Subscriber2 sub2 = new Subscriber2();
     Subscriber3 sub3 = new Subscriber3();

     pub.MyEvent += new EventHandler(sub1.OnEvent);
     pub.MyEvent += new EventHandler(sub2.OnEvent);
     pub.MyEvent += new EventHandler(sub3.OnEvent);

     pub.DoSomething();   // 觸發(fā)事件

    Console.WriteLine("\nControl back to client!"); // 返回控制權(quán)
  }

   // 觸發(fā)某個(gè)事件，以列表形式返回所有方法的返回值
  public static object[] FireEvent(Delegate del, params object[] args) {
     // 代碼與上同，略
  }
 }

public class Publisher {
   public event EventHandler MyEvent;
   public void DoSomething() {
     // 做某些其他的事情
    Console.WriteLine("DoSomething invoked!");
     Program6.FireEvent(MyEvent, this, EventArgs.Empty); //觸發(fā)事件
  }
 }

public class Subscriber1 {
   public void OnEvent(object sender, EventArgs e) {
     Thread.Sleep(TimeSpan.FromSeconds(3));
     Console.WriteLine("Waited for 3 seconds, subscriber1 invoked!");
   }
 }
public class Subscriber2 {
   public void OnEvent(object sender, EventArgs e) {
     Console.WriteLine("Subscriber2 immediately Invoked!");
   }
 }
public class Subscriber3 {
   public void OnEvent(object sender, EventArgs e) {
     Thread.Sleep(TimeSpan.FromSeconds(2));
     Console.WriteLine("Waited for 2 seconds, subscriber2 invoked!");
   }
 }

在這段代碼中，我們使用Thread.Sleep()靜態(tài)方法模擬了方法超時(shí)的情況。其中Subscriber1.OnEvent()需要三秒鐘完成，Subscriber2.OnEvent()立即執(zhí)行，Subscriber3.OnEvent需要兩秒完成。這段代碼完全可以正常輸出，也沒(méi)有異常拋出（如果有，也僅僅是該訂閱者被忽略掉），下面是輸出的情況：

但是這段程序在調(diào)用方法DoSomething()、打印了“DoSomething invoked”之后，觸發(fā)了事件，隨后必須等訂閱者的三個(gè)方法全部執(zhí)行完畢了之后，也就是大概5秒鐘的時(shí)間，才能繼續(xù)執(zhí)行下面的語(yǔ)句，也就是打印“Control back to client”。而我們前面說(shuō)過(guò)，很多情況下，尤其是遠(yuǎn)程調(diào)用的時(shí)候（比如說(shuō)在Remoting中），發(fā)布者和訂閱者應(yīng)該是完全的松耦合，發(fā)布者不關(guān)心誰(shuí)訂閱了它、不關(guān)心訂閱者的方法有什么返回值、不關(guān)心訂閱者會(huì)不會(huì)拋出異常，當(dāng)然也不關(guān)心訂閱者需要多長(zhǎng)時(shí)間才能完成訂閱的方法，它只要在事件發(fā)生的那一瞬間告知訂閱者事件已經(jīng)發(fā)生并將相關(guān)參數(shù)傳給訂閱者就可以了。然后它就應(yīng)該繼續(xù)執(zhí)行它后面的動(dòng)作，在本例中就是打印“Control back to client！”。而訂閱者不管失敗或是超時(shí)都不應(yīng)該影響到發(fā)布者，但在上面的例子中，發(fā)布者卻不得不等待訂閱者的方法執(zhí)行完畢才能繼續(xù)運(yùn)行。

現(xiàn)在我們來(lái)看下如何解決這個(gè)問(wèn)題，先回顧一下之前我在C#中的委托和事件一文中提到的內(nèi)容，我說(shuō)過(guò)，委托的定義會(huì)生成繼承自MulticastDelegate的完整的類，其中包含Invoke()、BeginInvoke()和EndInvoke()方法。當(dāng)我們直接調(diào)用委托時(shí)，實(shí)際上是調(diào)用了Invoke()方法，它會(huì)中斷調(diào)用它的客戶端，然后在客戶端線程上執(zhí)行所有訂閱者的方法（客戶端無(wú)法繼續(xù)執(zhí)行后面代碼），最后將控制權(quán)返回客戶端。注意到BeginInvoke()、EndInvoke()方法，在.Net中，異步執(zhí)行的方法通常都會(huì)配對(duì)出現(xiàn)，并且以Begin和End作為方法的開頭（最常見(jiàn)的可能就是Stream類的BeginRead()和EndRead()方法了）。它們用于方法的異步執(zhí)行，即是在調(diào)用BeginInvoke()之后，客戶端從線程池中抓取一個(gè)閑置線程，然后交由這個(gè)線程去執(zhí)行訂閱者的方法，而客戶端線程則可以繼續(xù)執(zhí)行下面的代碼。

BeginInvoke()接受“動(dòng)態(tài)”的參數(shù)個(gè)數(shù)和類型，為什么說(shuō)“動(dòng)態(tài)”的呢？因?yàn)樗膮?shù)是在編譯時(shí)根據(jù)委托的定義動(dòng)態(tài)生成的，其中前面參數(shù)的個(gè)數(shù)和類型與委托定義中接受的參數(shù)個(gè)數(shù)和類型相同，最后兩個(gè)參數(shù)分別是AsyncCallback和Object類型，對(duì)于它們更具體的內(nèi)容，可以參見(jiàn)下一節(jié)委托和方法的異步調(diào)用部分。現(xiàn)在，我們僅需要對(duì)這兩個(gè)參數(shù)傳入null就可以了。另外還需要注意幾點(diǎn)：

• 在委托類型上調(diào)用BeginInvoke()時(shí)，此委托對(duì)象只能包含一個(gè)目標(biāo)方法，所以對(duì)于多個(gè)訂閱者注冊(cè)的情況，必須使用GetInvocationList()獲得所有委托對(duì)象，然后遍歷它們，分別在其上調(diào)用BeginInvoke()方法。如果直接在委托上調(diào)用BeginInvoke()，會(huì)拋出異常，提示“委托只能包含一個(gè)目標(biāo)方法”。
• 如果訂閱者的方法拋出異常，.NET會(huì)捕捉到它，但是只有在調(diào)用EndInvoke()的時(shí)候，才會(huì)將異常重新拋出。而在本例中，我們不使用EndInvoke()（因?yàn)槲覀儾魂P(guān)心訂閱者的執(zhí)行情況），所以我們無(wú)需處理異常，因?yàn)榧词箳伋霎惓＃彩窃诹硪粋€(gè)線程上，不會(huì)影響到客戶端線程（客戶端甚至不知道訂閱者發(fā)生了異常，這有時(shí)是好事有時(shí)是壞事）。
• BeginInvoke()方法屬于委托定義所生成的類，它既不屬于MulticastDelegate也不屬于Delegate基類，所以無(wú)法繼續(xù)使用可重用的FireEvent()方法，我們需要進(jìn)行一個(gè)向下轉(zhuǎn)換，來(lái)獲取到實(shí)際的委托類型。

現(xiàn)在我們修改一下上面的程序，使用異步調(diào)用來(lái)解決訂閱者方法執(zhí)行超時(shí)的情況：

class Program6 {
   static void Main(string[] args) {

     Publisher pub = new Publisher();
     Subscriber1 sub1 = new Subscriber1();
     Subscriber2 sub2 = new Subscriber2();
     Subscriber3 sub3 = new Subscriber3();

     pub.MyEvent += new EventHandler(sub1.OnEvent);
     pub.MyEvent += new EventHandler(sub2.OnEvent);
     pub.MyEvent += new EventHandler(sub3.OnEvent);

     pub.DoSomething();   // 觸發(fā)事件

    Console.WriteLine("Control back to client!\n"); // 返回控制權(quán)
    Console.WriteLine("Press any thing to exit...");
     Console.ReadKey();   // 暫?？蛻舫绦?，提供時(shí)間供訂閱者完成方法
  }
 }

public class Publisher {
   public event EventHandler MyEvent;
   public void DoSomething() {     
     // 做某些其他的事情
    Console.WriteLine("DoSomething invoked!");

     if (MyEvent != null) {
       Delegate[] delArray = MyEvent.GetInvocationList();

       foreach (Delegate del in delArray) {
         EventHandler method = (EventHandler)del;
         method.BeginInvoke(null, EventArgs.Empty, null, null);
       }
     }
   }
 }

public class Subscriber1 {
   public void OnEvent(object sender, EventArgs e) {
     Thread.Sleep(TimeSpan.FromSeconds(3));   // 模擬耗時(shí)三秒才能完成方法
    Console.WriteLine("Waited for 3 seconds, subscriber1 invoked!");
   }
 }

public class Subscriber2 {
   public void OnEvent(object sender, EventArgs e) {
     throw new Exception("Subsciber2 Failed");  // 即使拋出異常也不會(huì)影響到客戶端
    //Console.WriteLine("Subscriber2 immediately Invoked!");
  }
 }

public class Subscriber3 {
   public void OnEvent(object sender, EventArgs e) {
     Thread.Sleep(TimeSpan.FromSeconds(2)); // 模擬耗時(shí)兩秒才能完成方法
    Console.WriteLine("Waited for 2 seconds, subscriber3 invoked!");
   }
 }

運(yùn)行上面的代碼，會(huì)得到下面的輸出：

需要注意代碼輸出中的幾個(gè)變化：

1.我們需要在客戶端程序中調(diào)用Console.ReadKey()方法來(lái)暫停客戶端，以提供足夠的時(shí)間來(lái)讓異步方法去執(zhí)行完代碼，不然的話客戶端的程序到此處便會(huì)運(yùn)行結(jié)束，程序會(huì)退出，不會(huì)看到任何訂閱者方法的輸出，因?yàn)樗鼈兏緵](méi)來(lái)得及執(zhí)行完畢。原因是這樣的：客戶端所在的線程我們通常稱為主線程，而執(zhí)行訂閱者方法的線程來(lái)自線程池，屬于后臺(tái)線程(Background Thread），當(dāng)主線程結(jié)束時(shí)，不論后臺(tái)線程有沒(méi)有結(jié)束，都會(huì)退出程序。（當(dāng)然還有一種前臺(tái)線程(Foreground Thread)，主線程結(jié)束后必須等前臺(tái)線程也結(jié)束后程序才會(huì)退出，關(guān)于線程的討論可以開辟另一個(gè)龐大的主題，這里就不討論了）。
2.在打印完“Press any thing to exit...”之后，兩個(gè)訂閱者的方法會(huì)以2秒、1秒的間隔顯示出來(lái)，且盡管我們先注冊(cè)了subscirber1，但是卻先執(zhí)行了subscriber3，這是因?yàn)閳?zhí)行它需要的時(shí)間更短。除此以外，注意到這兩個(gè)方法是并行執(zhí)行的，所以執(zhí)行它們的總時(shí)間是最長(zhǎng)的方法所需要的時(shí)間，也就是3秒，而不是他們的累加5秒。
3.如同前面所提到的，盡管subscriber2拋出了異常，我們也沒(méi)有針對(duì)異常進(jìn)行處理，但是客戶程序并沒(méi)有察覺(jué)到，程序也沒(méi)有因此而中斷。

委托和方法的異步調(diào)用

通常情況下，如果需要異步執(zhí)行一個(gè)耗時(shí)的操作，我們會(huì)新起一個(gè)線程，然后讓這個(gè)線程去執(zhí)行代碼。但是對(duì)于每一個(gè)異步調(diào)用都通過(guò)創(chuàng)建線程來(lái)進(jìn)行操作顯然會(huì)對(duì)性能產(chǎn)生一定的影響，同時(shí)操作也相對(duì)繁瑣一些。.Net中可以通過(guò)委托進(jìn)行方法的異步調(diào)用，就是說(shuō)客戶端在異步調(diào)用方法時(shí)，本身并不會(huì)因?yàn)榉椒ǖ恼{(diào)用而中斷，而是從線程池中抓取一個(gè)線程去執(zhí)行該方法，自身線程（主線程）在完成抓取線程這一過(guò)程之后，繼續(xù)執(zhí)行下面的代碼，這樣就實(shí)現(xiàn)了代碼的并行執(zhí)行。使用線程池的好處就是避免了頻繁進(jìn)行異步調(diào)用時(shí)創(chuàng)建、銷毀線程的開銷。

如同上面所示，當(dāng)我們?cè)谖袑?duì)象上調(diào)用BeginInvoke()時(shí)，便進(jìn)行了一個(gè)異步的方法調(diào)用。上面的例子中是在事件的發(fā)布和訂閱這一過(guò)程中使用了異步調(diào)用，而在事件發(fā)布者和訂閱者之間往往是松耦合的，發(fā)布者通常不需要獲得訂閱者方法執(zhí)行的情況；而當(dāng)使用異步調(diào)用時(shí)，更多情況下是為了提升系統(tǒng)的性能，而并非專用于事件的發(fā)布和訂閱這一編程模型。而在這種情況下使用異步編程時(shí)，就需要進(jìn)行更多的控制，比如當(dāng)異步執(zhí)行方法的方法結(jié)束時(shí)通知客戶端、返回異步執(zhí)行方法的返回值等。本節(jié)就對(duì)BeginInvoke()方法、EndInvoke()方法和其相關(guān)的IAysncResult做一個(gè)簡(jiǎn)單的介紹。

NOTE：注意此處我已經(jīng)不再使用發(fā)布者、訂閱者這些術(shù)語(yǔ)，因?yàn)槲覀儾辉偈怯懻撋厦娴氖录Ｐ停怯懻撛诳蛻舳顺绦蛑挟惒降卣{(diào)用方法，這里有一個(gè)思維的轉(zhuǎn)變。

我們看這樣一段代碼，它演示了不使用異步調(diào)用的通常情況：

class Program7 {
   static void Main(string[] args) {

     Console.WriteLine("Client application started!\n");
     Thread.CurrentThread.Name = "Main Thread";

     Calculator cal = new Calculator();
     int result = cal.Add(2, 5);
     Console.WriteLine("Result: {0}\n", result); 
     
     // 做某些其它的事情，模擬需要執(zhí)行3秒鐘
    for (int i = 1; i <= 3; i++) {
       Thread.Sleep(TimeSpan.FromSeconds(i));
       Console.WriteLine("{0}: Client executed {1} second(s).",
         Thread.CurrentThread.Name, i); 
     }

     Console.WriteLine("\nPress any key to exit...");
     Console.ReadKey();
   }
 }

public class Calculator {
   public int Add(int x, int y) {
     if (Thread.CurrentThread.IsThreadPoolThread) {
       Thread.CurrentThread.Name = "Pool Thread";
     }
     Console.WriteLine("Method invoked!");      

     // 執(zhí)行某些事情，模擬需要執(zhí)行2秒鐘
    for (int i = 1; i <= 2; i++) {
       Thread.Sleep(TimeSpan.FromSeconds(i));
       Console.WriteLine("{0}: Add executed {1} second(s).", 
         Thread.CurrentThread.Name, i); 
     }
     Console.WriteLine("Method complete!");
     return x + y;
   }
 } 

上面代碼有幾個(gè)關(guān)于對(duì)于線程的操作，如果不了解可以看一下下面的說(shuō)明，如果你已經(jīng)了解可以直接跳過(guò)：

•Thread.Sleep()，它會(huì)讓執(zhí)行當(dāng)前代碼的線程暫停一段時(shí)間（如果你對(duì)線程的概念比較陌生，可以理解為使程序的執(zhí)行暫停一段時(shí)間），以毫秒為單位，比如Thread.Sleep(1000)，將會(huì)使線程暫停1秒鐘。在上面我使用了它的重載方法，個(gè)人覺(jué)得使用TimeSpan.FromSeconds(1)，可讀性更好一些。
•Thread.CurrentThread.Name，通過(guò)這個(gè)屬性可以設(shè)置、獲取執(zhí)行當(dāng)前代碼的線程的名稱，值得注意的是這個(gè)屬性只可以設(shè)置一次，如果設(shè)置兩次，會(huì)拋出異常。
•Thread.IsThreadPoolThread，可以判斷執(zhí)行當(dāng)前代碼的線程是否為線程池中的線程。

通過(guò)這幾個(gè)方法和屬性，有助于我們更好地調(diào)試異步調(diào)用方法。上面代碼中除了加入了一些對(duì)線程的操作以外再?zèng)]有什么特別之處。我們建了一個(gè)Calculator類，它只有一個(gè)Add方法，我們模擬了這個(gè)方法需要執(zhí)行2秒鐘時(shí)間，并且每隔一秒進(jìn)行一次輸出。而在客戶端程序中，我們使用result變量保存了方法的返回值并進(jìn)行了打印。隨后，我們?cè)俅文M了客戶端程序接下來(lái)的操作需要執(zhí)行2秒鐘時(shí)間。運(yùn)行這段程序，會(huì)產(chǎn)生下面的輸出：

如果你確實(shí)執(zhí)行了這段代碼，會(huì)看到這些輸出并不是一瞬間輸出的，而是執(zhí)行了大概5秒鐘的時(shí)間，因?yàn)榫€程是串行執(zhí)行的，所以在執(zhí)行完Add()方法之后才會(huì)繼續(xù)客戶端剩下的代碼。

接下來(lái)我們定義一個(gè)AddDelegate委托，并使用BeginInvoke()方法來(lái)異步地調(diào)用它。在上面已經(jīng)介紹過(guò)，BeginInvoke()除了最后兩個(gè)參數(shù)為AsyncCallback類型和Object類型以外，前面的參數(shù)類型和個(gè)數(shù)與委托定義相同。另外BeginInvoke()方法返回了一個(gè)實(shí)現(xiàn)了IAsyncResult接口的對(duì)象（實(shí)際上就是一個(gè)AsyncResult類型實(shí)例，注意這里IAsyncResult和AysncResult是不同的，它們均包含在.Net Framework中）。

AsyncResult的用途有這么幾個(gè)：傳遞參數(shù)，它包含了對(duì)調(diào)用了BeginInvoke()的委托的引用；它還包含了BeginInvoke()的最后一個(gè)Object類型的參數(shù)；它可以鑒別出是哪個(gè)方法的哪一次調(diào)用，因?yàn)橥ㄟ^(guò)同一個(gè)委托變量可以對(duì)同一個(gè)方法調(diào)用多次。

EndInvoke()方法接受IAsyncResult類型的對(duì)象（以及ref和out類型參數(shù)，這里不討論了，對(duì)它們的處理和返回值類似），所以在調(diào)用BeginInvoke()之后，我們需要保留IAsyncResult，以便在調(diào)用EndInvoke()時(shí)進(jìn)行傳遞。這里最重要的就是EndInvoke()方法的返回值，它就是方法的返回值。除此以外，當(dāng)客戶端調(diào)用EndInvoke()時(shí)，如果異步調(diào)用的方法沒(méi)有執(zhí)行完畢，則會(huì)中斷當(dāng)前線程而去等待該方法，只有當(dāng)異步方法執(zhí)行完畢后才會(huì)繼續(xù)執(zhí)行后面的代碼。所以在調(diào)用完BeginInvoke()后立即執(zhí)行EndInvoke()是沒(méi)有任何意義的。我們通常在盡可能早的時(shí)候調(diào)用BeginInvoke()，然后在需要方法的返回值的時(shí)候再去調(diào)用EndInvoke()，或者是根據(jù)情況在晚些時(shí)候調(diào)用。說(shuō)了這么多，我們現(xiàn)在看一下使用異步調(diào)用改寫后上面的代碼吧：

public delegate int AddDelegate(int x, int y);

class Program8 {  

   static void Main(string[] args) {

     Console.WriteLine("Client application started!\n");
     Thread.CurrentThread.Name = "Main Thread";
           
     Calculator cal = new Calculator();
     AddDelegate del = new AddDelegate(cal.Add);
     IAsyncResult asyncResult = del.BeginInvoke(2,5,null,null); // 異步調(diào)用方法

    // 做某些其它的事情，模擬需要執(zhí)行3秒鐘
    for (int i = 1; i <= 3; i++) {
       Thread.Sleep(TimeSpan.FromSeconds(i));
       Console.WriteLine("{0}: Client executed {1} second(s).",
         Thread.CurrentThread.Name, i);
     }

     int rtn = del.EndInvoke(asyncResult);
     Console.WriteLine("Result: {0}\n", rtn);

     Console.WriteLine("\nPress any key to exit...");
     Console.ReadKey();
   }
 }

public class Calculator { /* 與上面同，略 */}

此時(shí)的輸出為：

現(xiàn)在執(zhí)行完這段代碼只需要3秒鐘時(shí)間，兩個(gè)for循環(huán)所產(chǎn)生的輸出交替進(jìn)行，這也說(shuō)明了這兩段代碼并行執(zhí)行的情況。可以看到Add()方法是由線程池中的線程在執(zhí)行，因?yàn)門hread.CurrentThread.IsThreadPoolThread返回了True，同時(shí)我們對(duì)該線程命名為了Pool Thread。另外我們可以看到通過(guò)EndInvoke()方法得到了返回值。

有時(shí)候，我們可能會(huì)將獲得返回值的操作放到另一段代碼或者客戶端去執(zhí)行，而不是向上面那樣直接寫在BeginInvoke()的后面。比如說(shuō)我們?cè)赑rogram中新建一個(gè)方法GetReturn()，此時(shí)可以通過(guò)AsyncResult的AsyncDelegate獲得del委托對(duì)象，然后再在其上調(diào)用EndInvoke()方法，這也說(shuō)明了AsyncResult可以唯一的獲取到與它相關(guān)的調(diào)用了的方法（或者也可以理解成委托對(duì)象）。所以上面獲取返回值的代碼也可以改寫成這樣：

static int GetReturn(IAsyncResult asyncResult) {
   AsyncResult result = (AsyncResult)asyncResult;
   AddDelegate del = (AddDelegate)result.AsyncDelegate;
   int rtn = del.EndInvoke(asyncResult);
   return rtn;
 }

然后再將int rtn = del.EndInvoke(asyncResult);語(yǔ)句改為int rtn = GetReturn(asyncResult);。注意上面IAsyncResult要轉(zhuǎn)換為實(shí)際的類型AsyncResult才能訪問(wèn)AsyncDelegate屬性，因?yàn)樗鼪](méi)有包含在IAsyncResult接口的定義中。

BeginInvoke的另外兩個(gè)參數(shù)分別是AsyncCallback和Object類型，其中AsyncCallback是一個(gè)委托類型，它用于方法的回調(diào)，即是說(shuō)當(dāng)異步方法執(zhí)行完畢時(shí)自動(dòng)進(jìn)行調(diào)用的方法。它的定義為：

public delegate void AsyncCallback(IAsyncResult ar);

Object類型用于傳遞任何你想要的數(shù)值，它可以通過(guò)IAsyncResult的AsyncState屬性獲得。下面我們將獲取方法返回值、打印返回值的操作放到了OnAddComplete()回調(diào)方法中：

public delegate int AddDelegate(int x, int y);

class Program9 {

   static void Main(string[] args) {

     Console.WriteLine("Client application started!\n");
     Thread.CurrentThread.Name = "Main Thread";

     Calculator cal = new Calculator();
     AddDelegate del = new AddDelegate(cal.Add);
     string data = "Any data you want to pass.";
     AsyncCallback callBack = new AsyncCallback(OnAddComplete);
     del.BeginInvoke(2, 5, callBack, data);   // 異步調(diào)用方法

    // 做某些其它的事情，模擬需要執(zhí)行3秒鐘
    for (int i = 1; i <= 3; i++) {
       Thread.Sleep(TimeSpan.FromSeconds(i));
       Console.WriteLine("{0}: Client executed {1} second(s).",
         Thread.CurrentThread.Name, i);
     }

     Console.WriteLine("\nPress any key to exit...");
     Console.ReadKey();
   }

   static void OnAddComplete(IAsyncResult asyncResult) {
     AsyncResult result = (AsyncResult)asyncResult;
     AddDelegate del = (AddDelegate)result.AsyncDelegate;
     string data = (string)asyncResult.AsyncState;

     int rtn = del.EndInvoke(asyncResult);
     Console.WriteLine("{0}: Result, {1}; Data: {2}\n", 
       Thread.CurrentThread.Name, rtn, data);
   }
 }
public class Calculator { /* 與上面同，略 */}

它產(chǎn)生的輸出為：

這里有幾個(gè)值得注意的地方：1、我們?cè)谡{(diào)用BeginInvoke()后不再需要保存IAysncResult了，因?yàn)锳ysncCallback委托將該對(duì)象定義在了回調(diào)方法的參數(shù)列表中；2、我們?cè)贠nAddComplete()方法中獲得了調(diào)用BeginInvoke()時(shí)最后一個(gè)參數(shù)傳遞的值，字符串“Any data you want to pass”；3、執(zhí)行回調(diào)方法的線程并非客戶端線程Main Thread，而是來(lái)自線程池中的線程Pool Thread。另外如前面所說(shuō)，在調(diào)用EndInvoke()時(shí)有可能會(huì)拋出異常，所以在應(yīng)該將它放到try/catch塊中，這里我就不再示范了。

總結(jié)

這篇文章是對(duì)我之前寫的C#中的委托和事件的一個(gè)補(bǔ)充，大致分為了三個(gè)部分，第一部分講述了幾個(gè)容易讓人產(chǎn)生困惑的問(wèn)題：為什么使用事件而不是委托變量，為什么通常委托的定義都返回void；第二部分講述了如何處理異常和超時(shí)；第三部分則講述了通過(guò)委托實(shí)現(xiàn)異步方法的調(diào)用。

感謝閱讀，希望這篇文章能給你帶來(lái)幫助。