C#中委託和事件使用教程
文章源碼下載 C#委託與事件教程.zip (4.05
KB, 下載次數: 682)
委託 和 事件在 .Net Framework中的應用非常廣泛,然而,較好地理解委託和事件對很多接觸C#時間不長的人來說並不容易。它們就像是一道檻兒,過了這個檻的人,覺得真是太容易了,而沒有過去的人每次見到委託和事件就覺得心裏別(biè)得慌,混身不自在。本文中,我將通過兩個範例由淺入深地講述什麼是委託、爲什麼要使用委託、事件的由來、.Net Framework中的委託和事件、委託和事件對Observer設計模式的意義,對它們的中間代碼也做了討論。
將方法作爲方法的參數我們先不管這個標題如何的繞口,也不管委託究竟是個什麼東西,來看下面這兩個最簡單的方法,它們不過是在屏幕上輸出一句問候的話語:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
|
public void
GreetPeople( string name)
{
EnglishGreeting(name);
}
public void
EnglishGreeting( string name)
{
Console.WriteLine( "Morning,
"
+ name);
}
|
暫且不管這兩個方法有沒有什麼實際意義。GreetPeople用於向某人問好,當我們傳遞代表某人姓名的name參數,比如說“sufei”,進去的時候,在這個方法中,將調用EnglishGreeting方法,再次傳遞name參數,EnglishGreeting則用於向屏幕輸出 “Morning, sufei”。
現在假設這個程序需要進行全球化,哎呀,不好了,我是中國人,我不明白“Morning”是什麼意思,怎麼辦呢?好吧,我們再加個中文版的問候方法:
[C#] 純文本查看 複製代碼
01
02
03
|
public void
ChineseGreeting( string name){
Console.WriteLine( "早上好,
"
+ name);
}
|
這時候,GreetPeople也需要改一改了,不然如何判斷到底用哪個版本的Greeting問候方法合適呢?在進行這個之前,我們最好再定義一個枚舉作爲判斷的依據:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
11
12
13
14
|
public enum
Language{
English,
Chinese
}
public void
GreetPeople( string name,
Language lang){
swith(lang){
case Language.English:
EnglishGreeting(name);
break ;
case Language.Chinese:
ChineseGreeting(name);
break ;
}
}
|
OK,儘管這樣解決了問題,但我不說大家也很容易想到,這個解決方案的可擴展性很差,如果日後我們需要再添加韓文版、日文版,就不得不反覆修改枚舉和GreetPeople()方法,以適應新的需求。
在考慮新的解決方案之前,我們先看看 GreetPeople的方法簽名:
[C#] 純文本查看 複製代碼
01
|
public void
GreetPeople( string name,
Language lang)
|
我們僅看 string name,在這裏,string 是參數類型,name 是參數變量,當我們賦給name字符串“sufei”時,它就代表“sufei”這個值;當我們賦給它“蘇飛”時,它又代表着“蘇飛”這個值。然後,我們可以在方法體內對這個name進行其他操作。哎,這簡直是廢話麼,剛學程序就知道了。
如果你再仔細想想,假如GreetPeople()方法可以接受一個參數變量,這個變量可以代表另一個方法,當我們給這個變量賦值 EnglishGreeting的時候,它代表着 EnglsihGreeting() 這個方法;當我們給它賦值ChineseGreeting 的時候,它又代表着ChineseGreeting()方法。我們將這個參數變量命名爲 MakeGreeting,那麼不是可以如同給name賦值時一樣,在調用 GreetPeople()方法的時候,給這個MakeGreeting 參數也賦上值麼(ChineseGreeting或者EnglsihGreeting等)?然後,我們在方法體內,也可以像使用別的參數一樣使用MakeGreeting。但是,由於MakeGreeting代表着一個方法,它的使用方式應該和它被賦的方法(比如ChineseGreeting)是一樣的,比如:
MakeGreeting(name);
好了,有了思路了,我們現在就來改改GreetPeople()方法,那麼它應該是這個樣子了:
[C#] 純文本查看 複製代碼
01
02
03
|
public void
GreetPeople( string name,
*** MakeGreeting){
MakeGreeting(name);
}
|
注意到 *** ,這個位置通常放置的應該是參數的類型,但到目前爲止,我們僅僅是想到應該有個可以代表方法的參數,並按這個思路去改寫GreetPeople方法,現在就出現了一個大問題:這個代表着方法的MakeGreeting參數應該是什麼類型的?
NOTE:這裏已不再需要枚舉了,因爲在給MakeGreeting賦值的時候動態地決定使用哪個方法,是ChineseGreeting還是 EnglishGreeting,而在這個兩個方法內部,已經對使用“morning”還是“早上好”作了區分。
聰明的你應該已經想到了,現在是委託該出場的時候了,但講述委託之前,我們再看看MakeGreeting參數所能代表的 ChineseGreeting()和EnglishGreeting()方法的簽名:
[C#] 純文本查看 複製代碼
01
02
|
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參數的類型。
本例中委託的定義:
[C#] 純文本查看 複製代碼
01
|
public delegate
void
GreetingDelegate( string name);
|
可以與上面EnglishGreeting()方法的簽名對比一下,除了加入了delegate關鍵字以外,其餘的是不是完全一樣?
現在,讓我們再次改動GreetPeople()方法,如下所示:
[C#] 純文本查看 複製代碼
01
02
03
|
public void
GreetPeople( string name,
GreetingDelegate MakeGreeting){
MakeGreeting(name);
}
|
如你所見,委託GreetingDelegate出現的位置與 string相同,string是一個類型,那麼GreetingDelegate應該也是一個類型,或者叫類(Class)。但是委託的聲明方式和類卻完全不同,這是怎麼一回事?實際上,委託在編譯的時候確實會編譯成類。因爲Delegate是一個類,所以在任何可以聲明類的地方都可以聲明委託。更多的內容將在下面講述,現在,請看看這個範例的完整代碼:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
using System;
using System.Collections.Generic;
using System.Text;
namespace Delegate
{
public delegate
void
GreetingDelegate( string name);
class Program
{
private static
void
EnglishGreeting( string name)
{
Console.WriteLine( "Morning,
"
+ name);
}
private static
void
ChineseGreeting( string name)
{
Console.WriteLine( "早上好,
"
+ name);
}
private static
void
GreetPeople( string name,
GreetingDelegate MakeGreeting) {
MakeGreeting(name);
}
static void
Main( string []
args) {
GreetPeople( "sufei" ,
EnglishGreeting);
GreetPeople( "蘇飛" ,
ChineseGreeting);
Console.ReadKey();
}
}
}
|
輸出如下:
Morning, sufei
早上好, 蘇飛
我們現在對委託做一個總結:
委託是一個類,它定義了方法的類型,使得可以將方法當作另一個方法的參數來進行傳遞,這種將方法動態地賦給參數的做法,可以避免在程序中大量使用If-Else(Switch)語句,同時使得程序具有更好的可擴展性。
將方法綁定到委託看到這裏,是不是有那麼點如夢初醒的感覺?於是,你是不是在想:在上面的例子中,我不一定要直接在GreetPeople()方法中給 name參數賦值,我可以像這樣使用變量:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
|
static void
Main( string []
args) {
string name1,
name2;
name1
= "sufei" ;
name2
= "蘇飛" ;
GreetPeople(name1,
EnglishGreeting);
GreetPeople(name2,
ChineseGreeting);
Console.ReadKey();
}
|
而既然委託GreetingDelegate 和 類型 string 的地位一樣,都是定義了一種參數類型,那麼,我是不是也可以這麼使用委託?
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
|
static void
Main( string []
args) {
GreetingDelegate
delegate1, delegate2;
delegate1
= EnglishGreeting;
delegate2
= ChineseGreeting;
GreetPeople( "sufei" ,
delegate1);
GreetPeople( "蘇飛" ,
delegate2);
Console.ReadKey();
}
|
如你所料,這樣是沒有問題的,程序一如預料的那樣輸出。這裏,我想說的是委託不同於string的一個特性:可以將多個方法賦給同一個委託,或者叫將多個方法綁定到同一個委託,當調用這個委託的時候,將依次調用其所綁定的方法。在這個例子中,語法如下:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
|
static void
Main( string []
args) {
GreetingDelegate
delegate1;
delegate1
= EnglishGreeting;
delegate1
+= ChineseGreeting;
GreetPeople( "sufei" ,
delegate1);
Console.ReadKey();
}
|
輸出爲:
Morning, sufei
早上好, sufei
實際上,我們可以也可以繞過GreetPeople方法,通過委託來直接調用EnglishGreeting和ChineseGreeting:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
|
static void
Main( string []
args) {
GreetingDelegate
delegate1;
delegate1
= EnglishGreeting;
delegate1
+= ChineseGreeting;
delegate1
( "sufei" );
Console.ReadKey();
}
|
NOTE:這在本例中是沒有問題的,但回頭看下上面GreetPeople()的定義,在它之中可以做一些對於EnglshihGreeting和ChineseGreeting來說都需要進行的工作,爲了簡便我做了省略。
注意這裏,第一次用的“=”,是賦值的語法;第二次,用的是“+=”,是綁定的語法。如果第一次就使用“+=”,將出現“使用了未賦值的局部變量”的編譯錯誤。
我們也可以使用下面的代碼來這樣簡化這一過程:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
|
GreetingDelegate
delegate1 = new GreetingDelegate(EnglishGreeting);
delegate1
+= ChineseGreeting;
看到這裏,應該注意到,這段代碼第一條語句與實例化一個類是何其的相似,你不禁想到:上面第一次綁定委託時不可以使用“+=”的編譯錯誤,或許可以用這樣的方法來避免:
GreetingDelegate
delegate1 = new GreetingDelegate();
delegate1
+= EnglishGreeting;
delegate1
+= ChineseGreeting;
|
但實際上,這樣會出現編譯錯誤: “GreetingDelegate”方法沒有采用“0”個參數的重載。儘管這樣的結果讓我們覺得有點沮喪,但是編譯的提示:“沒有0個參數的重載”再次讓我們聯想到了類的構造函數。我知道你一定按捺不住想探個究竟,但再此之前,我們需要先把基礎知識和應用介紹完。
既然給委託可以綁定一個方法,那麼也應該有辦法取消對方法的綁定,很容易想到,這個語法是“-=”:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
11
12
13
|
static void
Main( string []
args) {
GreetingDelegate
delegate1 = new GreetingDelegate(EnglishGreeting);
delegate1
+= ChineseGreeting;
GreetPeople( "sufei" ,
delegate1);
Console.WriteLine();
delegate1
-= EnglishGreeting;
GreetPeople( "蘇飛" ,
delegate1);
Console.ReadKey();
}
|
輸出爲:
Morning, sufei
早上好, sufei
早上好, 蘇飛
讓我們再次對委託作個總結:
使用委託可以將多個方法綁定到同一個委託變量,當調用此變量時(這裏用“調用”這個詞,是因爲此變量代表一個方法),可以依次調用所有綁定的方法。
事件的由來我們繼續思考上面的程序:上面的三個方法都定義在Programe類中,這樣做是爲了理解的方便,實際應用中,通常都是 GreetPeople 在一個類中,ChineseGreeting和 EnglishGreeting 在另外的類中。現在你已經對委託有了初步瞭解,是時候對上面的例子做個改進了。假設我們將GreetingPeople()放在一個叫GreetingManager的類中,那麼新程序應該是這個樣子的:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
namespace Delegate
{
public delegate
void
GreetingDelegate( string name);
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);
}
static void
Main( string []
args) {
}
}
}
|
這個時候,如果要實現前面演示的輸出效果,Main方法我想應該是這樣的:
[C#] 純文本查看 複製代碼
01
02
03
04
05
|
static void
Main( string []
args) {
GreetingManager
gm = new GreetingManager();
gm.GreetPeople( "sufei" ,
EnglishGreeting);
gm.GreetPeople( "蘇飛" ,
ChineseGreeting);
}
|
我們運行這段代碼,嗯,沒有任何問題。程序一如預料地那樣輸出了:
Morning, sufei
早上好, 蘇飛
現在,假設我們需要使用上一節學到的知識,將多個方法綁定到同一個委託變量,該如何做呢?讓我們再次改寫代碼:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
|
static void
Main( string []
args) {
GreetingManager
gm = new GreetingManager();
GreetingDelegate
delegate1;
delegate1
= EnglishGreeting;
delegate1
+= ChineseGreeting;
gm.GreetPeople( "sufei" ,
delegate1);
}
|
輸出:
Morning, sufei
早上好, sufei
到了這裏,我們不禁想到:面向對象設計,講究的是對象的封裝,既然可以聲明委託類型的變量(在上例中是delegate1),我們何不將這個變量封裝到 GreetManager類中?在這個類的客戶端中使用不是更方便麼?於是,我們改寫GreetManager類,像這樣:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
|
public class
GreetingManager{
public GreetingDelegate
delegate1;
public void
GreetPeople( string name,
GreetingDelegate MakeGreeting) {
MakeGreeting(name);
}
}
|
現在,我們可以這樣使用這個委託變量:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
|
static void
Main( string []
args) {
GreetingManager
gm = new GreetingManager();
gm.delegate1
= EnglishGreeting;
gm.delegate1
+= ChineseGreeting;
gm.GreetPeople( "sufei" ,
gm.delegate1);
}
|
輸出爲:
Morning, sufei
早上好, sufei
儘管這樣做沒有任何問題,但我們發現這條語句很奇怪。在調用gm.GreetPeople方法的時候,再次傳遞了gm的delegate1字段:
gm.GreetPeople("sufei", gm.delegate1);
既然如此,我們何不修改 GreetingManager 類成這樣:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
|
public class
GreetingManager{
public GreetingDelegate
delegate1;
public void
GreetPeople( string name)
{
if (delegate1!= null ){
delegate1(name);
}
}
}
|
在客戶端,調用看上去更簡潔一些:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
|
static void
Main( string []
args) {
GreetingManager
gm = new GreetingManager();
gm.delegate1
= EnglishGreeting;
gm.delegate1
+= ChineseGreeting;
gm.GreetPeople( "sufei" );
}
|
輸出爲:
Morning, sufei
早上好, sufei
儘管這樣達到了我們要的效果,但是還是存在着問題:
在這裏,delegate1和我們平時用的string類型的變量沒有什麼分別,而我們知道,並不是所有的字段都應該聲明成public,合適的做法是應該public的時候public,應該private的時候private。
我們先看看如果把 delegate1 聲明爲 private會怎樣?結果就是:這簡直就是在搞笑。因爲聲明委託的目的就是爲了把它暴露在類的客戶端進行方法的註冊,你把它聲明爲private了,客戶端對它根本就不可見,那它還有什麼用?
再看看把delegate1 聲明爲 public 會怎樣?結果就是:在客戶端可以對它進行隨意的賦值等操作,嚴重破壞對象的封裝性。
最後,第一個方法註冊用“=”,是賦值語法,因爲要進行實例化,第二個方法註冊則用的是“+=”。但是,不管是賦值還是註冊,都是將方法綁定到委託上,除了調用時先後順序不同,再沒有任何的分別,這樣不是讓人覺得很彆扭麼?
現在我們想想,如果delegate1不是一個委託類型,而是一個string類型,你會怎麼做?答案是使用屬性對字段進行封裝。
於是,Event出場了,它封裝了委託類型的變量,使得:在類的內部,不管你聲明它是public還是protected,它總是private的。在類的外部,註冊“+=”和註銷“-=”的訪問限定符與你在聲明事件時使用的訪問符相同。
我們改寫GreetingManager類,它變成了這個樣子:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
|
public class
GreetingManager{
public event
GreetingDelegate MakeGreet;
public void
GreetPeople( string name)
{
MakeGreet(name);
}
}
|
很容易注意到:MakeGreet 事件的聲明與之前委託變量delegate1的聲明唯一的區別是多了一個event關鍵字。看到這裏,在結合上面的講解,你應該明白到:事件其實沒什麼不好理解的,聲明一個事件不過類似於聲明一個進行了封裝的委託類型的變量而已。
爲了證明上面的推論,如果我們像下面這樣改寫Main方法:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
|
static void
Main( string []
args) {
GreetingManager
gm = new GreetingManager();
gm.MakeGreet
= EnglishGreeting;
gm.MakeGreet
+= ChineseGreeting;
gm.GreetPeople( "sufei" );
}
|
會得到編譯錯誤:事件“Delegate.GreetingManager.MakeGreet”只能出現在 += 或 -= 的左邊(從類型“Delegate.GreetingManager”中使用時除外)。
事件和委託的編譯代碼這時候,我們註釋掉編譯錯誤的行,然後重新進行編譯,再借助Reflactor來對 event的聲明語句做一探究,看看爲什麼會發生這樣的錯誤:
public event GreetingDelegate MakeGreet;
可以看到,實際上儘管我們在GreetingManager裏將 MakeGreet 聲明爲public,但是,實際上MakeGreet會被編譯成 私有字段,難怪會發生上面的編譯錯誤了,因爲它根本就不允許在GreetingManager類的外面以賦值的方式訪問,從而驗證了我們上面所做的推論。
我們再進一步看下MakeGreet所產生的代碼:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
11
|
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);
當編譯器遇到這段代碼的時候,會生成下面這樣一個完整的類:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
|
public sealed
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()。
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
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();
}
}
}
|
Observer設計模式簡介上面的例子顯然能完成我們之前描述的工作,但是卻並不夠好。現在假設熱水器由三部分組成:熱水器、警報器、顯示器,它們來自於不同廠商並進行了組裝。那麼,應該是熱水器僅僅負責燒水,它不能發出警報也不能顯示水溫;在水燒開時由警報器發出警報、顯示器顯示提示和水溫。
這時候,上面的例子就應該變成這個樣子:
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
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設計模式中主要包括如下兩類對象:
-
Subject:監視對象,它往往包含着其他對象所感興趣的內容。在本範例中,熱水器就是一個監視對象,它包含的其他對象所感興趣的內容,就是temprature字段,當這個字段的值快到100時,會不斷把數據發給監視它的對象。
-
Observer:監視者,它監視Subject,當Subject中的某件事發生的時候,會告知Observer,而Observer則會採取相應的行動。在本範例中,Observer有警報器和顯示器,它們採取的行動分別是發出警報和顯示水溫。
在本例中,事情發生的順序應該是這樣的:
-
警報器和顯示器告訴熱水器,它對它的溫度比較感興趣(註冊)。
-
熱水器知道後保留對警報器和顯示器的引用。
-
熱水器進行燒水這一動作,當水溫超過95度時,通過對警報器和顯示器的引用,自動調用警報器的MakeAlert()方法、顯示器的ShowMsg()方法。
類似這樣的例子是很多的,GOF對它進行了抽象,稱爲Observer設計模式:Observer設計模式是爲了定義對象間的一種一對多的依賴關係,以便於當一個對象的狀態改變時,其他依賴於它的對象會被自動告知並更新。Observer模式是一種鬆耦合的設計模式。
實現範例的Observer設計模式我們之前已經對委託和事件介紹很多了,現在寫代碼應該很容易了,現在在這裏直接給出代碼,並在註釋中加以說明。
[C#] 純文本查看 複製代碼
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
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;
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 度了:
Alarm:嘀嘀嘀,水已經 96 度了:
Display:水快燒開了,當前溫度:96度。
// 省略...
.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, BoiledEventArgs e);
public
event
BoiledEventHandler Boiled;
public
class
BoiledEventArgs : EventArgs {
public
readonly
int
temperature;
public
BoiledEventArgs( int
temperature) {
this .temperature
= temperature;
}
}
protected
virtual
void
OnBoiled(BoiledEventArgs e) {
if
(Boiled != null )
{
Boiled( this ,
e);
}
}
public
void
BoilWater() {
for
( int
i = 0; i <= 100; i++) {
temperature
= i;
if
(temperature > 95) {
BoiledEventArgs
e = new
BoiledEventArgs(temperature);
OnBoiled(e);
}
}
}
}
public
class
Alarm {
public
void
MakeAlert(Object sender, Heater.BoiledEventArgs e) {
Heater
heater = (Heater)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.BoiledEventArgs 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();
}
}
}
個人小結:
http://www.tracefact.net/CSharp-Programming/Delegates-and-Events-in-CSharp.aspx |