C#中的委托和事件(續)C#中的委托和事件(續)

轉自 http://www.cnblogs.com/JimmyZhang/archive/2008/08/22/1274342.html

NOTE：注 意這裡術語的變化，當我們單獨談論事件，我們說釋出者(publisher)、訂閱者(subscriber)、用戶端(client)。當我們讨論 Observer模式，我們說主題(subject)和觀察者(observer)。用戶端通常是包含Main()方法的Program類。

class Program {

    static void Main(string[] args) {

        Publishser pub = new Publishser();

        Subscriber sub = new Subscriber();

        pub.NumberChanged += new NumberChangedEventHandler(sub.OnNumberChanged);

        pub.DoSomething();          // 應該通過DoSomething()來觸發事件

        pub.NumberChanged(100);     // 但可以被這樣直接調用，對委托變量的不恰當使用

    }

}

// 定義委托

public delegate void NumberChangedEventHandler(int count);

// 定義事件釋出者

public class Publishser {

    private int count;

    public NumberChangedEventHandler NumberChanged;         // 聲明委托變量

    //public event NumberChangedEventHandler NumberChanged; // 聲明一個事件

    public void DoSomething() {

        // 在這裡完成一些工作 ...

        if (NumberChanged != null) {    // 觸發事件

            count++;

            NumberChanged(count);

        }

// 定義事件訂閱者

public class Subscriber {

    public void OnNumberChanged(int count) {

        Console.WriteLine("Subscriber notified: count = {0}", count);

上 面代碼定義了一個NumberChangedEventHandler委托，然後我們建立了事件的釋出者Publisher和訂閱者 Subscriber。當使用委托變量時，用戶端可以直接通過委托變量觸發事件，也就是直接調用pub.NumberChanged(100)，這将會影 響到所有注冊了該委托的訂閱者。而事件的本意應該為在事件釋出者在其本身的某個行為中觸發，比如說在方法DoSomething()中滿足某個條件後觸發。通過添加event關鍵字來釋出事件，事件釋出者的封裝性會更好，事 件僅僅是供其他類型訂閱，而用戶端不能直接觸發事件（語句pub.NumberChanged(100)無法通過編譯），事件隻能在事件釋出者 Publisher類的内部觸發（比如在方法pub.DoSomething()中），換言之，就是NumberChanged(100)語句隻能在 Publisher内部被調用。

大家可以嘗試一下，将委托變量的聲明那行代碼注釋掉，然後取消下面事件聲明的注釋。此時程式是無法 編譯的，當你使用了event關鍵字之後，直接在用戶端觸發事件這種行為，也就是直接調用pub.NumberChanged(100)，是被禁止的。事 件隻能通過調用DoSomething()來觸發。這樣才是事件的本意，事件釋出者的封裝才會更好。

就好像如果我們要定義一個數字類型，我 們會使用int而不是使用object一樣，給予對象過多的能力并不見得是一件好事，應該是越合适越好。盡管直接使用委托變量通常不會有什麼問題，但它給 了用戶端不應具有的能力，而使用事件，可以限制這一能力，更精确地對類型進行封裝。

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

盡 管并非必需，但是我們發現很多的委托定義傳回值都為void，為什麼呢？這是因為委托變量可以供多個訂閱者注冊，如果定義了傳回值，那麼多個訂閱者的方法 都會向釋出者傳回數值，結果就是後面一個傳回的方法值将前面的傳回值覆寫掉了，是以，實際上隻能獲得最後一個方法調用的傳回值。可以運作下面的代碼測試一 下。除此以外，釋出者和訂閱者是松耦合的，釋出者根本不關心誰訂閱了它的事件、為什麼要訂閱，更别說訂閱者的傳回值了，是以傳回訂閱者的方法傳回值大多數 情況下根本沒有必要。

        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();          // 觸發事件

public delegate string GeneralEventHandler();

    public event GeneralEventHandler NumberChanged; // 聲明一個事件

            string rtn = NumberChanged();

            Console.WriteLine(rtn);     // 列印傳回的字元串，輸出為Subscriber3

public class Subscriber1 { 

    public string OnNumberChanged() {

        return "Subscriber1";

public class Subscriber2 { /* 略，與上類似，傳回Subscriber2*/ }

public class Subscriber3 { /* 略，與上類似，傳回Subscriber3*/ }

如果運作這段代碼，得到的輸出是Subscriber3，可以看到，隻得到了最後一個注冊方法的傳回值。

少數情況下，比如像上面，為了避免發生“值覆寫”的情況（更多是在異步調用方法時，後面會讨論），我們可能想限制隻允許一個用戶端注冊。此時怎麼做呢？我們可以向下面這樣，将事件聲明為private的，然後提供兩個方法來進行注冊和取消注冊：

    private event GeneralEventHandler NumberChanged;    // 聲明一個私有事件

    // 注冊事件

    public void Register(GeneralEventHandler method) {

        NumberChanged = method;

    // 取消注冊

    public void UnRegister(GeneralEventHandler method) {

        NumberChanged -= method;

        // 做某些其餘的事情

            Console.WriteLine("Return: {0}", rtn);      // 列印傳回的字元串，輸出為Subscriber3

NOTE：注意上面，在UnRegister()中，沒有進行任何判斷就使用了NumberChanged-=method語句。這是因為即使method方法沒有進行過注冊，此行語句也不會有任何問題，不會抛出異常，僅僅是不會産生任何效果而已。

注意在Register()方法中，我們使用了指派操作符“=”，而非“+=”，通過這種方式就避免了多個方法注冊。上面的代碼盡管可以完成我們的需要，但是此時大家還應該注意下面兩點：

1、 将NumberChanged聲明為委托變量還是事件都無所謂了，因為它是私有的，即便将它聲明為一個委托變量，用戶端也看不到它，也就無法通過它來觸發 事件、調用訂閱者的方法。而隻能通過Register()和UnRegister()方法來注冊和取消注冊，通過調用DoSomething()方法觸發 事件（而不是NumberChanged本身，這在前面已經讨論過了）。

2、我們還應該發現，這裡采用的、對NumberChanged委 托變量的通路模式和C#中的屬性是多麼類似啊？大家知道，在C#中通常一個屬性對應一個類型成員，而在類型的外部對成員的操作全部通過屬性來完成。盡管這 裡對委托變量的處理是類似的效果，但卻使用了兩個方法來進行模拟，有沒有辦法像使用屬性一樣來完成上面的例子呢？答案是有的，C#中提供了一種叫事件通路 器（Event Accessor）的東西，它用來封裝委托變量。如下面例子所示：

        pub.NumberChanged -= sub1.OnNumberChanged;  // 不會有任何反應

        pub.NumberChanged += sub2.OnNumberChanged;  // 注冊了sub2

        pub.NumberChanged += sub1.OnNumberChanged;  // sub1将sub2的覆寫掉了

    // 聲明一個委托變量

    private GeneralEventHandler numberChanged;

    // 事件通路器的定義

    public event GeneralEventHandler NumberChanged {

        add {

            numberChanged = value;

        remove {

            numberChanged -= value;

        // 做某些其他的事情

        if (numberChanged != null) {    // 通過委托變量觸發事件

            string rtn = numberChanged();

            Console.WriteLine("Return: {0}", rtn);      // 列印傳回的字元串

public class Subscriber1 {

        Console.WriteLine("Subscriber1 Invoked!");

public class Subscriber2 {/* 與上類同，略 */}

public class Subscriber3 {/* 與上類同，略 */}

上 面代碼中類似屬性的public event GeneralEventHandler NumberChanged {add{...}remove{...}}語句便是事件通路器。使用了事件通路器以後，在DoSomething方法中便隻能通過 numberChanged委托變量來觸發事件，而不能NumberChanged事件通路器（注意它們的大小寫不同）觸發，它隻用于注冊和取消注冊。下 面是代碼輸出：

Subscriber1 Invoked!

Return: Subscriber1

現 在假設我們想要獲得多個訂閱者的傳回值，以List<string>的形式傳回，該如何做呢？我們應該記得委托定義在編譯時會生成一個繼承自 MulticastDelegate的類，而這個MulticastDelegate又繼承自Delegate，在Delegate内部，維護了一個委托 連結清單，連結清單上的每一個元素，為一個隻包含一個目标方法的委托對象。而通過Delegate基類的GetInvocationList()靜态方法，可以獲 得這個委托連結清單。随後我們周遊這個連結清單，通過連結清單中的每個委托對象來調用方法，這樣就可以分别獲得每個方法的傳回值：

class Program4 {

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

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

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

        List<string> list = pub.DoSomething();  //調用方法，在方法内觸發事件

        foreach (string str in list) {

            Console.WriteLine(str);

        }          

public delegate string DemoEventHandler(int num);

    public event DemoEventHandler NumberChanged;    // 聲明一個事件

    public List<string> DoSomething() {

        // 做某些其他的事

        List<string> strList = new List<string>();

        if (NumberChanged == null) return strList;

        // 獲得委托數組

        Delegate[] delArray = NumberChanged.GetInvocationList();

        foreach (Delegate del in delArray) {

            // 進行一個向下轉換

            DemoEventHandler method = (DemoEventHandler)del;

            strList.Add(method(100));       // 調用方法并擷取傳回值

        return strList;

    public string OnNumberChanged(int num) {

        Console.WriteLine("Subscriber1 invoked, number:{0}", num);

        return "[Subscriber1 returned]";

public class Subscriber3 {與上面類同，略}

如果運作上面的代碼，可以得到這樣的輸出：

Subscriber1 invoked, number:100

Subscriber2 invoked, number:100

Subscriber3 invoked, number:100

[Subscriber1 returned]

[Subscriber2 returned]

[Subscriber3 returned]

可 見我們獲得了三個方法的傳回值。而我們前面說過，很多情況下委托的定義都不包含傳回值，是以上面介紹的方法似乎沒有什麼實際意義。其實通過這種方式來觸發 事件最常見的情況應該是在異常進行中，因為很有可能在觸發事件時，訂閱者的方法會抛出異常，而這一異常會直接影響到釋出者，使得釋出者程式中止，而後面訂 閱者的方法将不會被執行。是以我們需要加上異常處理，考慮下面一段程式：

class Program5 {

        Publisher pub = new Publisher();

public class Publisher {

    public event EventHandler MyEvent;

        if (MyEvent != null) {

            try {

                MyEvent(this, EventArgs.Empty);

            } catch (Exception e) {

                Console.WriteLine("Exception: {0}", e.Message);

            }

    public void OnEvent(object sender, EventArgs e) {

public class Subscriber2 {

        throw new Exception("Subscriber2 Failed");

public class Subscriber3 {/* 與Subsciber1類同，略*/}

注意到我們在Subscriber2中抛出了異常，同時我們在Publisher中使用了try/catch語句來處理異常。運作上面的代碼，我們得到的結果是：

Exception: Subscriber2 Failed

可以看到，盡管我們捕獲了異常，使得程式沒有異常結束，但是卻影響到了後面的訂閱者，因為Subscriber3也訂閱了事件，但是卻沒有收到事件通知（它的方法沒有被調用）。此時，我們可以采用上面的辦法，先獲得委托連結清單，然後在周遊連結清單的循環中處理異常，我們隻需要修改一下DoSomething方法就可以了：

public void DoSomething() {

    if (MyEvent != null) {

        Delegate[] delArray = MyEvent.GetInvocationList();

            EventHandler method = (EventHandler)del;    // 強制轉換為具體的委托類型

                method(this, EventArgs.Empty);

注 意到Delegate是EventHandler的基類，是以為了觸發事件，先要進行一個向下的強制轉換，之後才能在其上觸發事件，調用所有注冊對象的方 法。除了使用這種方式以外，還有一種更靈活方式可以調用方法，它是定義在Delegate基類中的DynamicInvoke()方法：

public object DynamicInvoke(params object[] args);

這可能是調用委托最通用的方法了，适用于所有類型的委托。它接受的參數為object[]，也就是說它可以将任意數量的任意類型作為參數，并傳回單個object對象。上面的DoSomething()方法也可以改寫成下面這種通用形式：

    // 做某些其他的事情

        foreach (Delegate del in delArray) {                   

                // 使用DynamicInvoke方法觸發事件

                del.DynamicInvoke(this, EventArgs.Empty);  

注 意現在在DoSomething()方法中，我們取消了向具體委托類型的向下轉換，現在沒有了任何的基于特定委托類型的代碼，而 DynamicInvoke又可以接受任何類型的參數，且傳回一個object對象。是以我們完全可以将DoSomething()方法抽象出來，使它成 為一個公共方法，然後供其他類來調用，我們将這個方法聲明為靜态的，然後定義在Program類中：

// 觸發某個事件，以清單形式傳回所有方法的傳回值

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) {

                object obj = method.DynamicInvoke(args);

                if (obj != null)

                    objList.Add(obj);

            } catch { }

    return objList.ToArray();

随後，我們在DoSomething()中隻要簡單的調用一下這個方法就可以了：

    Program5.FireEvent(MyEvent, this, EventArgs.Empty);

注 意FireEvent()方法還可以傳回一個object[]數組，這個數組包括了所有訂閱者方法的傳回值。而在上面的例子中，我沒有示範如何擷取并使用 這個數組，為了節省篇幅，這裡也不再贅述了，在本文附帶的代碼中，有關于這部分的示範，有興趣的朋友可以下載下傳下來看看。

訂 閱者除了可以通過異常的方式來影響釋出者以外，還可以通過另一種方式：逾時。一般說逾時，指的是方法的執行超過某個指定的時間，而這裡我将含義擴充了一 下，凡是方法執行的時間比較長，我就認為它逾時了，這個“比較長”是一個比較模糊的概念，2秒、3秒、5秒都可以視為逾時。逾時和異常的差別就是逾時并不 會影響事件的正确觸發和程式的正常運作，卻會導緻事件觸發後需要很長才能夠結束。在依次執行訂閱者的方法這段期間内，用戶端程式會被中斷，什麼也不能做。 因為當執行訂閱者方法時（通過委托，相當于依次調用所有注冊了的方法），目前線程會轉去執行方法中的代碼，調用方法的用戶端會被中斷，隻有當方法執行完畢 并傳回時，控制權才會回到用戶端，進而繼續執行下面的代碼。我們來看一下下面一個例子：

class Program6 {

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

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

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

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

        Console.WriteLine(" Control back to client!"); // 傳回控制權

    // 觸發某個事件，以清單形式傳回所有方法的傳回值

    public static object[] FireEvent(Delegate del, params object[] args) {

        // 代碼與上同，略

        Console.WriteLine("DoSomething invoked!");

        Program6.FireEvent(MyEvent, this, EventArgs.Empty); //觸發事件

        Thread.Sleep(TimeSpan.FromSeconds(3));

        Console.WriteLine("Waited for 3 seconds, subscriber1 invoked!");

        Console.WriteLine("Subscriber2 immediately Invoked!");

public class Subscriber3 {

        Thread.Sleep(TimeSpan.FromSeconds(2));

        Console.WriteLine("Waited for 2 seconds, subscriber2 invoked!");

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

DoSomething invoked!

Waited for 3 seconds, subscriber1 invoked!

Subscriber2 immediately Invoked!

Waited for 2 seconds, subscriber2 invoked!

Control back to client!

但 是這段程式在調用方法DoSomething()、列印了“DoSomething invoked”之後，觸發了事件，随後必須等訂閱者的三個方法全部執行完畢了之後，也就是大概5秒鐘的時間，才能繼續執行下面的語句，也就是列印 “Control back to client”。而我們前面說過，很多情況下，尤其是遠端調用的時候（比如說在Remoting中），釋出者和訂閱者應該是完全的松耦合，釋出者不關心誰 訂閱了它、不關心訂閱者的方法有什麼傳回值、不關心訂閱者會不會抛出異常，當然也不關心訂閱者需要多長時間才能完成訂閱的方法，它隻要在事件發生的那一瞬 間告知訂閱者事件已經發生并将相關參數傳給訂閱者就可以了。然後它就應該繼續執行它後面的動作，在本例中就是列印“Control back to client！”。而訂閱者不管失敗或是逾時都不應該影響到釋出者，但在上面的例子中，釋出者卻不得不等待訂閱者的方法執行完畢才能繼續運作。

現 在我們來看下如何解決這個問題，先回顧一下之前我在C#中的委托和事件一文中提到的内容，我說過，委托的定義會生成繼承自 MulticastDelegate的完整的類，其中包含Invoke()、BeginInvoke()和EndInvoke()方法。當我們直接調用委 托時，實際上是調用了Invoke()方法，它會中斷調用它的用戶端，然後在用戶端線程上執行所有訂閱者的方法（用戶端無法繼續執行後面代碼），最後将控 制權傳回用戶端。注意到BeginInvoke()、EndInvoke()方法，在.Net中，異步執行的方法通常都會配對出現，并且以Begin和 End作為方法的開頭（最常見的可能就是Stream類的BeginRead()和EndRead()方法了）。它們用于方法的異步執行，即是在調用 BeginInvoke()之後，用戶端從線程池中抓取一個閑置線程，然後交由這個線程去執行訂閱者的方法，而用戶端線程則可以繼續執行下面的代碼。

BeginInvoke() 接受“動态”的參數個數和類型，為什麼說“動态”的呢？因為它的參數是在編譯時根據委托的定義動态生成的，其中前面參數的個數和類型與委托定義中接受的參 數個數和類型相同，最後兩個參數分别是AsyncCallback和Object類型，對于它們更具體的内容，可以參見下一節委托和方法的異步調用部分。 現在，我們僅需要對這兩個參數傳入null就可以了。另外還需要注意幾點：

在委托類型上調用BeginInvoke()時，此委 托對象隻能包含一個目标方法，是以對于多個訂閱者注冊的情況，必須使用GetInvocationList()獲得所有委托對象，然後周遊它們，分别在其 上調用BeginInvoke()方法。如果直接在委托上調用BeginInvoke()，會抛出異常，提示“委托隻能包含一個目标方法”。

如 果訂閱者的方法抛出異常，.NET會捕捉到它，但是隻有在調用EndInvoke()的時候，才會将異常重新抛出。而在本例中，我們不使用 EndInvoke()（因為我們不關心訂閱者的執行情況），是以我們無需處理異常，因為即使抛出異常，也是在另一個線程上，不會影響到用戶端線程（客戶 端甚至不知道訂閱者發生了異常，這有時是好事有時是壞事）。

BeginInvoke()方法屬于委托定義所生成的類，它既不屬于MulticastDelegate也不屬于Delegate基類，是以無法繼續使用可重用的FireEvent()方法，我們需要進行一個向下轉換，來擷取到實際的委托類型。

現在我們修改一下上面的程式，使用異步調用來解決訂閱者方法執行逾時的情況：

        Console.WriteLine("Control back to client! "); // 傳回控制權

        Console.WriteLine("Press any thing to exit...");

        Console.ReadKey();      // 暫停客戶程式，提供時間供訂閱者完成方法

    public void DoSomething() {        

            Delegate[] delArray = MyEvent.GetInvocationList();

            foreach (Delegate del in delArray) {

                EventHandler method = (EventHandler)del;

                method.BeginInvoke(null, EventArgs.Empty, null, null);

        Thread.Sleep(TimeSpan.FromSeconds(3));      // 模拟耗時三秒才能完成方法

        throw new Exception("Subsciber2 Failed");   // 即使抛出異常也不會影響到用戶端

        //Console.WriteLine("Subscriber2 immediately Invoked!");

        Thread.Sleep(TimeSpan.FromSeconds(2));  // 模拟耗時兩秒才能完成方法

        Console.WriteLine("Waited for 2 seconds, subscriber3 invoked!");

運作上面的代碼，會得到下面的輸出：

Press any thing to exit...

Waited for 2 seconds, subscriber3 invoked!

需要注意代碼輸出中的幾個變化：

我 們需要在用戶端程式中調用Console.ReadKey()方法來暫停用戶端，以提供足夠的時間來讓異步方法去執行完代碼，不然的話用戶端的程式到此處 便會運作結束，程式會退出，不會看到任何訂閱者方法的輸出，因為它們根本沒來得及執行完畢。原因是這樣的：用戶端所在的線程我們通常稱為主線程，而執行訂 閱者方法的線程來自線程池，屬于背景線程(Background Thread），當主線程結束時，不論背景線程有沒有結束，都會退出程式。（當然還有一種前台線程(Foreground Thread)，主線程結束後必須等前台線程也結束後程式才會退出，關于線程的讨論可以開辟另一個龐大的主題，這裡就不讨論了）。

在打 印完“Press any thing to exit...”之後，兩個訂閱者的方法會以2秒、1秒的間隔顯示出來，且盡管我們先注冊了subscirber1，但是卻先執行了 subscriber3，這是因為執行它需要的時間更短。除此以外，注意到這兩個方法是并行執行的，是以執行它們的總時間是最長的方法所需要的時間，也就 是3秒，而不是他們的累加5秒。

如同前面所提到的，盡管subscriber2抛出了異常，我們也沒有針對異常進行處理，但是客戶程式并沒有察覺到，程式也沒有是以而中斷。

通 常情況下，如果需要異步執行一個耗時的操作，我們會新起一個線程，然後讓這個線程去執行代碼。但是對于每一個異步調用都通過建立線程來進行操作顯然會對性 能産生一定的影響，同時操作也相對繁瑣一些。.Net中可以通過委托進行方法的異步調用，就是說用戶端在異步調用方法時，本身并不會因為方法的調用而中 斷，而是從線程池中抓取一個線程去執行該方法，自身線程（主線程）在完成抓取線程這一過程之後，繼續執行下面的代碼，這樣就實作了代碼的并行執行。使用線 程池的好處就是避免了頻繁進行異步調用時建立、銷毀線程的開銷。

如同上面所示，當我們在委托對象上調用BeginInvoke()時，便進行了一個異步的方法調用。上面的例子中是在事件的釋出和訂閱這一過程中使用了異步調用，而在事件釋出者和訂閱者之間往往是松耦合的，釋出者通常不需要獲得訂閱者方法執行的情況；而當使用異步調用時，更多情況下是為了提升系統的性能，而并非專用于事件的釋出和訂閱這一程式設計模型。而在這種情況下使用異步程式設計時，就需要進行更多的控制，比如當異步執行方法的方法結束時通知用戶端、傳回異步執行方法的傳回值等。本節就對BeginInvoke()方法、EndInvoke()方法和其相關的IAysncResult做一個簡單的介紹。

NOTE：注意此處我已經不再使用釋出者、訂閱者這些術語，因為我們不再是讨論上面的事件模型，而是讨論在用戶端程式中異步地調用方法，這裡有一個思維的轉變。

我們看這樣一段代碼，它示範了不使用異步調用的通常情況：

class Program7 {

        Console.WriteLine("Client application started! ");

        Thread.CurrentThread.Name = "Main Thread";

        Calculator cal = new Calculator();

        int result = cal.Add(2, 5);

        Console.WriteLine("Result: {0} ", result);

        // 做某些其它的事情，模拟需要執行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(" Press 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!");          

        // 執行某些事情，模拟需要執行2秒鐘

        for (int i = 1; i <= 2; i++) {

            Console.WriteLine("{0}: Add executed {1} second(s).",

        Console.WriteLine("Method complete!");

        return x + y;

上面代碼有幾個關于對于線程的操作，如果不了解可以看一下下面的說明，如果你已經了解可以直接跳過：

Thread.Sleep()， 它會讓執行目前代碼的線程暫停一段時間（如果你對線程的概念比較陌生，可以了解為使程式的執行暫停一段時間），以毫秒為機關，比如 Thread.Sleep(1000)，将會使線程暫停1秒鐘。在上面我使用了它的重載方法，個人覺得使用 TimeSpan.FromSeconds(1)，可讀性更好一些。

Thread.CurrentThread.Name，通過這個屬性可以設定、擷取執行目前代碼的線程的名稱，值得注意的是這個屬性隻可以設定一次，如果設定兩次，會抛出異常。

Thread.IsThreadPoolThread，可以判斷執行目前代碼的線程是否為線程池中的線程。

通 過這幾個方法和屬性，有助于我們更好地調試異步調用方法。上面代碼中除了加入了一些對線程的操作以外再沒有什麼特别之處。我們建了一個 Calculator類，它隻有一個Add方法，我們模拟了這個方法需要執行2秒鐘時間，并且每隔一秒進行一次輸出。而在用戶端程式中，我們使用 result變量儲存了方法的傳回值并進行了列印。随後，我們再次模拟了用戶端程式接下來的操作需要執行2秒鐘時間。運作這段程式，會産生下面的輸出：

Client application started!

Method invoked!

Main Thread: Add executed 1 second(s).

Main Thread: Add executed 2 second(s).

Method complete!

Result: 7

Main Thread: Client executed 1 second(s).

Main Thread: Client executed 2 second(s).

Main Thread: Client executed 3 second(s).

Press any key to exit...

如果你确實執行了這段代碼，會看到這些輸出并不是一瞬間輸出的，而是執行了大概5秒鐘的時間，因為線程是串行執行的，是以在執行完Add()方法之後才會繼續用戶端剩下的代碼。

接 下來我們定義一個AddDelegate委托，并使用BeginInvoke()方法來異步地調用它。在上面已經介紹過，BeginInvoke()除了 最後兩個參數為AsyncCallback類型和Object類型以外，前面的參數類型和個數與委托定義相同。另外BeginInvoke()方法傳回了 一個實作了IAsyncResult接口的對象（實際上就是一個AsyncResult類型執行個體，注意這裡IAsyncResult和 AysncResult是不同的，它們均包含在.Net Framework中）。

AsyncResult的用途有這麼幾個：傳遞參數，它 包含了對調用了BeginInvoke()的委托的引用；它還包含了BeginInvoke()的最後一個Object類型的參數；它可以鑒别出是哪個方 法的哪一次調用，因為通過同一個委托變量可以對同一個方法調用多次。

EndInvoke()方法接受IAsyncResult類型的對象 （以及ref和out類型參數，這裡不讨論了，對它們的處理和傳回值類似），是以在調用BeginInvoke()之後，我們需要保留 IAsyncResult，以便在調用EndInvoke()時進行傳遞。這裡最重要的就是EndInvoke()方法的傳回值，它就是方法的傳回值。除 此以外，當用戶端調用EndInvoke()時，如果異步調用的方法沒有執行完畢，則會中斷目前線程而去等待該方法，隻有當異步方法執行完畢後才會繼續執 行後面的代碼。是以在調用完BeginInvoke()後立即執行EndInvoke()是沒有任何意義的。我們通常在盡可能早的時候調用 BeginInvoke()，然後在需要方法的傳回值的時候再去調用EndInvoke()，或者是根據情況在晚些時候調用。說了這麼多，我們現在看一下 使用異步調用改寫後上面的代碼吧：

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

class Program8 {   

        AddDelegate del = new AddDelegate(cal.Add);

        IAsyncResult asyncResult = del.BeginInvoke(2,5,null,null);  // 異步調用方法

                Thread.CurrentThread.Name, i);

        int rtn = del.EndInvoke(asyncResult);

        Console.WriteLine("Result: {0} ", rtn);

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

此時的輸出為：

Pool Thread: Add executed 1 second(s).

Pool Thread: Add executed 2 second(s).

現 在執行完這段代碼隻需要3秒鐘時間，兩個for循環所産生的輸出交替進行，這也說明了這兩段代碼并行執行的情況。可以看到Add()方法是由線程池中的線 程在執行，因為Thread.CurrentThread.IsThreadPoolThread傳回了True，同時我們對該線程命名為了Pool Thread。另外我們可以看到通過EndInvoke()方法得到了傳回值。

有時候，我們可能會将獲得傳回值的操作放到另一段代碼或者客 戶端去執行，而不是向上面那樣直接寫在BeginInvoke()的後面。比如說我們在Program中建立一個方法GetReturn()，此時可以通 過AsyncResult的AsyncDelegate獲得del委托對象，然後再在其上調用EndInvoke()方法，這也說明了 AsyncResult可以唯一的擷取到與它相關的調用了的方法（或者也可以了解成委托對象）。是以上面擷取傳回值的代碼也可以改寫成這樣：

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);語句改為int rtn = GetReturn(asyncResult);。注意上面IAsyncResult要轉換為實際的類型AsyncResult才能通路 AsyncDelegate屬性，因為它沒有包含在IAsyncResult接口的定義中。

BeginInvoke的另外兩個參數分别是AsyncCallback和Object類型，其中AsyncCallback是一個委托類型，它用于方法的回調，即是說當異步方法執行完畢時自動進行調用的方法。它的定義為：

public delegate void AsyncCallback(IAsyncResult ar);

Object類型用于傳遞任何你想要的數值，它可以通過IAsyncResult的AsyncState屬性獲得。下面我們将擷取方法傳回值、列印傳回值的操作放到了OnAddComplete()回調方法中：

class Program9 {

        string data = "Any data you want to pass.";

        AsyncCallback callBack = new AsyncCallback(OnAddComplete);

        del.BeginInvoke(2, 5, callBack, data);      // 異步調用方法

    static void OnAddComplete(IAsyncResult asyncResult) {

        AsyncResult result = (AsyncResult)asyncResult;

        AddDelegate del = (AddDelegate)result.AsyncDelegate;

        string data = (string)asyncResult.AsyncState;

        Console.WriteLine("{0}: Result, {1}; Data: {2} ",

            Thread.CurrentThread.Name, rtn, data);

它産生的輸出為：

Pool Thread: Result, 7; Data: Any data you want to pass.

這 裡有幾個值得注意的地方：1、我們在調用BeginInvoke()後不再需要儲存IAysncResult了，因為AysncCallback委托将該 對象定義在了回調方法的參數清單中；2、我們在OnAddComplete()方法中獲得了調用BeginInvoke()時最後一個參數傳遞的值，字元 串“Any data you want to pass”；3、執行回調方法的線程并非用戶端線程Main Thread，而是來自線程池中的線程Pool Thread。另外如前面所說，在調用EndInvoke()時有可能會抛出異常，是以在應該将它放到try/catch塊中，這裡我就不再示範了。

感謝閱讀，希望這篇文章能給你帶來幫助。