將方法作為方法的參數
我們先不管這個標題如何的繞口也不管委托究竟是個什麼東西來看下面這兩個最簡單的方法它們不過是在屏幕上輸出一句問候的話語
public void GreetPeople(string name) {
// 做某些額外的事情比如初始化之類此處略
EnglishGreeting(name);
}
public void EnglishGreeting(string name) {
ConsoleWriteLine(Morning + name);
}
暫且不管這兩個方法有沒有什麼實際意義GreetPeople用於向某人問好當我們傳遞代表某人姓名的name參數比如說Jimmy進去的時候在這個方法中將調用EnglishGreeting方法再次傳遞name參數EnglishGreeting則用於向屏幕輸出 Morning Jimmy
現在假設這個程序需要進行全球化哎呀不好了我是中國人我不明白Morning是什麼意思怎麼辦呢？好吧我們再加個中文版的問候方法
public void ChineseGreeting(string name){
ConsoleWriteLine(早上好 + name);
}
這時候GreetPeople也需要改一改了不然如何判斷到底用哪個版本的Greeting問候方法合適呢？在進行這個之前我們最好再定義一個枚舉作為判斷的依據
public enum Language{
English Chinese
}
public void GreetPeople(string name Language lang){
//做某些額外的事情比如初始化之類此處略
swith(lang){
case LanguageEnglish:
EnglishGreeting(name);
break;
case LanguageChinese:
ChineseGreeting(name);
break;
}
}
OK盡管這樣解決了問題但我不說大家也很容易想到這個解決方案的可擴展性很差如果日後我們需要再添加韓文版日文版就不得不反復修改枚舉和GreetPeople()方法以適應新的需求
在考慮新的解決方案之前我們先看看 GreetPeople的方法簽名
public void GreetPeople(string name Language lang)
我們僅看 string name在這裡string 是參數類型name 是參數變量當我們賦給name字符串jimmy時它就代表jimmy這個值當我們賦給它張子陽時它又代表著張子陽這個值然後我們可以在方法體內對這個name進行其他操作哎這簡直是廢話麼剛學程序就知道了
如果你再仔細想想假如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和但不能接受bool類型的true和int類型的一樣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是一個類所以在任何可以聲明類的地方都可以聲明委托更多的內容將在下面講述現在請看看這個范例的完整代碼
using System;
using SystemCollectionsGeneric;
using SystemText;
namespace Delegate {
//定義委托它定義了可以代表的方法的類型
public delegate void GreetingDelegate(string name);
class Program {
private static void EnglishGreeting(string name) {
ConsoleWriteLine(Morning + name);
}
private static void ChineseGreeting(string name) {
ConsoleWriteLine(早上好 + name);
}
//注意此方法它接受一個GreetingDelegate類型的方法作為參數
private static void GreetPeople(string name GreetingDelegate MakeGreeting) {
MakeGreeting(name);
}
static void Main(string[] args) {
GreetPeople(Jimmy Zhang EnglishGreeting);
GreetPeople(張子陽 ChineseGreeting);
ConsoleReadKey();
}
}
}
輸出如下
Morning Jimmy Zhang
早上好 張子陽
我們現在對委托做一個總結
委托是一個類它定義了方法的類型使得可以將方法當作另一個方法的參數來進行傳遞這種將方法動態地賦給參數的做法可以避免在程序中大量使用IfElse(Switch)語句同時使得程序具有更好的可擴展性
將方法綁定到委托
看到這裡是不是有那麼點如夢初醒的感覺？於是你是不是在想在上面的例子中我不一定要直接在GreetPeople()方法中給 name參數賦值我可以像這樣使用變量
static void Main(string[] args) {
string name name;
name = Jimmy Zhang;
name = 張子陽;
GreetPeople(name EnglishGreeting);
GreetPeople(name ChineseGreeting);
ConsoleReadKey();
}
而既然委托GreetingDelegate 和 類型 string 的地位一樣都是定義了一種參數類型那麼我是不是也可以這麼使用委托？
static void Main(string[] args) {
GreetingDelegate delegate delegate;
delegate = EnglishGreeting;
delegate = ChineseGreeting;
GreetPeople(Jimmy Zhang delegate);
GreetPeople(張子陽 delegate);
ConsoleReadKey();
}
如你所料這樣是沒有問題的程序一如預料的那樣輸出這裡我想說的是委托不同於string的一個特性可以將多個方法賦給同一個委托或者叫將多個方法綁定到同一個委托當調用這個委托的時候將依次調用其所綁定的方法在這個例子中語法如下
static void Main(string[] args) {
GreetingDelegate delegate;
delegate = EnglishGreeting; // 先給委托類型的變量賦值
delegate += ChineseGreeting; // 給此委托變量再綁定一個方法
// 將先後調用 EnglishGreeting 與 ChineseGreeting 方法
GreetPeople(Jimmy Zhang delegate);
ConsoleReadKey();
}
輸出為
Morning Jimmy Zhang
早上好 Jimmy Zhang
實際上我們可以也可以繞過GreetPeople方法通過委托來直接調用EnglishGreeting和ChineseGreeting
static void Main(string[] args) {
GreetingDelegate delegate;
delegate = EnglishGreeting; // 先給委托類型的變量賦值
delegate += ChineseGreeting; // 給此委托變量再綁定一個方法
// 將先後調用 EnglishGreeting 與 ChineseGreeting 方法
delegate (Jimmy Zhang);
ConsoleReadKey();
}
NOTE這在本例中是沒有問題的但回頭看下上面GreetPeople()的定義在它之中可以做一些對於EnglshihGreeting和ChineseGreeting來說都需要進行的工作為了簡便我做了省略
注意這裡第一次用的=是賦值的語法第二次用的是+=是綁定的語法如果第一次就使用+=將出現使用了未賦值的局部變量的編譯錯誤
我們也可以使用下面的代碼來這樣簡化這一過程
GreetingDelegate delegate = new GreetingDelegate(EnglishGreeting);
delegate += ChineseGreeting; // 給此委托變量再綁定一個方法
看到這裡應該注意到這段代碼第一條語句與實例化一個類是何其的相似你不禁想到上面第一次綁定委托時不可以使用+=的編譯錯誤或許可以用這樣的方法來避免
GreetingDelegate delegate = new GreetingDelegate();
delegate += EnglishGreeting; // 這次用的是 +=綁定語法
delegate += ChineseGreeting; // 給此委托變量再綁定一個方法
但實際上這樣會出現編譯錯誤 GreetingDelegate方法沒有采用個參數的重載盡管這樣的結果讓我們覺得有點沮喪但是編譯的提示沒有個參數的重載再次讓我們聯想到了類的構造函數我知道你一定按捺不住想探個究竟但再此之前我們需要先把基礎知識和應用介紹完
既然給委托可以綁定一個方法那麼也應該有辦法取消對方法的綁定很容易想到這個語法是=
static void Main(string[] args) {
GreetingDelegate delegate = new GreetingDelegate(EnglishGreeting);
delegate += ChineseGreeting; // 給此委托變量再綁定一個方法
// 將先後調用 EnglishGreeting 與 ChineseGreeting 方法
GreetPeople(Jimmy Zhang delegate);
ConsoleWriteLine();
delegate = EnglishGreeting; //取消對EnglishGreeting方法的綁定
// 將僅調用 ChineseGreeting
GreetPeople(張子陽 delegate);
ConsoleReadKey();
}
輸出為
Morning Jimmy Zhang
早上好 Jimmy Zhang
早上好 張子陽
讓我們再次對委托作個總結
使用委托可以將多個方法綁定到同一個委托變量當調用此變量時(這裡用調用這個詞是因為此變量代表一個方法)可以依次調用所有綁定的方法
事件的由來
我們繼續思考上面的程序上面的三個方法都定義在Programe類中這樣做是為了理解的方便實際應用中通常都是 GreetPeople 在一個類中ChineseGreeting和 EnglishGreeting 在另外的類中現在你已經對委托有了初步了解是時候對上面的例子做個改進了假設我們將GreetingPeople()放在一個叫GreetingManager的類中那麼新程序應該是這個樣子的
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) {
ConsoleWriteLine(Morning + name);
}
private static void ChineseGreeting(string name) {
ConsoleWriteLine(早上好 + name);
}
static void Main(string[] args) {
//
}
}
}
這個時候如果要實現前面演示的輸出效果Main方法我想應該是這樣的
static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gmGreetPeople(Jimmy Zhang EnglishGreeting);
gmGreetPeople(張子陽 ChineseGreeting);
}
我們運行這段代碼嗯沒有任何問題程序一如預料地那樣輸出了
Morning Jimmy Zhang
早上好 張子陽
現在假設我們需要使用上一節學到的知識將多個方法綁定到同一個委托變量該如何做呢？讓我們再次改寫代碼
static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
GreetingDelegate delegate;
delegate = EnglishGreeting;
delegate += ChineseGreeting;
gmGreetPeople(Jimmy Zhang delegate);
}
輸出
Morning Jimmy Zhang
早上好 Jimmy Zhang
到了這裡我們不禁想到面向對象設計講究的是對象的封裝既然可以聲明委托類型的變量(在上例中是delegate)我們何不將這個變量封裝到 GreetManager類中？在這個類的客戶端中使用不是更方便麼？於是我們改寫GreetManager類像這樣
public class GreetingManager{
//在GreetingManager類的內部聲明delegate變量
public GreetingDelegate delegate;
public void GreetPeople(string name GreetingDelegate MakeGreeting) {
MakeGreeting(name);
}
}
現在我們可以這樣使用這個委托變量
static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gmdelegate = EnglishGreeting;
gmdelegate += ChineseGreeting;
gmGreetPeople(Jimmy Zhang gmdelegate);
}
輸出為
Morning Jimmy Zhang
早上好 Jimmy Zhang
盡管這樣做沒有任何問題但我們發現這條語句很奇怪在調用gmGreetPeople方法的時候再次傳遞了gm的delegate字段
gmGreetPeople(Jimmy Zhang gmdelegate);
既然如此我們何不修改 GreetingManager 類成這樣
public class GreetingManager{
//在GreetingManager類的內部聲明delegate變量
public GreetingDelegate delegate;
public void GreetPeople(string name) {
if(delegate!=null){ //如果有方法注冊委托變量
delegate(name); //通過委托調用方法
}
}
}
在客戶端調用看上去更簡潔一些
static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gmdelegate = EnglishGreeting;
gmdelegate += ChineseGreeting;
gmGreetPeople(Jimmy Zhang); //注意這次不需要再傳遞 delegate變量
}
輸出為
Morning Jimmy Zhang
早上好 Jimmy Zhang
盡管這樣達到了我們要的效果但是還是存在著問題
在這裡delegate和我們平時用的string類型的變量沒有什麼分別而我們知道並不是所有的字段都應該聲明成public合適的做法是應該public的時候public應該private的時候private
我們先看看如果把 delegate 聲明為 private會怎樣？結果就是這簡直就是在搞笑因為聲明委托的目的就是為了把它暴露在類的客戶端進行方法的注冊你把它聲明為private了客戶端對它根本就不可見那它還有什麼用？
再看看把delegate 聲明為 public 會怎樣？結果就是在客戶端可以對它進行隨意的賦值等操作嚴重破壞對象的封裝性
最後第一個方法注冊用=是賦值語法因為要進行實例化第二個方法注冊則用的是+=但是不管是賦值還是注冊都是將方法綁定到委托上除了調用時先後順序不同再沒有任何的分別這樣不是讓人覺得很別扭麼？
現在我們想想如果delegate不是一個委托類型而是一個string類型你會怎麼做？答案是使用屬性對字段進行封裝
於是Event出場了它封裝了委托類型的變量使得在類的內部不管你聲明它是public還是protected它總是private的在類的外部注冊+=和注銷=的訪問限定符與你在聲明事件時使用的訪問符相同
我們改寫GreetingManager類它變成了這個樣子
public class GreetingManager{
//這一次我們在這裡聲明一個事件
public event GreetingDelegate MakeGreet;
public void GreetPeople(string name) {
MakeGreet(name);
}
}
很容易注意到MakeGreet 事件的聲明與之前委托變量delegate的聲明唯一的區別是多了一個event關鍵字看到這裡在結合上面的講解你應該明白到事件其實沒什麼不好理解的聲明一個事件不過類似於聲明一個進行了封裝的委托類型的變量而已
為了證明上面的推論如果我們像下面這樣改寫Main方法
static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gmMakeGreet = EnglishGreeting; // 編譯錯誤
gmMakeGreet += ChineseGreeting;
gmGreetPeople(Jimmy Zhang);
}
會得到編譯錯誤事件DelegateGreetingManagerMakeGreet只能出現在 += 或 = 的左邊(從類型DelegateGreetingManager中使用時除外)
事件和委托的編譯代碼
這時候我們注釋掉編譯錯誤的行然後重新進行編譯再借助Reflactor來對 event的聲明語句做一探究看看為什麼會發生這樣的錯誤
public event GreetingDelegate MakeGreet;
可以看到實際上盡管我們在GreetingManager裡將 MakeGreet 聲明為public但是實際上MakeGreet會被編譯成私有字段難怪會發生上面的編譯錯誤了因為它根本就不允許在GreetingManager類的外面以賦值的方式訪問從而驗證了我們上面所做的推論
我們再進一步看下MakeGreet所產生的代碼
private GreetingDelegate MakeGreet; //對事件的聲明 實際是 聲明一個私有的委托變量
[MethodImpl(MethodImplOptionsSynchronized)]
public void add_MakeGreet(GreetingDelegate value){
thisMakeGreet = (GreetingDelegate) DelegateCombine(thisMakeGreet value);
}
[MethodImpl(MethodImplOptionsSynchronized)]
public void remove_MakeGreet(GreetingDelegate value){
thisMakeGreet = (GreetingDelegate) DelegateRemove(thisMakeGreet value);
}
現在已經很明確了MakeGreet事件確實是一個GreetingDelegate類型的委托只不過不管是不是聲明為public它總是被聲明為private另外它還有兩個方法分別是add_MakeGreet和remove_MakeGreet這兩個方法分別用於注冊委托類型的方法和取消注冊實際上也就是 += 對應 add_MakeGreet=對應remove_MakeGreet而這兩個方法的訪問限制取決於聲明事件時的訪問限制符
在add_MakeGreet()方法內部實際上調用了SystemDelegate的Combine()靜態方法這個方法用於將當前的變量添加到委托鏈表中我們前面提到過兩次說委托實際上是一個類在我們定義委托的時候
public delegate void GreetingDelegate(string name);
當編譯器遇到這段代碼的時候會生成下面這樣一個完整的類
public sealed class GreetingDelegate:SystemMulticastDelegate{
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設計模式
范例說明
上面的例子已不足以再進行下面的講解了我們來看一個新的范例因為之前已經介紹了很多的內容所以本節的進度會稍微快一些
假設我們有個高檔的熱水器我們給它通上電當水溫超過度的時候揚聲器會開始發出語音告訴你水的溫度液晶屏也會改變水溫的顯示來提示水已經快燒開了
現在我們需要寫個程序來模擬這個燒水的過程我們將定義一個類來代表熱水器我們管它叫Heater它有代表水溫的字段叫做temperature當然還有必不可少的給水加熱方法BoilWater()一個發出語音警報的方法MakeAlert()一個顯示水溫的方法ShowMsg()
namespace Delegate {
class Heater {
private int temperature; // 水溫
// 燒水
public void BoilWater() {
for (int i = ; i <= ; i++) {
temperature = i;
if (temperature > ) {
MakeAlert(temperature);
ShowMsg(temperature);
}
}
}
// 發出語音警報
private void MakeAlert(int param) {
ConsoleWriteLine(Alarm嘀嘀嘀水已經 {} 度了 param);
}
// 顯示水溫
private void ShowMsg(int param) {
ConsoleWriteLine(Display水快開了當前溫度{}度 param);
}
}
class Program {
static void Main() {
Heater ht = new Heater();
htBoilWater();
}
}
}
Observer設計模式簡介
上面的例子顯然能完成我們之前描述的工作但是卻並不夠好現在假設熱水器由三部分組成熱水器警報器顯示器它們來自於不同廠商並進行了組裝那麼應該是熱水器僅僅負責燒水它不能發出警報也不能顯示水溫在水燒開時由警報器發出警報顯示器顯示提示和水溫
這時候上面的例子就應該變成這個樣子
// 熱水器
public class Heater {
private int temperature;
// 燒水
private void BoilWater() {
for (int i = ; i <= ; i++) {
temperature = i;
}
}
}
// 警報器
public class Alarm{
private void MakeAlert(int param) {
ConsoleWriteLine(Alarm嘀嘀嘀水已經 {} 度了 param);
}
}
// 顯示器
public class Display{
private void ShowMsg(int param) {
ConsoleWriteLine(Display水已燒開當前溫度{}度 param);
}
}
這裡就出現了一個問題如何在水燒開的時候通知報警器和顯示器？在繼續進行之前我們先了解一下Observer設計模式Observer設計模式中主要包括如下兩類對象
Subject監視對象它往往包含著其他對象所感興趣的內容在本范例中熱水器就是一個監視對象它包含的其他對象所感興趣的內容就是temprature字段當這個字段的值快到時會不斷把數據發給監視它的對象
Observer監視者它監視Subject當Subject中的某件事發生的時候會告知Observer而Observer則會采取相應的行動在本范例中Observer有警報器和顯示器它們采取的行動分別是發出警報和顯示水溫
在本例中事情發生的順序應該是這樣的
警報器和顯示器告訴熱水器它對它的溫度比較感興趣(注冊)
熱水器進行燒水這一動作當水溫超過度時通過對警報器和顯示器的引用自動調用警報器的MakeAlert()方法顯示器的ShowMsg()方法
熱水器知道後保留對警報器和顯示器的引用
類似這樣的例子是很多的GOF對它進行了抽象稱為Observer設計模式Observer設計模式是為了定義對象間的一種一對多的依賴關系以便於當一個對象的狀態改變時其他依賴於它的對象會被自動告知並更新Observer模式是一種松耦合的設計模式
實現范例的Observer設計模式
我們之前已經對委托和事件介紹很多了現在寫代碼應該很容易了現在在這裡直接給出代碼並在注釋中加以說明
using System;
using SystemCollectionsGeneric;
using SystemText;
namespace Delegate {
// 熱水器
public class Heater {
private int temperature;
public delegate void BoilHandler(int param); //聲明委托
public event BoilHandler BoilEvent; //聲明事件
// 燒水
public void BoilWater() {
for (int i = ; i <= ; i++) {
temperature = i;
if (temperature > ) {
if (BoilEvent != null) { //如果有對象注冊
BoilEvent(temperature); //調用所有注冊對象的方法
}
}
}
}
}
// 警報器
public class Alarm {
public void MakeAlert(int param) {
ConsoleWriteLine(Alarm嘀嘀嘀水已經 {} 度了 param);
}
}
// 顯示器
public class Display {
public static void ShowMsg(int param) { //靜態方法
ConsoleWriteLine(Display水快燒開了當前溫度{}度 param);
}
}
class Program {
static void Main() {
Heater heater = new Heater();
Alarm alarm = new Alarm();
heaterBoilEvent += alarmMakeAlert; //注冊方法
heaterBoilEvent += (new Alarm())MakeAlert; //給匿名對象注冊方法
heaterBoilEvent += DisplayShowMsg; //注冊靜態方法
heaterBoilWater(); //燒水會自動調用注冊過對象的方法
}
}
}
輸出為
Alarm嘀嘀嘀水已經 度了
Alarm嘀嘀嘀水已經 度了
Display水快燒開了當前溫度度
// 省略
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 SystemCollectionsGeneric;
using SystemText;
namespace Delegate {
// 熱水器
public class Heater {
private int temperature;
public string type = RealFire ; // 添加型號作為演示
public string area = China Xian; // 添加產地作為演示
//聲明委托
public delegate void BoiledEventHandler(Object sender BoiledEventArgs e);
public event BoiledEventHandler Boiled; //聲明事件
// 定義BoiledEventArgs類傳遞給Observer所感興趣的信息
public class BoiledEventArgs : EventArgs {
public readonly int temperature;
public BoiledEventArgs(int temperature) {
thistemperature = temperature;
}
}
// 可以供繼承自 Heater 的類重寫以便繼承類拒絕其他對象對它的監視
protected virtual void OnBoiled(BoiledEventArgs e) {
if (Boiled != null) { // 如果有對象注冊
Boiled(this e); // 調用所有注冊對象的方法
}
}
// 燒水
public void BoilWater() {
for (int i = ; i <= ; i++) {
temperature = i;
if (temperature > ) {
//建立BoiledEventArgs 對象
BoiledEventArgs e = new BoiledEventArgs(temperature);
OnBoiled(e); // 調用 OnBolied方法
}
}
}
}
// 警報器
public class Alarm {
public void MakeAlert(Object sender HeaterBoiledEventArgs e) {
Heater heater = (Heater)sender; //這裡是不是很熟悉呢？
//訪問 sender 中的公共字段
ConsoleWriteLine(Alarm{} {}: heaterarea heatertype);
ConsoleWriteLine(Alarm: 嘀嘀嘀水已經 {} 度了 etemperature);
ConsoleWriteLine();
}
}
// 顯示器
public class Display {
public static void ShowMsg(Object sender HeaterBoiledEventArgs e) { //靜態方法
Heater heater = (Heater)sender;
ConsoleWriteLine(Display{} {}: heaterarea heatertype);
ConsoleWriteLine(Display水快燒開了當前溫度{}度 etemperature);
ConsoleWriteLine();
}
}
class Program {
static void Main() {
Heater heater = new Heater();
Alarm alarm = new Alarm();
heaterBoiled += alarmMakeAlert; //注冊方法
heaterBoiled += (new Alarm())MakeAlert; //給匿名對象注冊方法
heaterBoiled += new HeaterBoiledEventHandler(alarmMakeAlert); //也可以這麼注冊
heaterBoiled += DisplayShowMsg; //注冊靜態方法
heaterBoilWater(); //燒水會自動調用注冊過對象的方法
}
}
}
輸出為
AlarmChina Xian RealFire :
Alarm: 嘀嘀嘀水已經 度了
AlarmChina Xian RealFire :
Alarm: 嘀嘀嘀水已經 度了
AlarmChina Xian RealFire :
Alarm: 嘀嘀嘀水已經 度了
DisplayChina Xian RealFire :
Display水快燒開了當前溫度度
//
From:http://tw.wingwit.com/Article/program/net/201311/12190.html
