程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> .NET網頁編程 >> C# >> C#入門知識 >> C# 關於委托和事件的妙文,

C# 關於委托和事件的妙文,

編輯:C#入門知識

C# 關於委托和事件的妙文,


C# 關於委托和事件的妙文:

通過一個例子詳細介紹委托和事件的作用;Observer模式簡介

轉自:http://blog.csdn.net/susan19890313/article/details/6949738

分類: c#2011-11-08 20:45 741人閱讀 評論(0) 收藏 舉報 c#string設計模式classobject.net  

        委托和事件在 .Net Framework中的應用非常廣泛,然而,較好地理解委托和事件對很多接觸C#時間不長的人來說並不容易。它們就像是一道檻兒,過了這個檻的人,覺得真是太容易了,而沒有過去的人每次見到委托和事件就覺得心裡別(biè)得慌,混身不自在。本文中,我將通過兩個范例由淺入深地講述什麼是委托、為什麼要使用委托、事件的由來、.Net Framework中的委托和事件、委托和事件對Observer設計模式的意義,對它們的中間代碼也做了討論。

一、為什麼要使用委托

   委托的應用之一:將一個方法作為另一個方法的參數
   我們先不管這個標題如何的繞口,也不管委托究竟是個什麼東西,來看下面這兩個最簡單的方法,它們不過是在屏幕上輸出一句問候的話語:

以下為引用的內容:
       public void GreetPeople(string name) {
              // 做某些額外的事情,比如初始化之類,此處略
              EnglishGreeting(name);
       }
       public void EnglishGreeting(string name) {
              Console.WriteLine(”Morning, ” + name);
       }

       暫且不管這兩個方法有沒有什麼實際意義。GreetPeople用於向某人問好,當我們傳遞代表某人姓名的name參數,比如說“Jimmy”,進去的時候,在這個方法中,將調用EnglishGreeting方法,再次傳遞name參數,EnglishGreeting則用於向屏幕輸出 “Morning, Jimmy”。

      現在假設這個程序需要進行全球化,哎呀,不好了,我是人,我不明白“Morning”是什麼意思,怎麼辦呢?好吧,我們再加個中文版的問候方法:

以下為引用的內容:
public void ChineseGreeting(string name){
       Console.WriteLine(”早上好, ” + name);
}

        這時候,GreetPeople也需要改一改了,不然如何判斷到底用哪個版本的Greeting問候方法合適呢?在進行這個之前,我們最好再定義一個枚舉作為判斷的依據: 
以下為引用的內容:
   1. public enum Language{  
   2.        English, Chinese  
   3. }  
   4. public void GreetPeople(string name, Language lang){  
   5.        //做某些額外的事情,比如初始化之類,此處略  
   6.        swith(lang){  
   7.               case Language.English:  
   8.                      EnglishGreeting(name);  
   9.                      break;   
  10.               case Language.Chinese:  
  11.                      ChineseGreeting(name);  
  12.                      break;  
  13.               }  
  14. } 

        OK,盡管這樣解決了問題,但我不說大家也很容易想到,這個解決方案的可擴展性很差,如果日後我們需要再添加韓文版、日文版,就不得不反復修改枚舉和GreetPeople()方法,以適應新的需求。

在考慮新的解決方案之前,我們先看看 GreetPeople的方法簽名:
public void GreetPeople(string name, Language lang)

我們僅看 string name,在這裡,string 是參數類型,name 是參數變量,當我們賦給name字符串“jimmy”時,它就代表“jimmy”這個值;當我們賦給它“張子陽”時,它又代表著“張子陽”這個值。然後,我們可以在方法體內對這個name進行其他操作。哎,這簡直是廢話麼,剛學程序就知道了。 Www~

如果你再仔細想想,假如GreetPeople()方法可以接受一個參數變量,這個變量可以代表另一個方法,當我們給這個變量賦值 EnglishGreeting的時候,它代表著 EnglsihGreeting() 這個方法;當我們給它賦值ChineseGreeting 的時候,它又代表著ChineseGreeting()方法。我們將這個參數變量命名為 MakeGreeting,那麼不是可以如同給name賦值時一樣,在調用 GreetPeople()方法的時候,給這個MakeGreeting 參數也賦上值麼(ChineseGreeting或者EnglsihGreeting等)?然後,我們在方法體內,也可以像使用別的參數一樣使用 MakeGreeting。但是,由於MakeGreeting代表著一個方法,它的使用方式應該和它被賦的方法(比如ChineseGreeting) 是一樣的,比如:

MakeGreeting(name);

好了,有了思路了,我們現在就來改改GreetPeople()方法,那麼它應該是這個樣子了:
以下為引用的內容:
public void GreetPeople(string name, *** MakeGreeting){
       MakeGreeting(name);
}

注意到 *** ,這個位置通常放置的應該是參數的類型,但到目前為止,我們僅僅是想到應該有個可以代表方法的參數,並按這個思路去改寫GreetPeople方法,現在就出現了一個大問題:這個代表著方法的MakeGreeting參數應該是什麼類型的?

NOTE:這裡已不再需要枚舉了,因為在給MakeGreeting賦值的時候動態地決定使用哪個方法,是ChineseGreeting還是 EnglishGreeting,而在這個兩個方法內部,已經對使用“morning”還是“早上好”作了區分。

聰明的你應該已經想到了,現在是委托該出場的時候了,但講述委托之前,我們再看看MakeGreeting參數所能代表的 ChineseGreeting()和EnglishGreeting()方法的簽名:
public void EnglishGreeting(string name)
public void ChineseGreeting(string name)

如同name可以接受String類型的“true”和“1”,但不能接受bool類型的true和int類型的1一樣。MakeGreeting 的 參數類型定義 應該能夠確定 MakeGreeting可以代表的 方法種類,再進一步講,就是MakeGreeting可以代表方法 的參數類型和返回值類型。 於是,委托出現了:它定義了MakeGreeting參數所能代表的方法的種類,也就是MakeGreeting參數的類型。即委托定義了方法的簽名(在委托的上下文中方法簽名包括參數類型和返回值類型)。
NOTE:如果上面這句話比較繞口,我把它翻譯成這樣:string 定義了name參數所能代表的值的種類,也就是name參數的類型。

本例中委托的定義:

public delegate void GreetingDelegate(string name);
可以與上面EnglishGreeting()方法的簽名對比一下,除了加入了delegate關鍵字以外,其余的是不是完全一樣?

現在,讓我們再次改動GreetPeople()方法,如下所示:

以下為引用的內容:
public void GreetPeople(string name, GreetingDelegate MakeGreeting){
       MakeGreeting(name);
}

如你所見,委托GreetingDelegate出現的位置與 string相同,string是一個類型,那麼GreetingDelegate應該也是一個類型,或者叫類(Class)。但是委托的聲明方式和類卻完全不同,這是怎麼一回事?實際上,委托在編譯的時候確實會編譯成類。因為Delegate是一個類,所以在任何可以聲明類的地方都可以聲明委托。更多的內容將在下面講述,現在,請看看這個范例的完整代碼:

.

以下為引用的內容:

view plaincopy to clipboardprint?

   1. using System;  
   2. using System.Collections.Generic;  
   3. using System.Text;  
   4. namespace Delegate {  
   5.        //定義委托,它定義了可以代表的方法的類型  
   6.        public delegate void GreetingDelegate(string name);  
   7.        class Program {  
   8.               private static void EnglishGreeting(string name) {  
   9.                      Console.WriteLine(”Morning, ” + name);  
  10.               } Www~  
  11.               private static void ChineseGreeting(string name) {  
  12.                      Console.WriteLine(”早上好, ” + name);  
  13.               }   
  14.               //注意此方法,它接受一個GreetingDelegate類型的方法作為參數  
  15.               private static void GreetPeople(string name, GreetingDelegate MakeGreeting) {  
  16.                      MakeGreeting(name);  
  17.               }  
  18.               static void Main(string[] args) {  
  19.                      GreetPeople(”Jimmy Zhang”, EnglishGreeting);  
  20.                      GreetPeople(”張子陽”, ChineseGreeting);  
  21.                      Console.ReadKey();  
  22.               }  
  23.        }  
  24. } Www~ 

輸出如下:

Morning, Jimmy Zhang

早上好, 張子陽

我們現在對委托做一個總結:

委托是一個類,它定義了方法的類型,使得可以將方法當作另一個方法的參數來進行傳遞,這種將方法動態地賦給參數的做法,可以避免在程序中大量使用 If-Else(Switch)語句,同時使得程序具有更好的可擴展性。

 

二、將方法綁定到委托

看到這裡,是不是有那麼點如夢初醒的感覺?於是,你是不是在想:在上面的例子中,我不一定要直接在GreetPeople()方法中給 name參數賦值,我可以像這樣使用變量:

以下為引用的內容:
static void Main(string[] args) {
       string name1, name2;
       name1 = “Jimmy Zhang”;
       name2 = “張子陽”;

       GreetPeople(name1, EnglishGreeting);
       GreetPeople(name2, ChineseGreeting);
       Console.ReadKey();
}
 
而既然委托GreetingDelegate 和 類型 string 的地位一樣,都是定義了一種參數類型,那麼,我是不是也可以這麼使用委托?
以下為引用的內容:
static void Main(string[] args) {
       GreetingDelegate delegate1, delegate2;
       delegate1 = EnglishGreeting;
       delegate2 = ChineseGreeting;
       GreetPeople(”Jimmy Zhang”, delegate1);
       GreetPeople(”張子陽”, delegate2);
       Console.ReadKey();
}
如你所料,這樣是沒有問題的,程序一如預料的那樣輸出。這裡,我想說的是委托不同於string的一個特性:可以將多個方法賦給同一個委托,或者叫將多個方法綁定到同一個委托,當調用這個委托的時候,將依次調用其所綁定的方法。在這個例子中,語法如下:

以下為引用的內容:
static void Main(string[] args) {
       GreetingDelegate delegate1;
       delegate1 = EnglishGreeting;     // 先給委托類型的變量賦值
       delegate1 += ChineseGreeting;     // 給此委托變量再綁定一個方法

       // 將先後調用 EnglishGreeting 與 ChineseGreeting 方法
       GreetPeople(”Jimmy Zhang”, delegate1);      
       Console.ReadKey();
}

輸出為:
Morning, Jimmy Zhang

早上好, Jimmy Zhang

實際上,我們可以也可以繞過GreetPeople方法,通過委托來直接調用EnglishGreeting和ChineseGreeting:

以下為引用的內容:
static void Main(string[] args) {
       GreetingDelegate delegate1;
       delegate1 = EnglishGreeting;     // 先給委托類型的變量賦值
       delegate1 += ChineseGreeting;     // 給此委托變量再綁定一個方法

       // 將先後調用 EnglishGreeting 與 ChineseGreeting 方法
       delegate1 (”Jimmy Zhang”);      
       Console.ReadKey();
}
 
NOTE:這在本例中是沒有問題的,但回頭看下上面GreetPeople()的定義,在它之中可以做一些對於EnglshihGreeting和 ChineseGreeting來說都需要進行的工作,為了簡便我做了省略。

Www~
注意這裡,第一次用的“=”,是賦值的語法;第二次,用的是“+=”,是綁定的語法。如果第一次就使用“+=”,將出現“使用了未賦值的局部變量”的編譯錯誤。

既然給委托可以綁定一個方法,那麼也應該有辦法取消對方法的綁定,很容易想到,這個語法是“-=”:

以下為引用的內容:
static void Main(string[] args) {
       GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
       delegate1 += ChineseGreeting;    // 給此委托變量再綁定一個方法
       // 將先後調用 EnglishGreeting 與 ChineseGreeting 方法
       GreetPeople(”Jimmy Zhang”, delegate1);      
       Console.WriteLine();

       delegate1 -= EnglishGreeting; //取消對EnglishGreeting方法的綁定
       // 將僅調用 ChineseGreeting
       GreetPeople(”張子陽”, delegate1);      
       Console.ReadKey();
}
 
輸出為:

Morning, Jimmy Zhang

早上好, Jimmy Zhang Www_

早上好, 張子陽

讓我們再次對委托作個總結:

使用委托可以將多個方法綁定到同一個委托變量,當調用此變量時(這裡用“調用”這個詞,是因為此變量代表一個方法),可以依次調用所有綁定的方法。

 

三、事件的由來

我們繼續思考上面的程序:上面的三個方法都定義在Programe類中,這樣做是為了理解的方便,實際應用中,通常都是 GreetPeople 在一個類中,ChineseGreeting和 EnglishGreeting 在另外的類中。現在你已經對委托有了初步了解,是時候對上面的例子做個改進了。假設我們將GreetingPeople()放在一個叫 GreetingManager的類中,那麼新程序應該是這個樣子的:

Www_

以下為引用的內容:
namespace Delegate {
       //定義委托,它定義了可以代表的方法的類型
       public delegate void GreetingDelegate(string name);
      
       //新建的GreetingManager類
       public class GreetingManager{
              public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                     MakeGreeting(name); .
              }
              }
       class Program {
              private static void EnglishGreeting(string name) {
                     Console.WriteLine(”Morning, ” + name);
              }

              private static void ChineseGreeting(string name) {
                     Console.WriteLine(”早上好, ” + name);
              } @com

              static void Main(string[] args) {
                     // … …
              }
       }
}

Www~

這個時候,如果要實現前面演示的輸出效果,Main方法我想應該是這樣的:

以下為引用的內容:
static void Main(string[] args) {
       GreetingManager gm = new  GreetingManager();
       gm.GreetPeople(”Jimmy Zhang”, EnglishGreeting);
       gm.GreetPeople(”張子陽”, ChineseGreeting);
}

我們運行這段代碼,嗯,沒有任何問題。程序一如預料地那樣輸出了:
Morning, Jimmy Zhang
早上好, 張子陽

現在,假設我們需要使用上一節學到的知識,將多個方法綁定到同一個委托變量,該如何做呢?讓我們再次改寫代碼:

以下為引用的內容:

static void Main(string[] args) {
       GreetingManager gm = new  GreetingManager();
       GreetingDelegate delegate1;
       delegate1 = EnglishGreeting;
       delegate1 += ChineseGreeting;

       gm.GreetPeople(”Jimmy Zhang”, delegate1);
}
 
輸出:

Www~
Morning, Jimmy Zhang

早上好, Jimmy Zhang
到了這裡,我們不禁想到:面向對象設計,講究的是對象的封裝,既然可以聲明委托類型的變量(在上例中是delegate1),我們何不將這個變量封裝到 GreetManager類中?在這個類的客戶端中使用不是更方便麼?於是,我們改寫GreetManager類,像這樣:

以下為引用的內容:
public class GreetingManager{
//在GreetingManager類的內部聲明delegate1變量
       public GreetingDelegate delegate1;      
public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                     MakeGreeting(name);
       }
}

現在,我們可以這樣使用這個委托變量: 
以下為引用的內容:
static void Main(string[] args) {
       GreetingManager gm = new  GreetingManager();
       gm.delegate1 = EnglishGreeting;
       gm.delegate1 += ChineseGreeting;
       gm.GreetPeople(”Jimmy Zhang”, gm.delegate1);

 
盡管這樣達到了我們要的效果,但是似乎並不美氣,光是第一個方法注冊用“=”,第二個用“+=”就讓人覺得別扭。此時,輪到Event出場了,C# 中可以使用事件來專門完成這項工作,我們改寫GreetingManager類,它變成了這個樣子: 
以下為引用的內容:
public class GreetingManager{
       //這一次我們在這裡聲明一個事件
       public event GreetingDelegate MakeGreet;
public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
              MakeGreeting(name);
       }

 
.

很容易注意到:MakeGreet 事件的聲明與之前委托變量delegate1的聲明唯一的區別是多了一個event關鍵字。看到這裡,你差不多明白到:事件其實沒什麼不好理解的,聲明一個事件不過類似於聲明一個委托類型的變量而已。

我們想當然地改寫Main方法: 
以下為引用的內容:
static void Main(string[] args) {
       GreetingManager gm = new  GreetingManager();
       gm.MakeGreet = EnglishGreeting; // 編譯錯誤1
       gm.MakeGreet += ChineseGreeting;
       gm.GreetPeople(”Jimmy Zhang”, gm.MakeGreet); //編譯錯誤2
}
 
這次,你會得到編譯錯誤:事件“Delegate.GreetingManager.MakeGreet”只能出現在 += 或 -= 的左邊(從類型“Delegate.GreetingManager”中使用時除外)。

事件和委托的編譯代碼

這時候,我們不得不注釋掉編譯錯誤的行,然後重新進行編譯,再借助Reflactor來對 event的聲明語句做一探究,看看為什麼會發生這樣的錯誤:
public event GreetingDelegate MakeGreet; 
可以看到,實際上盡管我們在GreetingManager裡將 MakeGreet 聲明為public,但是,實際上MakeGreet會被編譯成私有字段,難怪會發生上面的編譯錯誤了,因為它根本就不允許在GreetingManager類的外面以賦值的方式訪問。
我們進一步看下MakeGreet所產生的代碼:

以下為引用的內容:

private GreetingDelegate MakeGreet;       //對事件的聲明 實際是 聲明一個私有的委托變量

[MethodImpl(MethodImplOptions.Synchronized)]
public void add_MakeGreet(GreetingDelegate value){
    this.MakeGreet = (GreetingDelegate) Delegate.Combine(this.MakeGreet, value);
}

[MethodImpl(MethodImplOptions.Synchronized)]
public void remove_MakeGreet(GreetingDelegate value){
    this.MakeGreet = (GreetingDelegate) Delegate.Remove(this.MakeGreet, value);
}

現在已經很明確了:MakeGreet 事件確實是一個GreetingDelegate類型的委托,只不過不管是不是聲明為public,它總是被聲明為private。另外,它還有兩個方法,分別是add_MakeGreet和remove_MakeGreet,這兩個方法分別用於注冊委托類型的方法和取消注冊,實際上也就是: “+= ”對應 add_MakeGreet,“-=”對應remove_MakeGreet。而這兩個方法的訪問限制取決於聲明事件時的訪問限制符。

在add_MakeGreet()方法內部,實際上調用了System.Delegate的Combine()靜態方法,這個方法用於將當前的變量添加到委托鏈表中。我們前面提到過兩次,說委托實際上是一個類,在我們定義委托的時候:
public delegate void GreetingDelegate(string name);

當編譯器遇到這段代碼的時候,會生成下面這樣一個完整的類:

以下為引用的內容:

public class GreetingDelegate:System.MulticastDelegate{

       public GreetingDelegate(object @object, IntPtr method);
       public virtual IAsyncResult BeginInvoke(string name, AsyncCallback callback, object @object);
       public virtual void EndInvoke(IAsyncResult result);
       public virtual void Invoke(string name);
}

關於這個類的更深入內容,可以參閱《CLR Via C#》等相關書籍,這裡就不再討論了。

 

四、委托、事件與Observer設計模式


范例說明
上面的例子已不足以再進行下面的講解了,我們來看一個新的范例,因為之前已經介紹了很多的內容,所以本節的進度會稍微快一些:
假設我們有個高檔的熱水器,我們給它通上電,當水溫超過95度的時候:1、揚聲器會開始發出語音,告訴你水的溫度;2、液晶屏也會改變水溫的顯示,來提示水已經快燒開了。

現在我們需要寫個程序來模擬這個燒水的過程,我們將定義一個類來代表熱水器,我們管它叫:Heater,它有代表水溫的字段,叫做 temperature;當然,還有必不可少的給水加熱方法BoilWater(),一個發出語音警報的方法MakeAlert(),一個顯示水溫的方法,ShowMsg()。
以下為引用的內容:
namespace Delegate {
       class Heater {
              private int temperature; // 水溫
              // 燒水
              public void BoilWater() {
                     for (int i = 0; i <= 100; i++) {
                            temperature = i;

                            if (temperature > 95) {
                                   MakeAlert(temperature);
                                   ShowMsg(temperature);
                            }
                     }
              }
              // 發出語音警報
              private void MakeAlert(int param) {
                     Console.WriteLine(”Alarm:嘀嘀嘀,水已經 {0} 度了:” , param);
              }
             
              // 顯示水溫
              private void ShowMsg(int param) {
                     Console.WriteLine(”Display:水快開了,當前溫度:{0}度。” , param);
              }

.

       }

       class Program {
              static void Main() {
                     Heater ht = new Heater();
                     ht.BoilWater();
              }
       }
}

上面的例子顯然能完成我們之前描述的工作,但是卻並不夠好。現在假設熱水器由三部分組成:熱水器、警報器、顯示器,它們來自於不同廠商並進行了組裝。那麼,應該是熱水器僅僅負責燒水,它不能發出警報也不能顯示水溫;在水燒開時由警報器發出警報、顯示器顯示提示和水溫。

這時候,上面的例子就應該變成這個樣子:

以下為引用的內容:

// 熱水器
public class Heater {      
              private int temperature;
                    
              // 燒水
              private void BoilWater() {
                     for (int i = 0; i <= 100; i++) { 
                            temperature = i;
                     }
              }
       }

       // 警報器
       public class Alarm{
              private void MakeAlert(int param) {
                     Console.WriteLine(”Alarm:嘀嘀嘀,水已經 {0} 度了:” , param);
              }
       }

       // 顯示器
       public class Display{
              private void ShowMsg(int param) {
                     Console.WriteLine(”Display:水已燒開,當前溫度:{0}度。” , param);
              }

 
這裡就出現了一個問題:如何在水燒開的時候通知報警器和顯示器?在繼續進行之前,我們先了解一下Observer設計模式

Observer設計模式簡介

Observer設計模式中主要包括如下兩類對象:
Subject:監視對象,它往往包含著其他對象所感興趣的內容。在本范例中,熱水器就是一個監視對象,它包含的其他對象所感興趣的內容,就是 temprature字段,當這個字段的值快到100時,會不斷把數據發給監視它的對象。

Observer:監視者,它監視Subject,當Subject中的某件事發生的時候,會告知Observer,而Observer則會采取相應的行動。在本范例中,Observer有警報器和顯示器,它們采取的行動分別是發出警報和顯示水溫。
在本例中,事情發生的順序應該是這樣的:

警報器和顯示器告訴熱水器,它對它的溫度比較感興趣(注冊)。

熱水器知道後保留對警報器和顯示器的引用。

熱水器進行燒水這一動作,當水溫超過95度時,通過對警報器和顯示器的引用,自動調用警報器的MakeAlert()方法、顯示器的 ShowMsg()方法。
類似這樣的例子是很多的,GOF對它進行了抽象,稱為Observer設計模式:Observer設計模式是為了定義對象間的一種一對多的依賴關系,以便於當一個對象的狀態改變時,其他依賴於它的對象會被自動告知並更新。Observer模式是一種松耦合的設計模式。 Www~

實現范例的Observer設計模式

我們之前已經對委托和事件介紹很多了,現在寫代碼應該很容易了,現在在這裡直接給出代碼,並在注釋中加以說明。
以下為引用的內容:
using System;
using System.Collections.Generic;
using System.Text;
namespace Delegate {
       // 熱水器
       public class Heater {
              private int temperature;
              public delegate void BoilHandler(int param);       //聲明委托
              public event BoilHandler BoilEvent;                     //聲明事件

              // 燒水
              public void BoilWater() {
                     for (int i = 0; i <= 100; i++) {
                            temperature = i;

Www~
                            if (temperature > 95) {
                                   if (BoilEvent != null) {       //如果有對象注冊
                                          BoilEvent(temperature);       //調用所有注冊對象的方法
                                   } 
                            }
                     }
              }
       }
       // 警報器
       public class Alarm {
              public void MakeAlert(int param) {
                     Console.WriteLine(”Alarm:嘀嘀嘀,水已經 {0} 度了:”, param);
              }
       }

       // 顯示器
       public class Display {
              public static void ShowMsg(int param) {       //靜態方法
                     Console.WriteLine(”Display:水快燒開了,當前溫度:{0}度。”, param);
              }
       }
      
       class Program {
              static void Main() {
                     Heater heater = new Heater();
                     Alarm alarm = new Alarm();

.

                     heater.BoilEvent += alarm.MakeAlert;       //注冊方法
                     heater.BoilEvent += (new Alarm()).MakeAlert;       //給匿名對象注冊方法
                     heater.BoilEvent += Display.ShowMsg;              //注冊靜態方法 .

                     heater.BoilWater();       //燒水,會自動調用注冊過對象的方法
              }
       }
}

輸出為:

Alarm:嘀嘀嘀,水已經 96 度了: Www_

Alarm:嘀嘀嘀,水已經 96 度了:

Display:水快燒開了,當前溫度:96度。
// 省略… @com

五、.Net Framework中的委托與事件

盡管上面的范例很好地完成了我們想要完成的工作,但是我們不僅疑惑:為什麼.Net Framework 中的事件模型和上面的不同?為什麼有很多的EventArgs參數?

在回答上面的問題之前,我們先搞懂 .Net Framework的編碼規范:

委托類型的名稱都應該以EventHandler結束。
委托的原型定義:有一個void返回值,並接受兩個輸入參數:一個Object 類型,一個 EventArgs類型(或繼承自EventArgs)。

事件的命名為 委托去掉 EventHandler之後剩余的部分。

繼承自EventArgs的類型應該以EventArgs結尾。
再做一下說明:
委托聲明原型中的Object類型的參數代表了Subject,也就是監視對象,在本例中是 Heater(熱水器)。回調函數(比如Alarm的MakeAlert)可以通過它訪問觸發事件的對象(Heater)。

EventArgs 對象包含了Observer所感興趣的數據,在本例中是temperature。
上面這些其實不僅僅是為了編碼規范而已,這樣也使得程序有更大的靈活性。比如說,如果我們不光想獲得熱水器的溫度,還想在Observer端(警報器或者顯示器)方法中獲得它的生產日期、型號、價格,那麼委托和方法的聲明都會變得很麻煩,而如果我們將熱水器的引用傳給警報器的方法,就可以在方法中直接訪問熱水器了。

現在我們改寫之前的范例,讓它符合 .Net Framework 的規范:

以下為引用的內容:

using System;
using System.Collections.Generic;
using System.Text;

namespace Delegate {
       // 熱水器
       public class Heater {
              private int temperature;
              public string type = “RealFire 001″;              // 添加型號作為演示
              public string area = “China Xian”;                     // 添加產地作為演示
              //聲明委托
              public delegate void BoiledEventHandler(Object sender, BoliedEventArgs e);
              public event BoiledEventHandler Boiled;       //聲明事件

              // 定義BoliedEventArgs類,傳遞給Observer所感興趣的信息
              public class BoliedEventArgs : EventArgs {
                     public readonly int temperature;
                     public BoliedEventArgs(int temperature) {
                            this.temperature = temperature;
                     }
              }

              // 可以供繼承自 Heater 的類重寫,以便繼承類拒絕其他對象對它的監視
              protected virtual void OnBolied(BoliedEventArgs e) {
                     if (Boiled != null) {       // 如果有對象注冊
                            Boiled(this, e);       // 調用所有注冊對象的方法
                     }
              }
              
              // 燒水。
              public void BoilWater() {
                     for (int i = 0; i <= 100; i++) {
                            temperature = i;
                            if (temperature > 95) {
                                   //建立BoliedEventArgs 對象。
                                   BoliedEventArgs e = new BoliedEventArgs(temperature); .
                                   OnBolied(e);       // 調用 OnBolied方法
                            }
                     }
              }
       }

       // 警報器
       public class Alarm {
              public void MakeAlert(Object sender, Heater.BoliedEventArgs e) {
                     Heater heater = (Heater)sender;              //這裡是不是很熟悉呢?
                     //訪問 sender 中的公共字段
                     Console.WriteLine(”Alarm:{0} - {1}: “, heater.area, heater.type);
                     Console.WriteLine(”Alarm: 嘀嘀嘀,水已經 {0} 度了:”, e.temperature); 
                     Console.WriteLine();
              }

       }
       // 顯示器
       public class Display {
              public static void ShowMsg(Object sender, Heater.BoliedEventArgs e) {       //靜態方法
                     Heater heater = (Heater)sender;
                     Console.WriteLine(”Display:{0} - {1}: “, heater.area, heater.type);
                     Console.WriteLine(”Display:水快燒開了,當前溫度:{0}度。”, e.temperature);
                     Console.WriteLine();
              }
       }

       class Program {
              static void Main() {
                     Heater heater = new Heater();
                     Alarm alarm = new Alarm();

                     heater.Boiled += alarm.MakeAlert;       //注冊方法
                     heater.Boiled += (new Alarm()).MakeAlert;              //給匿名對象注冊方法
                     heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert);       //也可以這麼注冊
                     heater.Boiled += Display.ShowMsg;              //注冊靜態方法

                     heater.BoilWater();       //燒水,會自動調用注冊過對象的方法
              }
       }
}

Www_

輸出為:

以下為引用的內容:
Alarm:China Xian - RealFire 001:
Alarm: 嘀嘀嘀,水已經 96 度了:
Alarm:China Xian - RealFire 001:
Alarm: 嘀嘀嘀,水已經 96 度了:
Alarm:China Xian - RealFire 001:
Alarm: 嘀嘀嘀,水已經 96 度了:
Display:China Xian - RealFire 001:
Display:水快燒開了,當前溫度:96度。
// 省略 …
總結

在本文中我首先通過一個GreetingPeople的小程序向大家介紹了委托的概念、委托用來做什麼,隨後又引出了事件,接著對委托與事件所產生的中間代碼做了粗略的講述。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved