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

iDotNetSpace發表於2008-09-23

引言

如果你看過了 C#中的委託和事件一文，我想你對委託和事件已經有了一個基本的認識。但那些遠不是委託和事件的全部內容，還有很多的地方沒有涉及。本文將討論委託和事件一些更為細節的問題，包括一些大家常問到的問題，以及事件訪問器、異常處理、超時處理和非同步方法呼叫等內容。

為什麼要使用事件而不是委託變數？

在 C#中的委託和事件中，我提出了兩個為什麼在型別中使用事件向外部提供方法註冊，而不是直接使用委託變數的原因。主要是從封裝性和易用性上去考慮，但是還漏掉了一點，事件應該由事件釋出者觸發，而不應該由客戶端（客戶程式）來觸發。這句話是什麼意思呢？請看下面的範例：

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？

儘管並非必需，但是我們發現很多的委託定義返回值都為void，為什麼呢？這是因為委託變數可以供多個訂閱者註冊，如果定義了返回值，那麼多個訂閱者的方法都會向釋出者返回數值，結果就是後面一個返回的方法值將前面的返回值覆蓋掉了，因此，實際上只能獲得最後一個方法呼叫的返回值。可以執行下面的程式碼測試一下。除此以外，釋出者和訂閱者是鬆耦合的，釋出者根本不關心誰訂閱了它的事件、為什麼要訂閱，更別說訂閱者的返回值了，所以返回訂閱者的方法返回值大多數情況下根本沒有必要。

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

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

// 定義事件釋出者
public class Publishser {
    public event GeneralEventHandler NumberChanged; // 宣告一個事件
    public void DoSomething() {
        if (NumberChanged != null) {    // 觸發事件
            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的，然後提供兩個方法來進行註冊和取消註冊：

// 定義事件釋出者
public class Publishser {
    private event GeneralEventHandler NumberChanged;    // 宣告一個私有事件
    // 註冊事件
    public void Register(GeneralEventHandler method) {
        NumberChanged = method;
    }
    // 取消註冊
    public void UnRegister(GeneralEventHandler method) {
        NumberChanged -= method;
    }

    public void DoSomething() {
        // 做某些其餘的事情
        if (NumberChanged != null) {    // 觸發事件
            string rtn = NumberChanged();
            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）的東西，它用來封裝委託變數。如下面例子所示：

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

        pub.NumberChanged -= sub1.OnNumberChanged; // 不會有任何反應
        pub.NumberChanged += sub2.OnNumberChanged; // 註冊了sub2
        pub.NumberChanged += sub1.OnNumberChanged; // sub1將sub2的覆蓋掉了

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

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

// 定義事件釋出者
public class Publishser {
    // 宣告一個委託變數
    private GeneralEventHandler numberChanged;
    // 事件訪問器的定義
    public event GeneralEventHandler NumberChanged {
        add {
            numberChanged = value;
        }
        remove {
            numberChanged -= value;
        }
    }

    public void DoSomething() {
        // 做某些其他的事情
        if (numberChanged != null) {    // 通過委託變數觸發事件
            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{...}}語句便是事件訪問器。使用了事件訪問器以後，在DoSomething方法中便只能通過numberChanged委託變數來觸發事件，而不能NumberChanged事件訪問器（注意它們的大小寫不同）觸發，它只用於註冊和取消註冊。下面是程式碼輸出：

Subscriber1 Invoked!
Return: Subscriber1

獲得多個返回值與異常處理

現在假設我們想要獲得多個訂閱者的返回值，以List的形式返回，該如何做呢？我們應該記得委託定義在編譯時會生成一個繼承自MulticastDelegate的類，而這個MulticastDelegate又繼承自Delegate，在Delegate內部，維護了一個委託連結串列，連結串列上的每一個元素，為一個只包含一個目標方法的委託物件。而通過Delegate基類的GetInvocationList()靜態方法，可以獲得這個委託連結串列。隨後我們遍歷這個連結串列，通過連結串列中的每個委託物件來呼叫方法，這樣就可以分別獲得每個方法的返回值：

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(); //呼叫方法，在方法內觸發事件

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

public delegate string DemoEventHandler(int num);

// 定義事件釋出者
public class Publishser {
    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 class Subscriber1 {
    public string OnNumberChanged(int num) {
        Console.WriteLine("Subscriber1 invoked, number:{0}", num);
        return "[Subscriber1 returned]";
    }
}
public class Subscriber3 {與上面類同，略}
public class Subscriber3 {與上面類同，略}

如果執行上面的程式碼，可以得到這樣的輸出：

Subscriber1 invoked, number:100
Subscriber2 invoked, number:100
Subscriber3 invoked, number:100
[Subscriber1 returned]
[Subscriber2 returned]
[Subscriber3 returned]

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

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類同，略*/}

注意到我們在Subscriber2中丟擲了異常，同時我們在Publisher中使用了try/catch語句來處理異常。執行上面的程式碼，我們得到的結果是：

Subscriber1 Invoked!
Exception: Subscriber2 Failed

可以看到，儘管我們捕獲了異常，使得程式沒有異常結束，但是卻影響到了後面的訂閱者，因為Subscriber3也訂閱了事件，但是卻沒有收到事件通知（它的方法沒有被呼叫）。此時，我們可以採用上面的辦法，先獲得委託連結串列，然後在遍歷連結串列的迴圈中處理異常，我們只需要修改一下DoSomething方法就可以了：

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

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

public object DynamicInvoke(params object[] args);

這可能是呼叫委託最通用的方法了，適用於所有型別的委託。它接受的引數為object[]，也就是說它可以將任意數量的任意型別作為引數，並返回單個object物件。上面的DoSomething()方法也可以改寫成下面這種通用形式：

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

注意現在在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) {
            try {
                // 使用DynamicInvoke方法觸發事件
                object bj = method.DynamicInvoke(args);
                if (obj != null)
                    objList.Add(obj);
            } catch { }
        }
    }
    return objList.ToArray();
}

隨後，我們在DoSomething()中只要簡單的呼叫一下這個方法就可以了：

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

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

委託中訂閱者方法超時的處理

訂閱者除了可以通過異常的方式來影響釋出者以外，還可以通過另一種方式：超時。一般說超時，指的是方法的執行超過某個指定的時間，而這裡我將含義擴充套件了一下，凡是方法執行的時間比較長，我就認為它超時了，這個“比較長”是一個比較模糊的概念，2秒、3秒、5秒都可以視為超時。超時和異常的區別就是超時並不會影響事件的正確觸發和程式的正常執行，卻會導致事件觸發後需要很長才能夠結束。在依次執行訂閱者的方法這段期間內，客戶端程式會被中斷，什麼也不能做。因為當執行訂閱者方法時（通過委託，相當於依次呼叫所有註冊了的方法），當前執行緒會轉去執行方法中的程式碼，呼叫方法的客戶端會被中斷，只有當方法執行完畢並返回時，控制權才會回到客戶端，從而繼續執行下面的程式碼。我們來看一下下面一個例子：

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

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

    // 觸發某個事件，以列表形式返回所有方法的返回值
    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); //觸發事件
    }
}

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()靜態方法模擬了方法超時的情況。其中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()方法，我們需要進行一個向下轉換，來獲取到實際的委託型別。

現在我們修改一下上面的程式，使用非同步呼叫來解決訂閱者方法執行超時的情況：

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

        Console.WriteLine("Control back to client! "); // 返回控制權
        Console.WriteLine("Press any thing to exit...");
        Console.ReadKey();      // 暫停客戶程式，提供時間供訂閱者完成方法
    }
}

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));      // 模擬耗時三秒才能完成方法
        Console.WriteLine("Waited for 3 seconds, subscriber1 invoked!");
    }
}

public class Subscriber2 {
    public void OnEvent(object sender, EventArgs e) {
        throw new Exception("Subsciber2 Failed");   // 即使丟擲異常也不會影響到客戶端
        //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, subscriber3 invoked!");
    }
}

執行上面的程式碼，會得到下面的輸出：

DoSomething invoked!
Control back to client!

Press any thing to exit...

Waited for 2 seconds, subscriber3 invoked!
Waited for 3 seconds, subscriber1 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 {
    static void Main(string[] args) {

        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++) {
            Thread.Sleep(TimeSpan.FromSeconds(i));
            Console.WriteLine("{0}: Add executed {1} second(s).",
                Thread.CurrentThread.Name, i);
        }
        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 {

    static void Main(string[] args) {

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

        Calculator cal = new Calculator();
        AddDelegate del = new AddDelegate(cal.Add);
        IAsyncResult asyncResult = del.BeginInvoke(2,5,null,null); // 非同步呼叫方法

        // 做某些其它的事情，模擬需要執行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} ", rtn);

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

public

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/12639172/viewspace-462660/，如需轉載，請註明出處，否則將追究法律責任。

C# 中的委託和事件
2013-02-26
C#事件
C# 事件委託
2017-06-05
C#事件
C# 委託事件
2016-02-24
C#事件
C#中的委託和事件－拋磚引玉
2009-10-12
C#事件
C#：委託和自定義事件
2014-04-07
C#事件
徹底搞清楚c#中的委託和事件
2019-07-17
C#事件
C#委託與事件
2020-10-12
C#事件
C# 事件 vs 委託
2009-12-30
C#事件
詳解C#委託和事件（一）
2018-09-14
C#事件
詳解C#委託和事件（二）
2018-10-17
C#事件
C# 之委託與事件
2016-08-24
C#事件
C# 委託，事件和Lambda表示式（轉）
2010-09-17
C#事件
C#中的委託
2024-04-05
C#
事件模型和事件委託
2020-10-06
事件模型
C# 自定義事件和委託（精彩轉載）
2009-12-13
C#事件
JS事件流和事件委託
2018-12-17
JS事件
javascript中的事件委託（代理）
2017-09-05
JavaScript事件
jquery-中的事件委託
2018-01-06
jQuery事件
js 事件的冒泡和委託
2015-07-28
JS事件
C# 委託原理刨析，外加和事件對比
2023-02-17
C#事件
事件委託
2018-08-01
事件
委託、事件--委託例項篇
2009-07-06
事件
委託、Lambda表示式、事件系列01,委託是什麼,委託的基本用法,委託的Method和Target屬性
2014-10-01
事件
C# 委託(delegate)、泛型委託和Lambda表示式
2019-07-31
C#泛型
委託與事件-委託詳解（一）
2019-07-19
事件
C#中的委託,匿名方法和Lambda表示式
2010-10-08
C#
C#規範整理·泛型委託事件
2019-06-18
C#泛型事件
c#委託
2018-11-18
C#
jQuery 事件委託
2017-02-10
jQuery事件
C#自學（一）委託(delegate)、委託泛型、多播委託
2014-07-30
C#泛型
你可能不知道的陷阱：C#委託和事件的困惑
2015-10-22
C#事件
jquery中如何使用事件委託?
2020-12-13
jQuery事件
C#的委託案例
2020-12-17
C#
.NET委託，事件和Lambda表示式
2020-09-12
事件
ASP.NET談委託和事件
2008-09-16
ASP.NET事件
.net的委託和事件的直接理解 (轉)
2007-08-17
事件
C# 從1到Core--委託與事件
2020-06-30
C#事件
C#程式設計之委託與事件(一)
2009-05-15
C#程式設計事件