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

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

引言 如果你看過了 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

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

更多相關文章
  • 原文:https://blogs.msdn.microsoft.com/mazhou/2017/06/27/c-7-series-part-4-discards/ 有時我們想要忽略一個方法返回的值,特別是那些out參數,一個典型的例子是檢查一個字元串是否可以解析成另一種類型: 這裡我們要忽略pars ...
  • 場景 在新建一個程式後,項目中會有一個預設配置文件App.config 一般會將一些配置文件信息,比如連接資料庫的字元串等信息存在此配置文件中。 怎樣在代碼中獲取自己配置的鍵值對信息。 註: 博客主頁: https://blog.csdn.net/badao_liumang_qizhi 關註公眾號 ...
  • 1.1、自定義config結構(參考對應顏色標註),放到configuration根節點下: <test> <testInfos> <testInfo aa="aaKeyStr1" bb="111111" /> <testInfo aa="aaKeyStr2" bb="222222" /> </te ...
  • 場景 想要在程式中獲取App.config中設置的內容。 想要通過 ConfigurationManager.AppSettings[key]; 來進行獲取,已經添加 using System.Configuration; 但是還是提示“當前上下文中不存在名稱ConfigurationManager ...
  • 委托的定義 什麼是委托? 委托實際上是一種類型,是一種引用類型。 微軟用delegate關鍵字來聲明委托,delegate與int,string,double等關鍵字一樣。都是聲明用的。 下麵先看下聲明代碼,這裡聲明瞭兩個委托。 1 2 public delegate void TestDelega ...
  • 引言 前幾天 ".NET Core3.1發佈" ,於是我把公司一個基礎通用系統升級了,同時刪除了幾個基礎模塊當然這幾個基礎模塊與.NET Core3.1無關,其中包括了支付模塊,升級完後靜文(同事)問我你把支付刪除了啊?我說是啊,沒考慮好怎麼加上(感覺目前不太好,我需要重新設計一下)。 故事從這開始 ...
  • using System; using System.Text; using System.IO; namespace ConsoleApplication15 { class Program { static void Main(string[] args) { string fileName =... ...
  • using System; using System.Text; using System.IO; using System.Security.Cryptography; namespace ConsoleApplication13 { class Program { static void Mai... ...
一周排行
  • 比如要拆分“呵呵呵90909086676喝喝999”,下麵當type=0返回的是中文字元串“呵呵呵,喝喝”,type=1返回的是數字字元串“90909086676,999”, private string GetStrings(string str,int type=0) { IList<strin ...
  • Swagger一個優秀的Api介面文檔生成工具。Swagger可以可以動態生成Api介面文檔,有效的降低前後端人員關於Api介面的溝通成本,促進項目高效開發。 1、使用NuGet安裝最新的包:Swashbuckle.AspNetCore。 2、編輯項目文件(NetCoreTemplate.Web.c ...
  • 2020 年 7 月 30 日, 由.NET基金會和微軟 將舉辦一個線上和為期一天的活動,包括 微軟 .NET 團隊的演講者以及社區的演講者。本次線上大會 專註.NET框架構建微服務,演講者分享構建和部署雲原生應用程式的最佳實踐、模式、提示和技巧。有關更多信息和隨時瞭解情況:https://focu... ...
  • #abp框架Excel導出——基於vue #1.技術棧 ##1.1 前端採用vue,官方提供 UI套件用的是iview ##1.2 後臺是abp——aspnetboilerplate 即abp v1,https://github.com/aspnetboilerplate/aspnetboilerp ...
  • 前言 本文的文字及圖片來源於網路,僅供學習、交流使用,不具有任何商業用途,版權歸原作者所有,如有問題請及時聯繫我們以作處理。 作者:碧茂大數據 PS:如有需要Python學習資料的小伙伴可以加下方的群去找免費管理員領取 input()輸入 Python提供了 input() 內置函數從標準輸入讀入一 ...
  • 從12年到20年,python以肉眼可見的趨勢超過了java,成為了當今It界人人皆知的編程語言。 python為什麼這麼火? 網路編程語言搜索指數 適合初學者 Python具有語法簡單、語句清晰的特點,這就讓初學者在學習階段可以把精力集中在編程對象和思維方法上。 大佬都在用 Google,YouT ...
  • 在社會上存在一種普遍的對培訓機構的學生一種歧視的現象,具體表現在,比如:當你去公司面試的時候,一旦你說了你是培訓機構出來的,那麼基本上你就涼了,那麼你瞞著不說,然後又通過了面試成功入職,但是以後一旦在公司被髮現有培訓經歷,可能會面臨被降薪,甚至被辭退,培訓機構出來的學生,在用人單位眼裡就是能力低下的 ...
  • from typing import List# 這道題看了大佬寫的代碼,經過自己的理解寫出來了。# 從最外圍的四周找有沒有為O的,如果有的話就進入深搜函數,然後深搜遍歷# 判斷上下左右的位置是否為Oclass Solution: def solve(self, board: List[List[s ...
  • import requests; import re; import os; # 1.請求網頁 header = { "user-agent":'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, li ...
  • import requests; import re; import os; import parsel; 1.請求網頁 header = { "user-agent":'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537. ...