委托事件观察者模式资料.doc

委托事件观察者模式资料

———————————————————————————————— 作者：
———————————————————————————————— 日期：

50

个人收集整理 勿做商业用途
认识C#中的委托和事件
引言　ﻫﻫ委托 和 事件在 .Ｎeｔ　Fｒaｍｅwoｒk中的应用非常广泛,然而，较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人,觉得真是太容易了,而没有过去的人每次见到委托和事件就觉得心里别〔bｉè)得慌,混身不自在。本文中，我将通过两个范例由浅入深地讲述什么是委托、为什么要使用委托、事件的由来、.Net Ｆrameｗork中的委托和事件、委托和事件对Ｏbsｅrver设计模式的意义,对它们的中间代码也做了讨论。

将方法作为方法的参数
ﻫ我们先不管这个标题如何的绕口，也不管委托终究是个什么东西，来看下面这两个最简单的方法,它们不过是在屏幕上输出一句问候的话语:　ﻫﻫpuｂlic voiｄ GｒeeｔＰeoｐle〔striｎg　namｅ) ｛　
// 做某些额外的事情,比方初始化之类,此处略 ﻫEngｌｉｓhGrｅeting(ｎamｅ);
}　ﻫpublic voｉd ＥnｇliｓhGｒｅeting(string ｎａｍｅ〕　{
Ｃｏnsｏle．WriteLｉne〔"Mornｉng， ＂　+ namｅ〕; ﻫ｝ ﻫ
暂且不管这两个方法有没有什么实际意义。GreetＰeople用于向某人问好，当我们传递代表某人姓名的nａme参数,比方说“Jimｍy〞,进去的时候，在这个方法中，将调用EｎｇliｓｈGｒeetｉｎg方法,再次传递name参数，EnglｉshGreetinｇ那么用于向屏幕输出 “Morning，　Ｊimmy〞。 ﻫ
现在假设这个程序需要进展全球化,哎呀，不好了,我是中国人，我不明白“Ｍｏrnｉnｇ〞是什么意思,怎么办呢？好吧，我们再加个中文版的问候方法：
ﻫpublic　void ChineseGreetiｎg(ｓtrｉng name){
Console.ＷriteLｉne("早上好，　" + ｎame);
} ﻫ
这时候，GreetPeoplｅ也需要改一改了,不然如何判断到底用哪个版本的Ｇreeting问候方法适宜呢？在进展这个之前,我们最好再定义一个枚举作为判断的依据:
ﻫ
pubｌiｃ enum Lａngｕａge{
Enｇlish， Chinesｅ　ﻫ} ﻫﻫpｕblic　ｖoｉd　GreetＰeople(strinｇ　nａme, Ｌanguａｇe lang){　
//做某些额外的事情,比方初始化之类,此处略
swiｔh(lang){ ﻫcase Langｕage.English:
EnｇlishGrｅeting(ｎamｅ);　ﻫbreak;
caｓe Lanｇｕagｅ.Cｈinese:　
ＣｈiｎeseGrｅｅｔing(name〕; ﻫｂｒeak; ﻫ}
}　

OK，尽管这样解决了问题，但我不说大家也很容易想到，这个解决方案的可扩展性很差，如果日后我们需要再添加韩文版、日文版，就不得不反复修改枚举和ＧrｅeｔPeople(〕方法，以适应新的需求。　

在考虑新的解决方案之前,我们先看看 GreetPeｏple的方法签名： ﻫ
pｕｂlｉｃ ｖoiｄ GｒeeｔPeople(ｓtring ｎａme, Ｌaｎgｕagｅ lａng)

我们仅看 sｔring nａme,在这里，ｓtring 是参数类型,namｅ　是参数变量，当我们赋给naｍｅ字符串“jimmy〞时，它就代表“ｊimmy〞这个值；当我们赋给它“张子阳〞时，它又代表着“张子阳〞这个值。然后,我们可以在方法体内对这个ｎame进展其他操作。哎,这简直是废话么，刚学程序就知道了。 ﻫﻫ如果你再仔细想想，假设GｒeetPeople()方法可以承受一个参数变量，这个变量可以代表另一个方法，当我们给这个变量赋值 EnglisｈGreeting的时候,它代表着 ＥｎglsihGreｅｔing〔) 这个方法;当我们给它赋值ChineseＧｒｅetｉng　的时候，它又代表着ChineseGreetｉng()方法。我们将这个参数变量命名为 ＭaｋeGrｅetiｎg，那么不是可以如同给ｎame赋值时一样，在调用 GreetPｅople()方法的时候,给这个ＭakeGreeting　参数也赋上值么(ChineｓeGｒeｅｔｉng或者EnｇlｓihGreｅting等)?然后,我们在方法体内,也可以像使用别的参数一样使用MakｅGreｅting。但是，由于MａkeGreeｔinｇ代表着一个方法,它的使用方式应该和它被赋的方法(比方ＣhinｅsｅGreeting〕是一样的，比方:

MakeＧｒeｅting(naｍｅ);

好了,有了思路了,我们现在就来改改GreetPeople()方法，那么它应该是这个样子了: ﻫﻫｐｕblｉc vｏid GｒeetＰeoｐle(stｒinｇ nａme， **＊ ＭａkeＧreetiｎｇ){
MａkeGｒeｅｔｉnｇ〔namｅ);
}

注意到　**＊　,这个位置通常放置的应该是参数的类型，但到目前为止,我们仅仅是想到应该有个可以代表方法的参数,并按这个思路去改写GreｅtPeoｐle方法,现在就出现了一个大问题:这个代表着方法的ＭakeＧreｅting参数应该是什么类型的？

ＮOTE：这里已不再需要枚举了,因为在给ＭaｋeGreeting赋值的时候动态地决定使用哪个方法,是ChineｓeＧreeting还是 ＥnｇｌisｈGｒeetiｎg，而在这个两个方法内部,已经对使用“mｏｒning〞还是“早上好〞作了区分。　ﻫﻫ聪明的你应该已经想到了，现在是委托该出场的时候了，但讲述委托之前，我们再看看MａkｅGｒｅｅtｉng参数所能代表的 ＣhｉneｓｅＧrｅetｉnｇ〔)和ＥｎｇｌishGreeｔｉng()方法的签名:
ﻫpublic vｏｉd EｎｇlishGrｅetinｇ〔strinｇ namｅ)　ﻫｐuｂｌｉc ｖｏid ChiｎesｅGreeｔing(strｉnｇ　name〕　
ﻫ如同ｎamｅ可以承受Ｓtring类型的“true〞和“1〞，但不能承受ｂooｌ类型的true和inｔ类型的1一样。MａｋｅＧｒeetiｎg的　参数类型定义 应该能够确定 ＭakｅＧｒeｅtiｎg可以代表的　方法种类，再进一步讲，就是MａｋｅGreeting可以代表的方法　的 参数类型和祷乩嘈汀?bｒ ／>　于是，委托出现了:它定义了MakeGrｅeｔｉng参数所能代表的方法的种类,也就是MａkeGrｅetｉｎg参数的类型。　

NOTＥ：如果上面这句话比拟绕口,我把它翻译成这样:strｉｎg　定义了name参数所能代表的值的种类,也就是ｎａmｅ参数的类型。 ﻫ
本例中委托的定义:　ﻫ
public dｅlegａｔｅ vｏid　GreｅtingＤeleｇate(strinｇ nａmｅ〕;

可以与上面ＥｎgliｓｈGreetinｇ()方法的签名比照一下，除了参加了delegate关键字以外,其余的是不是完全一样？
ﻫ现在,让我们再次改动GreeｔPｅople(〕方法,如下所示:　ﻫ
pｕblｉc voｉd GreeｔＰeople〔stｒinｇ nａｍe， GｒeetiｎgＤｅｌｅgaｔｅ MａkeGreeting){ ﻫMakeGｒeetiｎｇ〔name)；
}
ﻫ如你所见，委托ＧreeｔｉngＤelegate出现的位置与 ｓtrinｇ一样，ｓtrｉng是一个类型,那么GrｅｅtｉnｇDelegate应该也是一个类型，或者叫类(Clａss〕。但是委托的声明方式和类却完全不同，这是怎么一回事?实际上,委托在编译的时候确实会编译成类。因为Ｄｅlegatｅ是一个类，所以在任何可以声明类的地方都可以声明委托。更多的内容将在下面讲述，现在,请看看这个范例的完整代码:　ﻫﻫ
ｕsｉng System;
ｕsｉｎg Systｅｍ.Ｃｏlｌections.Generｉc;
ｕsｉng Sｙstｅｍ．Text;
ﻫnamespaｃe Ｄelegaｔe　{
／/定义委托,它定义了可以代表的方法的类型 ﻫpublic ｄeｌegａte　ｖoid GｒｅetingＤｅlegatｅ(striｎg　ｎame);

cｌass Progｒａｍ　{
ﻫpｒivate ｓｔａｔic voｉd EnｇlishＧreetｉnｇ〔sｔring　ｎame) { ﻫConsolｅ．ＷriteLinｅ("Moｒning, " + name〕;
}　

prｉvatｅ ｓtaｔic　void　ChineseGreetｉng(strinｇ　nａme) ｛ ﻫＣonsoｌｅ.WriteLinｅ("早上好, " + name); ﻫ｝　

//注意此方法，它承受一个GrｅetｉｎgDelｅgａｔe类型的方法作为参数　
priｖａtｅ ｓtatｉc voiｄ GrｅｅtＰｅopｌe(ｓtｒinｇ name, GreetｉngDeleｇaｔe MakeGreeｔinｇ〕　{
MａkeＧreetinｇ(nａｍe); ﻫ} ﻫ
static ｖoid Main(string[] ａrgs) {
GreetPeople("Jｉmmy　Zhang"，　ＥｎgｌishGreetｉng); ﻫＧrｅetPeｏpｌe("张子阳", CｈiｎeseGreｅting);　ﻫCｏnsole.RｅadKｅy〔〕;
}　ﻫ}
} ﻫ
ﻫ输出如下：　
Morning， Jimmy Ｚhａｎg
早上好，　张子阳
ﻫ我们现在对委托做一个总结：　

委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进展传递，这种将方法动态地赋给参数的做法,可以防止在程序中大量使用If-Ｅlｓe〔Ｓｗｉtch)语句，同时使得程序具有更好的可扩展性。　
ﻫ将方法绑定到委托 ﻫ
看到这里，是不是有那么点如梦初醒的感觉？于是，你是不是在想:在上面的例子中,我不一定要直接在ＧreeｔPeoｐlｅ〔)方法中给　name参数赋值，我可以像这样使用变量:

ﻫstaｔic vｏid Mａin(sｔｒｉng[] ａrgs) {
sｔring ｎame1, ｎame2; ﻫｎaｍe1　= "Jｉｍmy Zhａnｇ＂；
nａｍe２ =　"张子阳＂;
ﻫGｒeetPeople(ｎaｍe1， EnｇlishGreｅｔiｎｇ);
GｒeｅｔPeoplｅ〔naｍe２，　CｈineseGreｅtｉng)；　
Cｏnsole．ReadKey();
}　

而既然委托GreeｔingDeｌeｇate　和 类型　string　的地位一样，都是定义了一种参数类型,那么,我是不是也可以这么使用委托？　ﻫ

statｉc void　Ｍain(ｓtｒｉｎｇ[] aｒgs) { ﻫGreｅｔinｇＤelegate delｅｇａtｅ1， ｄeｌｅｇate2; ﻫdelegａte1 =　ＥｎglishＧreeｔing； ﻫdelegaｔe2 = CｈｉneseＧreｅｔinｇ;　
ﻫGrｅetPeople("Jimmy　Zｈang",　ｄelｅgatｅ１);
GｒｅetPeoｐle("张子阳"， ｄelｅgａte2);　ﻫConsolｅ.ReaｄＫey();　
}　
ﻫ如你所料,这样是没有问题的,程序一如预料的那样输出。这里，我想说的是委托不同于strｉng的一个特性:可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法。在这个例子中,语法如下：　ﻫ

statiｃ　voiｄ　Maiｎ〔ｓｔrｉng[] ａrgs) { ﻫGreｅｔingＤeleｇatｅ delｅgate1;
dｅlegatｅ1　= EｎgｌiｓｈＧreetinｇ;　／/ 先给委托类型的变量赋值　
ｄeｌegatｅ1 +=　CｈineseＧreetiｎg;　／/ 给此委托变量再绑定一个方法　

/／ 将先后调用 EｎglｉsｈGreetｉｎg 与 ＣｈineseGreetｉng 方法 ﻫＧreetＰeoｐle("Jｉmmｙ Zhang＂,　delegatｅ1); ﻫConｓｏle.ＲeadKey〔〕;
}
ﻫ输出为: ﻫMorning, Jimｍy Zｈang
早上好, Ｊimmｙ Ｚｈaｎg　ﻫ
实际上,我们可以也可以绕过ＧreeｔＰｅopｌe方法,通过委托来直接调用ＥｎｇlishＧreｅtｉｎg和CｈinｅsｅGｒeeｔｉｎg：
ﻫﻫｓtatic void　Main(ｓtring[] aｒgs) { ﻫGreetinｇDelｅｇａte dｅlegate1； ﻫdelegate１ = EｎgliｓhＧreeting; /／ 先给委托类型的变量赋值 ﻫdelegaｔe1 +=　ChineseＧreetiｎg; // 给此委托变量再绑定一个方法 ﻫﻫ// 将先后调用 ＥngｌiｓhＧｒｅeｔing 与 ChineｓｅＧｒeeｔｉnｇ 方法　
dｅlegaｔｅ1 ("Ｊimmy Zｈanｇ＂);
Coｎsoｌe．ReaｄKey〔)； ﻫ}　ﻫﻫNOＴE:这在本例中是没有问题的,但回头看下上面ＧrｅetPｅｏple〔)的定义，在它之中可以做一些对于EnglｓhihGrｅｅtｉng和ChineseGrｅeting来说都需要进展的工作，为了简便我做了省略。　
ﻫ注意这里，第一次用的“=〞,是赋值的语法;第二次,用的是“+=〞,是绑定的语法。如果第一次就使用“＋=〞,将出现“使用了未赋值的局部变量〞的编译错误。 ﻫﻫ我们也可以使用下面的代码来这样简化这一过程：　ﻫ
GｒｅetiｎgDｅlegaｔe ｄｅlegate1 =　new GｒeetingDeｌｅｇaｔe(EnｇlishGｒeeting); ﻫｄeleｇate1 += ＣhineｓeGreeting； // 给此委托变量再绑定一个方法　

看到这里，应该注意到,这段代码第一条语句与实例化一个类是何其的相似,你不禁想到：上面第一次绑定委托时不可以使用“＋=〞的编译错误，或许可以用这样的方法来防止：　
ﻫGreetingDｅleｇate deｌegａte１ = new GreeｔingDelｅgatｅ(); ﻫdelegaｔe1 += EnglisｈGrｅetinｇ； ／/　这次用的是 “+=〞,绑定语法。 ﻫdelegａｔe１　＋=　ChineseＧreｅting； //　给此委托变量再绑定一个方法

但实际上，这样会出现编译错误：　“GｒeetｉngDｅleｇａte〞方法没有采用“0〞个参数的重载。尽管这样的结果让我们觉得有点沮丧，但是编译的提示:“没有０个参数的重载〞再次让我们联想到了类的构造函数。我知道你一定按捺不住想探个终究，但再此之前,我们需要先把根底知识和应用介绍完。 ﻫﻫ既然给委托可以绑定一个方法,那么也应该有方法取消对方法的绑定,很容易想到,这个语法是“-=〞:　ﻫﻫ
ｓtatiｃ ｖoid　Main(string[] aｒgｓ)　｛
ＧreetingDｅlｅｇate delegate1　= new GreetingDelegａtｅ(ＥnglishGreeｔing〕;
delegaｔｅ1　+= ChineｓeGreeｔinｇ； // 给此委托变量再绑定一个方法 ﻫﻫ// 将先后调用 EngｌishGreｅｔinｇ 与 ChineseGｒｅeting　方法　
GreetＰeople〔"Jiｍｍy Zhaｎg", delｅｇate１);
Console．ＷriteLinｅ();

ｄｅｌegaｔe1 -= ＥnglishGｒeetiｎg;　//取消对EngｌishGｒeｅtinｇ方法的绑定　ﻫ/／ 将仅调用 CｈineseGreeting ﻫGｒeetＰeopｌe("张子阳＂, deｌｅｇate1);
Console.ＲeaｄKey();
}

输出为：
Ｍｏrninｇ, Jｉmmy Zhang ﻫ早上好, Jimmy Ｚhang ﻫﻫ早上好, 张子阳
ﻫ让我们再次对委托作个总结: ﻫﻫ使用委托可以将多个方法绑定到同一个委托变量,当调用此变量时(这里用“调用〞这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。　

事件的由来　ﻫﻫ我们继续思考上面的程序:上面的三个方法都定义在Pｒograme类中,这样做是为了理解的方便，实际应用中，通常都是　ＧｒeeｔPeｏple 在一个类中,ChｉneｓeＧreetiｎg和 EnglisｈＧreeting 在另外的类中。现在你已经对委托有了初步了解,是时候对上面的例子做个改良了。假设我们将GrｅetingPeopｌe〔)放在一个叫GreeｔingManager的类中,那么新程序应该是这个样子的： ﻫ

namespace Delegate ｛ ﻫ//定义委托，它定义了可以代表的方法的类型 ﻫpuｂｌiｃ　ｄｅｌeｇａｔe vｏid　ＧreetingDeｌegaｔｅ(striｎg namｅ);　ﻫ
／/新建的GreetinｇManaｇeｒ类
ｐuｂlic　clａss ＧｒeeｔｉngMaｎager{ ﻫpubｌｉc void GreetPeopｌｅ〔string ｎame， GreetingDｅlｅgaｔe ＭakeＧｒeetiｎg)　{ ﻫMakｅGreeting(name)； ﻫ} ﻫ｝
ﻫclasｓ Progｒａm {　ﻫprivaｔe　staｔic voｉｄ EｎglishGreetiｎｇ(ｓtrｉng　naｍe) ｛ ﻫCｏｎsole.WrｉｔeLine〔"Moｒnｉng，　"　+ name); ﻫ｝　ﻫﻫpriｖａte static　void ChｉｎeseGrｅeting(striｎg　nａｍe) ｛
Conｓole.WｒiteＬine(＂早上好,　"　+ nａme);　ﻫ｝ ﻫﻫstatic vｏiｄ Maiｎ(strinｇ［]　arｇs) {　ﻫ//　.．． .．． ﻫ}　
} ﻫ｝
ﻫ
这个时候,如果要实现前面演示的输出效果，Main方法我想应该是这样的:
ﻫstatic voiｄ　Main(ｓtriｎｇ[] args) { ﻫGrｅetingManａger gm　= ｎｅw　GｒeetiｎgManager〔)； ﻫgm．GreｅtPeople("Jｉｍmｙ Zhang", ＥngｌisｈGreｅtｉｎg)； ﻫgm.GrｅｅtＰeople(＂张子阳＂, ChineseGreetｉｎｇ)； ﻫ} ﻫ
我们运行这段代码,嗯，没有任何问题。程序一如预料地那样输出了： ﻫMｏrning, Jiｍｍy　Zhang　
早上好, 张子阳 ﻫﻫ现在,假设我们需要使用上一节学到的知识,将多个方法绑定到同一个委托变量,该如何做呢?让我们再次改写代码：　ﻫ
ﻫｓtatiｃ　void Main(ｓtriｎg[］ args) ｛
GrｅetｉnｇＭａnaｇｅr gm = nｅw GreetinｇManaｇer()； ﻫＧｒeetiｎgDelegatｅ deｌegate1; ﻫdｅleｇaｔｅ1 = ＥnglisｈGｒｅeｔｉng;
ｄeｌegate1 += ChinesｅＧreetｉng;　
ﻫgm．GｒｅｅtPeｏｐle("Jiｍmｙ Zhang＂, ｄeｌeｇate1); ﻫ｝ ﻫ
输出:
Mornｉｎg, Jimmy Ｚｈanｇ ﻫ早上好, Jimmｙ Zhanｇ

到了这里,我们不禁想到：面向对象设计，讲究的是对象的封装,既然可以声明委托类型的变量(在上例中是delegatｅ１)，我们何不将这个变量封装到 GreｅtＭanａger类中?在这个类的客户端中使用不是更方便么？于是，我们改写ＧreetＭanager类,像这样：
ﻫﻫpublic class GrｅetingManａgｅr{
//在ＧrｅｅｔingManageｒ类的内部声明ｄｅleｇatｅ1变量 ﻫpｕbliｃ GｒｅetingDeleｇate　ｄelｅgaｔe1;

pｕblic voｉｄ　GreetＰｅｏple〔sｔrinｇ name,　GｒｅｅｔｉngＤelegatｅ MａkｅGreeting) { ﻫMakeＧrｅｅtiｎg(name〕;
}
} ﻫﻫ现在,我们可以这样使用这个委托变量：
ﻫ
sｔatic voｉd Ｍain〔strｉｎg[] args)　{ ﻫＧｒeetiｎgMａnager ｇm =　nｅw GrｅetｉｎgManaｇer();
gm.delｅgate１ ＝ EnglｉｓhＧｒeeｔing;
ｇm.delｅｇaｔe1 ＋= CｈｉｎesｅGｒeetｉnｇ； ﻫﻫgm.GｒeetPeople("Ｊｉmmy　Zhａng", ｇm.dｅlegate1〕;
} ﻫ
尽管这样到达了我们要的效果,但是似乎并不美气,光是第一个方法注册用“=〞,第二个用“+=〞就让人觉得别扭。此时，轮到Eveｎｔ出场了，Ｃ#　中可以使用事件来专门完成这项工作，我们改写ＧreetiｎgＭａｎager类,它变成了这个样子: ﻫ
ﻫpｕｂlic clａss GrｅｅtｉｎgManａｇeｒ{ ﻫ／/这一次我们在这里声明一个事件　
ｐｕblic event GｒeetingＤelegate MakeGreｅt;
ﻫpuｂlic voiｄ ＧreetPeoplｅ〔strinｇ name， GrｅｅtingDeleｇate MａｋeGreeｔinｇ〕 {　
MakeGreetinｇ(name〕; ﻫ}
｝

很容易注意到:MaｋｅＧreｅt 事件的声明与之前委托变量deｌegａｔe1的声明唯一的区别是多了一个eｖent关键字。看到这里，你差不多明白到：事件其实没什么不好理解的，声明一个事件不过类似于声明一个委托类型的变量而已。 ﻫﻫ我们想当然地改写Mａｉｎ方法: ﻫ

statiｃ ｖoiｄ　Main〔strｉng[] ａrｇｓ) {　ﻫGreeｔingMａｎager　gｍ　＝ nｅw　GrｅetingManageｒ(〕; ﻫgm.MａkeGrｅｅｔ = EｎglishGreeting; /／ 编译错误１　
gm．MａkeGｒeeｔ += ChinｅｓeGreetinｇ;

ｇm．GreeｔPｅｏplｅ("Jiｍmy Zhａng", ｇm．MakeGreet); ／/编译错误2
}　ﻫﻫ这次，你会得到编译错误：事件“Deleｇaｔe.GreetinｇManager.MakeGreｅt〞只能出现在 += 或 -= 的左边(从类型“Delegaｔe.GreetiｎgManageｒ〞中使用时除外)。　ﻫﻫ事件和委托的编译代码
ﻫ这时候，我们不得不注释掉编译错误的行，然后重新进展编译，再借助Ｒeflactor来对 ｅvenｔ的声明语句做一探究，看看为什么会发生这样的错误: ﻫﻫpuｂliｃ evｅnt ＧrｅｅtingDelegate MakｅGrｅｅｔ;

ﻫﻫ可以看到，实际上尽管我们在GreetiｎｇManager里将 MakｅGreeｔ　声明为pｕbｌｉc,但是，实际上MakｅGreet会被编译成 私有字段,难怪会发生上面的编译错误了，因为它根本就不允许在GreetingManagｅr类的外面以赋值的方式访问。 ﻫ
我们进一步看下MakｅＧreet所产生的代码:
ﻫ
ｐrivａtｅ　GｒeｅtinｇDelegaｔe MaｋeGreｅt; //对事件的声明　实际是 声明一个私有的委托变量
ﻫ[MethodImpl〔MethｏdImｐｌOptions.Synchroｎizｅd〕］ ﻫpubｌiｃ voiｄ add＿MakeＧreet(GrｅeｔinｇDｅlｅgate vaｌuｅ){
ｔhis．MａkｅGrｅet = (ＧreetingＤeleｇaｔe) Deｌegate.Cｏmbine(thｉｓ.ＭaｋeGｒeet, value)；　ﻫ} ﻫ
［ＭethoｄＩmpl(MetｈodImplOptiｏns．Sｙｎｃhronｉzｅd)] ﻫpuｂｌiｃ　void　remoｖe_MaｋeGreet(GｒｅeｔingDelｅgate ｖalｕｅ)｛ ﻫtｈis.MakeGreet = 〔ＧrｅetiｎgDelegate) Dｅｌeｇate．Remove(thｉs．MakeGｒeｅt, valｕe〕; ﻫ}
ﻫ现在已经很明确了：ＭakeGrｅet　事件确实是一个GｒeetiｎgDelegaｔe类型的委托，只不过不管是不是声明为puｂlｉｃ，它总是被声明为privａｔe。另外,它还有两个方法，分别是aｄd_MakeGｒeｅt和remove＿MａkｅGｒeet,这两个方法分别用于注册委托类型的方法和取消注册，实际上也就是： “+=　〞对应 aｄｄ_MakeGreet,“－＝〞对应remove_MakeGreeｔ。而这两个方法的访问限制取决于声明事件时的访问限制符。　
ﻫ在add＿MakeGreet()方法内部，实际上调用了Syｓtem.Delｅgaｔｅ的Combine()静态方法,这个方法用于将当前的变量添加到委托链表中。我们前面提到过两次,说委托实际上是一个类，在我们定义委托的时候:　ﻫﻫpubｌｉc delｅｇate vｏid GreetｉnｇDｅlegａte(sｔring name〕；

当编译器遇到这段代码的时候，会生成下面这样一个完整的类:　ﻫ

puｂｌic ｃｌaｓs GreetingDｅlｅgatｅ：Sｙsｔem.ＭｕlticａstＤelegatｅ｛
ﻫpｕblｉc　GｒeetingＤｅlegatｅ〔ｏbjｅｃt ＠oｂjecｔ, IntＰtr method)； ﻫｐubｌiｃ virｔｕal IAｓyｎcRｅsｕlt　BeｇiｎＩnｖoke(ｓtｒing ｎaｍe, ＡsyncCallback　calｌｂａｃk, ｏbject @obｊect);
ｐｕｂｌｉc　vｉrtｕal vｏid　ＥnｄInvｏｋe〔ＩAsｙncResｕｌt resｕlｔ)； ﻫpubliｃ virtuａl voiｄ　Inｖoke(string nａｍe〕;
ﻫ}　ﻫ
ﻫﻫ关于这个类的更深入内容,可以参阅?CＬR　Viａ C＃?等相关书籍,这里就不再讨论了。　

委托、事件与Ｏbseｒvｅr设计模式 ﻫﻫ范例说明　
ﻫ上面的例子已缺乏以再进展下面的讲解了，我们来看一个新的范例，因为之前已经介绍了很多的内容,所以本节的进度会稍微快一些： ﻫ
假设我们有个高档的热水器，我们给它通上电,当水温超过９５度的时候：1、扬声器会开场发出语音，告诉你水的温度；２、液晶屏也会改变水温的显示，来提示水已经快烧开了。
ﻫ现在我们需要写个程序来模拟这个烧水的过程，我们将定义一个类来代表热水器，我们管它叫:Heater,它有代表水温的字段,叫做teｍperatｕｒe;当然，还有必不可少的给水加热方法BoilＷater(),一个发出语音警报的方法MakeAlｅrt〔),一个显示水温的方法，ShowMsg()。

ﻫnaｍespace Ｄeleｇate { ﻫclａsｓ Heａｔer {　
privａte int tｅmperatｕre；　/／　水温　ﻫﻫ// 烧水 ﻫpｕblｉc voiｄ BoilWatｅr() {　ﻫfor (ｉnt i ＝ 0; i <＝ 100; i＋+) { ﻫtemperature ＝　i;　
ﻫｉf (tempeｒａture　> 95〕 { ﻫＭａkeAlｅrt(temｐeraｔure)；
ＳｈowMｓg(temperatuｒe);
}
} ﻫ}　

／/ 发出语音警报 ﻫprｉvate vｏid MａkｅＡｌert(inｔ ｐaｒaｍ) {
Coｎsolｅ．WriteLiｎe("Aｌaｒｍ:嘀嘀嘀,水已经 {0｝ 度了："　, parａm); ﻫ}　ﻫﻫ//　显示水温 ﻫpｒivate ｖoｉd　ShowＭｓg〔int param) { ﻫConsｏlｅ.ＷｒiｔeLｉne("Dｉｓplay：水快开了,当前温度：{0}度。" ， paraｍ〕;
} ﻫ｝
ﻫcｌａsｓ Pｒogram {　
staｔic vｏｉd Ｍａin() ｛　
Heateｒ hｔ = new Heａteｒ()； ﻫht.BoｉlWater(); ﻫ} ﻫ}　
}

Observer设计模式简介 ﻫﻫ上面的例子显然能完成我们之前描述的工作,但是却并不够好。现在假设热水器由三局部组成：热水器、警报器、显示器,它们来自于不同厂商并进展了组装。那么，应该是热水器仅仅负责烧水,它不能发出警报也不能显示水温;在水烧开时由警报器发出警报、显示器显示提示和水温。 ﻫ
这时候,上面的例子就应该变成这个样子:　

// 热水器
pubｌic cｌass Hｅateｒ {
priｖaｔe inｔ temperature;
ﻫ// 烧水 ﻫpｒｉvaｔe vｏiｄ　BoiｌＷａter() ｛ ﻫｆor 〔int ｉ　= 0;　i <= 100; ｉ++) ｛
tｅmｐeｒaｔure = i； ﻫ} ﻫ}
｝
ﻫ/／ 警报器 ﻫpｕblic claｓs Aｌarm{ ﻫprivａte ｖｏid　MakeAlｅｒt(iｎt param) { ﻫConsｏlｅ.ＷritｅLｉnｅ(＂Alａrｍ:嘀嘀嘀,水已经 {0｝　度了：" ，　ｐａｒam); ﻫ}
｝

/／ 显示器　ﻫpuｂlic clａss Diｓplａy{　
ｐrivate　void　SｈowMsg(ｉnt ｐａｒaｍ)　｛　ﻫＣonsｏlｅ.WｒiteLine〔"Ｄisplay:水已烧开，当前温度：{0｝度。" , param);　ﻫ} ﻫ} ﻫﻫ这里就出现了一个问题：如何在水烧开的时候通知报警器和显示器？在继续进展之前,我们先了解一下Ｏbserｖer设计模式，Observｅr设计模式中主要包括如下两类对象： ﻫ
Sｕbject：监视对象,它往往包含着其他对象所感兴趣的内容。在本范例中，热水器就是一个监视对象,它包含的其他对象所感兴趣的内容,就是ｔｅmprature字段,当这个字段的值快到100时,会不断把数据发给监视它的对象。　ﻫObserver:监视者，它监视Subjecｔ，当Subject中的某件事发生的时候，会告知Observer,而Oｂｓerver那么会采取相应的行动。在本范例中，Ｏbserｖeｒ有警报器和显示器，它们采取的行动分别是发出警报和显示水温。
在本例中,事情发生的顺序应该是这样的: ﻫ
警报器和显示器告诉热水器,它对它的温度比拟感兴趣(注册)。　ﻫ热水器知道后保存对警报器和显示器的引用。
热水器进展烧水这一动作,当水温超过９5度时，通过对警报器和显示器的引用，自动调用警报器的MaｋeAleｒｔ()方法、显示器的ShowMｓg〔)方法。 ﻫ类似这样的例子是很多的，GOF对它进展了抽象，称为Oｂsｅrvｅr设计模式:Oｂserver设计模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，其他依赖于它的对象会被自动告知并更新。Obserｖer模式是一种松耦合的设计模式。

实现范例的Ｏｂseｒver设计模式　ﻫﻫ我们之前已经对委托和事件介绍很多了,现在写代码应该很容易了,现在在这里直接给出代码，并在注释中加以说明。　

ﻫusｉng Systｅm; ﻫｕsｉｎg Ｓysｔem．Ｃollecｔioｎｓ．Gｅneric；　ﻫuｓing　Ｓｙsｔｅｍ.Text;　

namespａce　Dｅｌegａte {
/／ 热水器 ﻫpubliｃ　ｃlaｓs　Hｅater {　
ｐrｉｖaｔe inｔ ｔｅmperatｕre;
puｂlｉｃ deｌegate voｉｄ BoilHaｎdｌｅr(inｔ parａm)；　/／声明委托　ﻫpｕblic evｅnt　BoｉlHandｌｅr BoilＥvenｔ； //声明事件 ﻫ
／/ 烧水 ﻫｐublic void　BoilWater() {　ﻫfor (iｎt i ＝ 0;　i　＜= 1００; i++)　{ ﻫteｍperaturｅ　=　i;

ｉf (ｔeｍpeｒaｔｕre　>　95〕　{
ｉｆ 〔BoilEｖeｎｔ !＝ ｎｕll)　｛ ／／如果有对象注册　
BｏiｌＥｖｅnｔ(tｅmperａｔurｅ)；　//调用所有注册对象的方法
}
}　
}　
}　ﻫ} ﻫ
／/ 警报器
ｐublｉc claｓｓ Alarm {　ﻫpublic ｖoｉd　MakeAlert〔int paｒam)　{　ﻫConｓoｌe．WｒiｔｅLine("Alaｒm：嘀嘀嘀,水已经 ｛0} 度了:", param); ﻫ} ﻫ}

／/ 显示器
pubｌic ｃlasｓ　Disｐlay {　
pｕｂlic static　void　ShowＭsg(iｎｔ　pａrａm) { /／静态方法　
Cｏｎｓｏｌe．ＷriteＬine〔"Dｉｓplay：水快烧开了,当前温度：{0}度。", paｒam); ﻫ} ﻫ}　ﻫﻫcｌass　Program　{　
sｔatic　void Ｍain() {　
Hｅaｔer　ｈeater = nｅｗ　Heater(〕;
Alarm alaｒm　= new Alarm(〕;
ﻫhｅater.BoilEvｅｎｔ += ａｌａrm.ＭａkeAｌｅrt； //注册方法
heater．BoilEvent　+= (ｎｅw Alａrｍ()〕.MａkeAlｅrt； //给匿名对象注册方法 ﻫhｅater.BoiｌEveｎt　+=　Displaｙ.ShoｗMｓg; ／/注册静态方法 ﻫ
ｈeater．BoilWaｔeｒ〔)； //烧水,会自动调用注册过对象的方法
｝
｝
} ﻫﻫ
输出为:
Aｌaｒm：嘀嘀嘀，水已经 9６ 度了:
Alaｒm：嘀嘀嘀，水已经　96 度了： ﻫDisplay:水快烧开了,当前温度：96度。　
／/ 省略...　

.Net Fraｍｅworｋ中的委托与事件 ﻫﻫ尽管上面的范例很好地完成了我们想要完成的工作,但是我们不仅疑惑：为什么．Ｎeｔ　Frａｍｅwork　中的事件模型和上面的不同?为什么有很多的ＥvｅntArgｓ参数? ﻫﻫ在答复上面的问题之前，我们先搞懂　.Net Framｅwoｒk的编码标准：
ﻫ委托类型的名称都应该以EvenｔＨandleｒ完毕。 ﻫ委托的原型定义:有一个ｖｏid返回值，并承受两个输入参数:一个Objｅct 类型,一个 EｖeｎtAｒｇｓ类型(或继承自EveｎｔＡrgs〕。
事件的命名为 委托去掉 EventHanｄler之后剩余的局部。 ﻫ继承自EvｅnｔArｇs的类型应该以EｖenｔAｒgs