谬误是多种多样的，但真理只有一个。——佚名（上海网站建设）
（转）.NET委托：一个C＃睡前故事
Admin
2012年1月19日
英文版原作者：Chris Sells（www.sellsbrothers.com）
翻译：袁晓辉（www.farproc.com http://blog.csdn.net/uoyevoli）
原文地址: http://dev.csdn.net/article/82/82644.shtm
紧耦合
畴前，在南边一块奇怪的地盘上，有个工人名叫彼得，他很是勤奋，对他的老板老是百依百顺。然则他的老板是个悭吝的人，从不信赖别人，果断请求随时知道彼得的工作进度，以防止他偷懒。然则彼得又不想让老板呆在他的办公室里站在背后盯着他，于是就对老板做出承诺：无论何时，只要我的工作取得了一点进展我都邑及时让你知道。彼得经由过程周期性地应用“带类型的引用”（原文为：“typed reference” 也就是delegate？？）“回调”他的老板来实现他的承诺，如下：
class Worker {
public void Advise（Boss boss） { _boss = boss; }
public void DoWork（） {
Console.WriteLine（“工作: 工作开端”）;
if（ _boss != null ） _boss.WorkStarted（）;
Console.WriteLine（“工作: 工作进行中”）;
if（ _boss != null ） _boss.WorkProgressing（）;
Console.WriteLine（"“工作: 工作完成”"）;
if（ _boss != null ） {
int grade = _boss.WorkCompleted（）;
Console.WriteLine（“工人的工作得分＝” + grade）;
}
}
private Boss _boss;
}
class Boss {
public void WorkStarted（） { /* 老板不关怀。 */ }
public void WorkProgressing（） { /*老板不关怀。 */ }
public int WorkCompleted（） {
Console.WriteLine（“时候差不久不多！”）;
return 2; /* 总分为10 */
}
}
class Universe {
static void Main（） {
Worker peter = new Worker（）;
Boss boss = new Boss（）;
peter.Advise（boss）;
peter.DoWork（）;
Console.WriteLine（“Main: 工人工作完成”）;
Console.ReadLine（）;
}
}
接口
如今，彼得成了一个特别的人，他不单能容忍悭吝的老板，并且和他四周的宇宙也有了亲近的接洽，以至于他认为宇宙对他的工作进度也感爱好。不幸的是，他必须也给宇宙添加一个特别的回调函数Advise来实现同时向他老板和宇宙呈报工作进度。彼得想要把潜伏的通知的列表和这些通知的实现办法分别开来，于是他决意把办法分别为一个接口：
interface IWorkerEvents {
void WorkStarted（）;
void WorkProgressing（）;
int WorkCompleted（）;
}
class Worker {
public void Advise（IWorkerEvents events） { _events = events; }
public void DoWork（） {
Console.WriteLine（“工作: 工作开端”）;
if（ _events != null ） _events.WorkStarted（）;
Console.WriteLine（“工作: 工作进行中”）;
if（_events != null ） _events.WorkProgressing（）;
Console.WriteLine（"“工作: 工作完成”"）;
if（_events != null ） {
int grade = _events.WorkCompleted（）;
Console.WriteLine（“工人的工作得分＝” + grade）;
}
}
private IWorkerEvents _events;
}
class Boss : IWorkerEvents {
public void WorkStarted（） { /* 老板不关怀。 */ }
public void WorkProgressing（） { /* 老板不关怀。 */ }
public int WorkCompleted（） {
Console.WriteLine（“时候差不久不多！”）;
return 3; /* 总分为10 */
}
}
委托
不幸的是，每当彼得忙于经由过程接口的实现和老板交换时，就没有机会及时通知宇宙了。至少他应当忽视身在远方的老板的引用，好让其他实现了IWorkerEvents的对象获得他的工作呈报。（”At least he""d abstracted the reference of his boss far away him so that others who implemented the IWorkerEvents interface could be notified of his work progress” 原话如此，不睬解到底是什么意思 ）
他的老板还是抱怨得很厉害。“彼得！”他老板吼道，“你为什么在工作一开端和工作进行中都来烦我？！我不关怀这些事务。你不单强迫我实现了这些办法，并且还在浪费我名贵的工作时候来处理惩罚你的事务，希罕是当我外出的时辰更是如此！你能不克不及不再来烦我？”
于是，彼合意识到接口固然在很多景象都很有效，然则当用作事务时，“粒度”不敷好。他欲望可以或许仅在别人想要时才通知他们，于是他决意把接口的办法分别为零丁的委托，每个委托都像一个小的接口办法：
delegate void WorkStarted（）;
delegate void WorkProgressing（）;
delegate int WorkCompleted（）;
class Worker {
public void DoWork（） {
Console.WriteLine（“工作: 工作开端”）;
if（ started != null ） started（）;
Console.WriteLine（“工作: 工作进行中”）;
if（ progressing != null ） progressing（）;
Console.WriteLine（"“工作: 工作完成”"）;
if（ completed != null ） {
int grade = completed（）;
Console.WriteLine（“工人的工作得分＝” + grade）;
}
}
public WorkStarted started;
public WorkProgressing progressing;
public WorkCompleted completed;
}
class Boss {
public int WorkCompleted（） {
Console.WriteLine（"Better..."）;
return 4; /* 总分为10 */
}
}
class Universe {
static void Main（） {
Worker peter = new Worker（）;
Boss boss = new Boss（）;
peter.completed = new WorkCompleted（boss.WorkCompleted）;
peter.DoWork（）;
Console.WriteLine（“Main: 工人工作完成”）;
Console.ReadLine（）;
}
}
静态监听者
如许，彼得不会再拿他老板不想要的事务来烦他老板了，然则他还没有把宇宙放到他的监听者列表中。因为宇宙是个包涵一切的实体，看来不合适应用实例办法的委托（想像一下，实例化一个“宇宙”要花费几许资料…..），于是彼得就须要可以或许对静态委托进行挂钩，委托对这一点支撑得很好：
class Universe {
static void WorkerStartedWork（） {
Console.WriteLine（"Universe notices worker starting work"）;
}
static int WorkerCompletedWork（） {
Console.WriteLine（"Universe pleased with worker""s work"）;
return 7;
}
static void Main（） {
Worker peter = new Worker（）;
Boss boss = new Boss（）;
peter.completed = new WorkCompleted（boss.WorkCompleted）;
peter.started = new WorkStarted（Universe.WorkerStartedWork）;
peter.completed = new WorkCompleted（Universe.WorkerCompletedWork）;
peter.DoWork（）;
Console.WriteLine（“Main: 工人工作完成”）;
Console.ReadLine（）;
}
}
事务
不幸的是，宇宙太忙了，也不习惯时刻存眷它里面的个别，它可以用本身的委托调换了彼得老板的委托。这是把彼得的Worker类的的委托字段做成public的一个无意识的副感化。同样，若是彼得的老板不耐烦了，也可以决意本身来激发彼得的委托（真是一个粗暴的老板）：
// Peter""s boss taking matters into his own hands
if（ peter.completed != null ） peter.completed（）;
彼得不想让这些事产生，他意识到须要给每个委托供给“注册”和“反注册”功能，如许监听者就可以本身添加和移除委托，但同时又不克不及清空全部列表也不克不及随便激发彼得的事务了。彼得并没有来本身实现这些功能，相反，他应用了event关键字让C＃编译器为他构建这些办法：
class Worker {
...
public event WorkStarted started;
public event WorkProgressing progressing;
public event WorkCompleted completed;
}
彼得知道event关键字在委托的外边包装了一个property，仅让C＃客户经由过程+= 和 -=操纵符来添加和移除，强迫他的老板和宇宙正确地应用事务。
static void Main（） {
Worker peter = new Worker（）;
Boss boss = new Boss（）;
peter.completed += new WorkCompleted（boss.WorkCompleted）;
peter.started += new WorkStarted（Universe.WorkerStartedWork）;
peter.completed += new WorkCompleted（Universe.WorkerCompletedWork）;
peter.DoWork（）;
Console.WriteLine（“Main: 工人工作完成”）;
Console.ReadLine（）;
}
“收成”所有成果
到这时，彼得终于可以送一口气了，他成功地满足了所有监听者的需求，同时避免了与特定实现的紧耦合。然则他重视到他的老板和宇宙都为它的工作打了分，然则他仅仅接管了一个分数。面对多个监听者，他想要“收成”所有的成果，于是他深切到****代理里面，轮询监听者列表，手工一个个调用：
public void DoWork（） {
...
Console.WriteLine（"“工作: 工作完成”"）;
if（ completed != null ） {
foreach（ WorkCompleted wc in completed.GetInvocationList（） ） {
int grade = wc（）;
Console.WriteLine（“工人的工作得分＝” + grade）;
}
}
}
异步通知：激发 & 忘掉
同时，他的老板和宇宙还要忙于处理惩罚其他工作，也就是说他们给彼得打分所花费的事务变得很是长：
class Boss {
public int WorkCompleted（） {
System.Threading.Thread.Sleep（3000）;
Console.WriteLine（"Better..."）; return 6; /* 总分为10 */
}
}
class Universe {
static int WorkerCompletedWork（） {
System.Threading.Thread.Sleep（4000）;
Console.WriteLine（"Universe is pleased with worker""s work"）;
return 7;
}
...
}
很不幸，彼得每次通知一个监听者后必须守候它给本身打分，如今这些通知花费了他太多的工作事务。于是他决意忘掉分数，仅仅异步激发事务：
public void DoWork（） {
...
Console.WriteLine（"“工作: 工作完成”"）;
if（ completed != null ） {
foreach（ WorkCompleted wc in completed.GetInvocationList（） ）
{
wc.BeginInvoke（null， null）;
}
}
}
异步通知：轮询
这使得彼得可以通知他的监听者，然后立即返回工作，让过程的线程池来调用这些****代理。跟着时候的畴昔，彼得发明他丧失了他工作的反馈，他知道听取别人的赞赏和尽力工作一样首要，于是他异步激发事务，然则周期性地轮询，取得可用的分数。
public void DoWork（） {
...
Console.WriteLine（"“工作: 工作完成”"）;
if（ completed != null ） {
foreach（ WorkCompleted wc in completed.GetInvocationList（） ） {
IAsyncResult res = wc.BeginInvoke（null， null）;
while（ !res.IsCompleted ） System.Threading.Thread.Sleep（1）;
int grade = wc.EndInvoke（res）;
Console.WriteLine（“工人的工作得分＝” + grade）;
}
}
}
异步通知：委托
不幸地，彼得有回到了一开端就想避免的景象中来，比如，老板站在背后盯着他工作。于是，他决意应用本身的委托作为他调用的异步委托完成的通知，让他本身立即回到工作，然则仍可以在别人给他的工作打分后获得通知：
public void DoWork（） {
...
Console.WriteLine（"“工作: 工作完成”"）;
if（ completed != null ） {
foreach（ WorkCompleted wc in completed.GetInvocationList（） ） {
wc.BeginInvoke（new AsyncCallback（WorkGraded）， wc）;
}
}
}
private void WorkGraded（IAsyncResult res） {
WorkCompleted wc = （WorkCompleted）res.AsyncState;
int grade = wc.EndInvoke（res）;
Console.WriteLine（“工人的工作得分＝” + grade）;
}
宇宙中的幸福
彼得、他的老板和宇宙终极都满足了。彼得的老板和宇宙可以收到他们感爱好的事务通知，削减了实现的肩负和非必须的往返“差川资”。彼得可以通知他们，而不管他们要花多长时候来从目标办法中返回，同时又可以异步地获得他的成果。彼得知道，这并不*十分*简单，因为当他异步激发事务时，办法要在别的一个线程中履行，彼得的目标办法完成的通知也是一样的事理。然则，迈克和彼得是好伴侣，他很熟悉线程的工作，可以在这个范畴供给领导。
他们永远幸福地生活生计下去……<完>
作者：Limits
出处：http://limits.cnblogs.com
本文版权归作者和博客园共有，迎接转载，但未经作者赞成必须保存此段声明，且在文章页面明显地位给出原文连接，如有题目，可以经由过程limitswpf＃hotmail.com 接洽我，很是感激。
博客园C＃技巧交换群：186458423。迎接大师参加。
|