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

来源:https://www.cnblogs.com/ljdong7/archive/2019/12/09/12009551.html
-Advertisement-
Play Games

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


引言

如果你看過了 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<string>的形式返回，該如何做呢？我們應該記得委托定義在編譯時會生成一個繼承自 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 obj = 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!

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

  1. 我 們需要在客戶端程式中調用Console.ReadKey()方法來暫停客戶端，以提供足夠的時間來讓非同步方法去執行完代碼，不然的話客戶端的程式到此處 便會運行結束，程式會退出，不會看到任何訂閱者方法的輸出，因為它們根本沒來得及執行完畢。原因是這樣的：客戶端所在的線程我們通常稱為主線程，而執行訂 閱者方法的線程來自線程池，屬於後臺線程(Background Thread），當主線程結束時，不論後臺線程有沒有結束，都會退出程式。（當然還有一種前臺線程(Foreground Thread)，主線程結束後必須等前臺線程也結束後程式才會退出，關於線程的討論可以開闢另一個龐大的主題，這裡就不討論了）。
  2. 在打 印完“Press any thing to exit...”之後，兩個訂閱者的方法會以2秒、1秒的間隔顯示出來，且儘管我們先註冊了subscirber1，但是卻先執行了 subscriber3，這是因為執行它需要的時間更短。除此以外，註意到這兩個方法是並行執行的，所以執行它們的總時間是最長的方法所需要的時間，也就 是3秒，而不是他們的累加5秒。
  3. 如同前面所提到的，儘管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

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • [譯]C# 7系列，Part 4: Discards 棄元
    原文：https://blogs.msdn.microsoft.com/mazhou/2017/06/27/c-7-series-part-4-discards/ 有時我們想要忽略一個方法返回的值，特別是那些out參數，一個典型的例子是檢查一個字元串是否可以解析成另一種類型： 這裡我們要忽略pars ...
  • C#中怎樣獲取預設配置文件App.config中配置的鍵值對內容
    場景 在新建一個程式後，項目中會有一個預設配置文件App.config 一般會將一些配置文件信息，比如連接資料庫的字元串等信息存在此配置文件中。 怎樣在代碼中獲取自己配置的鍵值對信息。 註： 博客主頁： https://blog.csdn.net/badao_liumang_qizhi 關註公眾號 ...
  • 關於ConfigurationSection自定義config的簡單使用
    1.1、自定義config結構（參考對應顏色標註）,放到configuration根節點下： <test> <testInfos> <testInfo aa="aaKeyStr1" bb="111111" /> <testInfo aa="aaKeyStr2" bb="222222" /> </te ...
  • C#中提示：當前上下文中不存在名稱“ConfigurationManager”
    場景 想要在程式中獲取App.config中設置的內容。 想要通過 ConfigurationManager.AppSettings[key]; 來進行獲取，已經添加 using System.Configuration; 但是還是提示“當前上下文中不存在名稱ConfigurationManager ...
  • C#語法--委托，架構的血液
    委托的定義 什麼是委托？ 委托實際上是一種類型，是一種引用類型。 微軟用delegate關鍵字來聲明委托，delegate與int，string，double等關鍵字一樣。都是聲明用的。 下麵先看下聲明代碼，這裡聲明瞭兩個委托。 1 2 public delegate void TestDelega ...
  • ASP.NET Core3.X 終端中間件轉換為端點路由運行
    引言 前幾天 ".NET Core3.1發佈" ,於是我把公司一個基礎通用系統升級了,同時刪除了幾個基礎模塊當然這幾個基礎模塊與.NET Core3.1無關，其中包括了支付模塊，升級完後靜文（同事）問我你把支付刪除了啊？我說是啊，沒考慮好怎麼加上(感覺目前不太好，我需要重新設計一下)。 故事從這開始 ...
  • C# read file to bytes,File.ReadAllFiles,File.Open(),BinaryReader
    using System; using System.Text; using System.IO; namespace ConsoleApplication15 { class Program { static void Main(string[] args) { string fileName =... ...
  • C# get md5,renamed file and can not change file's md5
    using System; using System.Text; using System.IO; using System.Security.Cryptography; namespace ConsoleApplication13 { class Program { static void Mai... ...
一周排行
    -Advertisement-
    Play Games
  • C#自增運算符詳解：++i與i++的區別及應用場景
    概述：在C#中，++i和i++都是自增運算符，其中++i先增加值再返回，而i++先返回值再增加。應用場景根據需求選擇，首碼適合先增後用，尾碼適合先用後增。詳細示例提供清晰的代碼演示這兩者的操作時機和實際應用。 在C#中，++i 和 i++ 都是自增運算符，但它們在操作上有細微的差異，主要體現在操作的 ...
  • Taurus.MVC 性能壓力測試（ap 壓測 和 linux 下wrk 壓測）：.NET 版本
    上次發佈了：Taurus.MVC 性能壓力測試（ap 壓測 和 linux 下wrk 壓測）：.NET Core 版本，今天計劃準備壓測一下 .NET 版本，來測試並記錄一下 Taurus.MVC 框架在 .NET 版本的性能，以便後續持續優化改進。 為了方便對比，本文章的電腦環境和測試思路，儘量和... ...
  • 一文讀懂.NET WebAPI中FromRoute、FromQuery、FromBody的關鍵角色與用法
    .NET WebAPI作為一種構建RESTful服務的強大工具，為開發者提供了便捷的方式來定義、處理HTTP請求並返迴響應。在設計API介面時，正確地接收和解析客戶端發送的數據至關重要。.NET WebAPI提供了一系列特性，如[FromRoute]、[FromQuery]和[FromBody]，用 ...
  • WPF/C#實現圖像濾鏡優化方案：打造炫目視覺體驗！
    原因：我之所以想做這個項目，是因為在之前查找關於C#/WPF相關資料時，我發現講解圖像濾鏡的資源非常稀缺。此外，我註意到許多現有的開源庫主要基於CPU進行圖像渲染。這種方式在處理大量圖像時，會導致CPU的渲染負擔過重。因此，我將在下文中介紹如何通過GPU渲染來有效實現圖像的各種濾鏡效果。 生成的效果 ...
  • Bogus 實戰：使用 Bogus 和 EFCore 生成模擬數據和種子數據【完整教程】
    引言 上一章我們介紹了在xUnit單元測試中用xUnit.DependencyInject來使用依賴註入，上一章我們的Sample.Repository倉儲層有一個批量註入的介面沒有做單元測試，今天用這個示例來演示一下如何用Bogus創建模擬數據 ，和 EFCore 的種子數據生成 Bogus 的優 ...
  • WPF隨筆收錄-實時繪製心率曲線
    一、前言 在自己的項目中，涉及到實時心率曲線的繪製，項目上的曲線繪製，一般很難找到能直接用的第三方庫，而且有些還是定製化的功能，所以還是自己繪製比較方便。很多人一聽到自己畫就害怕，感覺很難，今天就分享一個完整的實時心率數據繪製心率曲線圖的例子；之前的博客也分享給DrawingVisual繪製曲線的方 ...
  • wpf程式修改啟動入口註意事項
    如果你在自定義的 Main 方法中直接使用 App 類並啟動應用程式，但發現 App.xaml 中定義的資源沒有被正確載入，那麼問題可能在於如何正確配置 App.xaml 與你的 App 類的交互。 確保 App.xaml 文件中的 x:Class 屬性正確指向你的 App 類。這樣，當你創建 Ap ...
  • 記一次 .NET某爐膛鍋爐檢測系統 崩潰分析
    一：背景 1. 講故事 上個月有個朋友在微信上找到我，說他們的軟體在客戶那邊隔幾天就要崩潰一次，一直都沒有找到原因，讓我幫忙看下怎麼回事，確實工控類的軟體環境複雜難搞，朋友手上有一個崩潰的dump，剛好丟給我來分析一下。 二：WinDbg分析 1. 程式為什麼會崩潰 windbg 有一個厲害之處在於 ...
  • 一個.NET內置依賴註入的小型強化版
    前言 .NET生態中有許多依賴註入容器。在大多數情況下，微軟提供的內置容器在易用性和性能方面都非常優秀。外加ASP.NET Core預設使用內置容器，使用很方便。 但是筆者在使用中一直有一個頭疼的問題：服務工廠無法提供請求的服務類型相關的信息。這在一般情況下並沒有影響，但是內置容器支持註冊開放泛型服 ...
  • WPF隨筆收錄-DataGrid固定右側列
    一、前言 在項目開發過程中，DataGrid是經常使用到的一個數據展示控制項，而通常表格的最後一列是作為操作列存在，比如會有編輯、刪除等功能按鈕。但WPF的原始DataGrid中，預設只支持固定左側列，這跟大家習慣性操作列放最後不符，今天就來介紹一種簡單的方式實現固定右側列。（這裡的實現方式參考的大佬 ...
所有分類