从前,在南方一块奇异的土地上,有个工人名叫彼得,他非常勤奋,对他的老板总是百依百顺。但是他的老板是个吝啬的人,从不信任别人,坚决要求随时知道彼得的工作进度,以防止他偷懒。但是彼得又不想让老板呆在他的办公室里站在背后盯着他,于是就对老板做出承诺:无论何时,只要我的工作取得了一点进展我都会及时让你知道。彼得通过周期性地使用
“
带类型的引用
”(
原文为:
“typed reference”
也就是
delegate
??
)“
回调
”
他的老板来实现他的承诺,如下:
namespace
皮特的故事_原始版
{
class Worker
{
//
声明老板变量
private Boss _boss;
//
通知老板
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+"
分"
);
}
}
}
class Boss
{
public void WorkStarted()
{
Console.WriteLine("
老板说:“好好干!”"
);
}
public void WorkProgressing()
{
Console.WriteLine("
老板说:“没干完别来烦我!”"
);
}
public int WorkCompleted()
{
Console.WriteLine("
老板说:“没干完别来烦我!”"
);
return 4; /*
总分为5分*/
}
}
class Universe
{
static void Main()
{
Worker peter = new Worker();
Boss boss = new Boss();
//
开始通知老板,要开始干活了
peter.Advise(boss);
peter.DoWork();
Console.WriteLine("
工人工作完成。"
);
Console.ReadLine();
}
}
}
接口
现在,彼得成了一个特殊的人,他不但能容忍吝啬的老板,而且和他周围的宇宙也有了密切的联系,以至于他认为宇宙对他的工作进度也感兴趣。不幸的是,
他必须也给宇宙添加一个特殊的回调函数
Advise
来实现同时向他老板和宇宙报告工作进度
。彼得想要把潜在的通知的列表和这些通知的实现方法分离开来,于是他决定把方法分离为一个接口:
namespace
皮特的故事_接口版
{
//
工人报告工作进度事件接口
interface IWorkerEvents
{
void WorkStarted();
void WorkProgressing();
int WorkCompleted();
}
class Worker
{
//
声明接口类型变量指向实现接口的类
private IWorkerEvents _events;
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+"
分"
);
}
}
}
//
老板类实现工人报告工作进度事件接口
class Boss : IWorkerEvents
{
//
老板不关心工作开始
public void WorkStarted()
{
Console.WriteLine("
老板说:“没干完别来烦我!”"
);
}
//
老板不关心工作进行情况
public void WorkProgressing()
{
Console.WriteLine("
老板说:“没干完别来烦我!”"
);
}
//
老板关心工作结果
public int WorkCompleted()
{
Console.WriteLine("
老板说:“我看看结果,还不错!”"
);
return 4; /*
总分为5分*/
}
}
class Universe : IWorkerEvents
{
//
宇宙关心工作开始
public void WorkStarted()
{
Console.WriteLine("
宇宙说:“好,加油!”"
);
}
//
宇宙关心工作进行情况
public void WorkProgressing()
{
Console.WriteLine("
宇宙说:“干得听不错的,继续努力!”"
);
}
//
宇宙关心工作结果
public int WorkCompleted()
{
Console.WriteLine("
宇宙说:“我看看结果,还不错!”"
);
return 4; /*
总分为5分*/
}
}
class Text
{
static void Main()
{
Worker peter = new Worker();
//
生成老板实例
Boss boss = new Boss();
//
生成宇宙实例
Universe universe = new Universe();
//
开始通知老板,要开始干活了
//
一次工作的过程只能通知其中一方(老板或宇宙),无法同时通知所有实现接口的对象。
//peter.Advise(universe);
// peter.Advise(boss);
//peter.DoWork();
//
这样写实际只通知了老板,没通知到宇宙
peter.Advise(universe);
peter.Advise(boss);
peter.DoWork();
//
下面这样写实际上是执行了两次工作,第一次通知了宇宙,第二次通知了老板
//peter.Advise(universe);
//peter.DoWork();
//peter.Advise(boss);
//peter.DoWork();
Console.WriteLine("
工人工作完成了。"
);
Console.ReadLine();
}
}
}
委托
不幸的是,每当彼得忙于通过接口的实现和老板交流时,就
没有机会及时
通知宇宙了
(一次工作的过程只能通知一方(老板或宇宙),无法同时通知所有实现接口的对象。)
。
至少他应该忽略身在远方的老板的引用,好让其他实现了
IWorkerEvents
的对象得到他的工作报告。
(
”At least he'd abstracted the reference of his boss far away from him so that others who implemented the IWorkerEvents interface could be notified of his work progress”
原话如此,不理解到底是什么意思
)
他的老板还是抱怨得很厉害。
“
彼得!
”
他老板吼道,
“
你为什么在工作一开始和工作进行中都来烦我?!
我不关心这些事件。你不但强迫我实现了这些方法
,而且还在浪费我宝贵的工作时间来处理你的事件,特别是当我外出的时候更是如此!你能不能不再来烦我?
”
于是,彼得意识到接口虽然在很多情况都很有用,但是当用作事件时,
“
粒度
”
不够好
(
在面向对象中,如果一个对象
“
车队
”
的实现只深入到
“
汽车
”
这个层次,而不是
“
发动机
”“
轮胎
”
这个层次,那么前者比后者粒度大。
只要能满足需要,粒度当然越大越好,简单实用。
)
。他希望能够仅在别人想要时才通知他们,于是他决定把接口的方法分离为单独的委托,
每个委托都像一个小的接口方法
:
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
皮特的故事_委托版_
{
//
声明3个委托,分别用来报告工作进度的3个阶段(开始、进行、完成)
delegate void WorkStarted();
delegate void WorkProgressing();
delegate int WorkCompleted();
class Worker
{
//
声明3个委托的变量
public WorkStarted started;
public WorkProgressing progressing;
public WorkCompleted completed;
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+"
分"
);
}
}
}
class Boss
{
//
老板不关心工作进行情况
public void WorkProgressing()
{
Console.WriteLine("
老板说:“快点干,没干完别来见我!”"
);
}
//
老板关心工作结果
public int WorkCompleted()
{
Console.WriteLine("
老板说:“我看看结果,还不错!”"
);
return 4; /*
总分为5分*/
}
}
class Universe
{
//
宇宙关心工作开始
public void WorkStarted()
{
Console.WriteLine("
宇宙说:“好,加油!”"
);
}
//
宇宙关心工作进行情况
public void WorkProgressing()
{
Console.WriteLine("
宇宙说:“干得挺不错的,继续努力!”"
);
}
}
class Test
{
static void Main()
{
Worker peter = new Worker();
//
生成老板实例
Boss boss = new Boss();
//
老板关心工作结果,所以给老板订阅报告工作完成事件
peter.completed = new WorkCompleted(boss.WorkCompleted);
//
老板关心工作进度,所以使用托给老板订阅报告工作进度事件
peter.progressing = new WorkProgressing(boss.WorkProgressing);
//
生成宇宙实例
Universe universe = new Universe();
//
宇宙关心工作开始,所以给宇宙订阅报告工作开始事件
peter.started = new WorkStarted(universe.WorkStarted);
//
宇宙和老板一样也关心工作进度,所以使用多播委托也给宇宙订阅报告工作进度事件
peter.progressing = new WorkProgressing(universe.WorkProgressing);
//
皮特开始工作
peter.DoWork();
Console.WriteLine("
工人工作完成,所有人都得到自己关心的消息!"
);
Console.ReadLine();
}
}
}
静态监听者
这样,彼得不会再拿他老板不想要的事件来烦他老板了,但是他
还没有把宇宙放到他的监听者列表中
。因为宇宙是个包涵一切的实体,看来不适合使用实例方法的委托(
想像一下,实例化一个
“
宇宙
”
要花费多少资源
…..
),于是彼得就需要能够对静态委托进行挂钩,委托对这一点支持得很好:
namespace
皮特的故事_静态监听者版_
{
//
声明3个委托,分别用来报告工作进度的3个阶段(开始、进行、完成)
delegate void WorkStarted();
delegate void WorkProgressing();
delegate int WorkCompleted();
class Worker
{
//
声明3个委托的变量
public WorkStarted started;
public WorkProgressing progressing;
public WorkCompleted completed;
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 + "
分"
);
}
}
}
class Boss
{
//
老板关心工作结果
public int WorkCompleted()
{
Console.WriteLine("
老板说:“我看看结果,还不错!”"
);
return 4; /*
总分为5分*/
}
}
class Universe
{
//
因为宇宙是个包涵一切的实体,不适合使用实例方法的委托
//
(想像一下,实例化一个“宇宙”要花费多少资源…..),于是彼得就需要能够对静态委托进行挂钩
//
把宇宙的方法全部设成静态
//
宇宙关心工作开始
public static void WorkerStarted()
{
Console.WriteLine("
宇宙说:“好,加油!”"
);
}
//
宇宙关心工作结果
public static int WorkCompleted()
{
Console.WriteLine("
宇宙说:“我看看结果,很不错,非常好!”"
);
return 5; /*
总分为5分*/
}
}
class Test
{
static void Main()
{
Worker peter = new Worker();
Boss boss = new Boss();
peter.completed = new WorkCompleted(boss.WorkCompleted);
peter.started = new WorkStarted(Universe.WorkerStarted);
//
宇宙不小心用自己的委托替换了彼得老板的委托。
//
这是把彼得的Worker类的的委托字段做成public的一个无意识的副作用,如果不想替换必须用”+=“进行多播委托
peter.completed = new WorkCompleted(Universe.WorkCompleted);
peter.DoWork();
Console.WriteLine("/n
工人工作完成,老板没收到工作完成的报告。/n老板很生气,后果很严重!"
);
Console.ReadLine();
}
}
}
|
异步通知:激发
&
忘掉
同时,他的老板和宇宙还要忙于处理其他事情,也就是说他们给彼得打分所花费的事件变得非常长:
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 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);
}
}
}
...
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);
}
}
}
...
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);
}
...
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);
}
宇宙中的幸福
彼得、他的老板和宇宙最终都满足了。彼得的老板和宇宙可以收到他们感兴趣的事件通知,减少了实现的负担和非必需的往返
“
差旅费
”
。彼得可以通知他们,而不管他们要花多长时间来从目的方法中返回,同时又可以异步地得到他的结果。彼得知道,这并不
*
十分
*
简单,因为当他异步激发事件时,方法要在另外一个线程中执行,彼得的目的方法完成的通知也是一样的道理。但是,迈克和彼得是好朋友,他很熟悉线程的事情,可以在这个领域提供指导。
他们永远幸福地生活下去
……<
完
>