引言
如果你看過了 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!
需要注意代碼輸出中的幾個變化：
- 我 們需要在客戶端程式中呼叫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 class Calculator { /* 與上面同，略 */}
此時的輸出為：
Client application started!
Method invoked!
Main Thread: Client executed 1 second(s).
Pool Thread: Add executed 1 second(s).
Main Thread: Client executed 2 second(s).
Pool Thread: Add executed 2 second(s).
Method complete!
Main Thread: Client executed 3 second(s).
Result: 7
Press any key to exit...
現 在執行完這段代碼只需要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()回呼方法中：
public delegate int AddDelegate(int x, int y);
class Program9 {
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);
string data = https://www.cnblogs.com/ljdong7/p/"Any data you want to pass.";
AsyncCallback callBack = new AsyncCallback(OnAddComplete);
del.BeginInvoke(2, 5, callBack, data); // 異步呼叫方法
// 做某些其它的事情，模擬需要執行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();
}
static void OnAddComplete(IAsyncResult asyncResult) {
AsyncResult result = (AsyncResult)asyncResult;
AddDelegate del = (AddDelegate)result.AsyncDelegate;
string data = https://www.cnblogs.com/ljdong7/p/(string)asyncResult.AsyncState;
int rtn = del.EndInvoke(asyncResult);
Console.WriteLine("{0}: Result, {1}; Data: {2} ",
Thread.CurrentThread.Name, rtn, data);
}
}
public class Calculator { /* 與上面同，略 */}
它產生的輸出為：
Client application started!
Method invoked!
Main Thread: Client executed 1 second(s).
Pool Thread: Add executed 1 second(s).
Main Thread: Client executed 2 second(s).
Pool Thread: Add executed 2 second(s).
Method complete!
Pool Thread: Result, 7; Data: Any data you want to pass.
Main Thread: Client executed 3 second(s).
Press any key to exit...
這 里有幾個值得注意的地方：1、我們在呼叫BeginInvoke()后不再需要保存IAysncResult了，因為AysncCallback委托將該 物件定義在了回呼方法的引數串列中；2、我們在OnAddComplete()方法中獲得了呼叫BeginInvoke()時最后一個引數傳遞的值，字符 串“Any data you want to pass”；3、執行回呼方法的執行緒并非客戶端執行緒Main Thread，而是來自執行緒池中的執行緒Pool Thread，另外如前面所說，在呼叫EndInvoke()時有可能會拋出例外，所以在應該將它放到try/catch塊中，這里我就不再示范了，
總結
這篇文章是對我之前寫的C#中的委托和事件的一個補充，大致分為了三個部分，第一部分講述了幾個容易讓人產生困惑的問題：為什么使用事件而不是委托變數，為什么通常委托的定義都回傳void；第二部分講述了如何處理例外和超時；第三部分則講述了通過委托實作異步方法的呼叫，
感謝閱讀，希望這篇文章能給你帶來幫助，
轉載請註明出處，本文鏈接：https://www.uj5u.com/net/94883.html
標籤：C#
上一篇：C#中的委托和事件(一)