寄托的功效,睡前传说

英文版原来的小说者:克莉丝Sells(www.sellsbrothers.com
翻译:袁晓辉(www.farproc.com
http://blog.csdn.net/uoyevoli
原来的作品地址: http://dev.csdn.net/article/82/82644.shtm

 

在此从前,在西边1块奇异的土地上,有个工人名字为Peter,他相当努力,对他的业主连连百依百顺。不过她的小业主是个吝啬的人,从不信任旁人,坚决须要随时理解彼得的工作进程,以幸免她偷懒。不过Peter又不想让业主呆在他的办公室里站在私行看着她,于是就对业主做出承诺:无论曾几何时,只要本身的劳作取得了某个进行小编都会即刻让您通晓。Peter通过周期性地使用“带项目标引用”(最初的作品为:“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() { /* CEO不保养。 */ }    
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();     } }

接口

近日,Peter成了三个奇特的人,他不仅能隐忍吝啬的CEO娘,而且和他方圆的自然界也有了细致的关联,以至于他觉得宇宙对他的工作进度也感兴趣。不幸的是,他必须也给宇宙添加三个例外的回调函数Advise来兑现同时向她老董和宇宙报告工作进程。Peter想要把潜在的通报的列表和那么些通告的贯彻方式分别开来,于是她操纵把艺术分别为2个接口:

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 IWorker伊芙nts _events; }
class Boss : IWorkerEvents {     public void WorkStarted() { /*
总CEO不关怀。 */ }     public void WorkProgressing() { /* 老板不爱慕。
*/ }     public int WorkCompleted() {        
Console.WriteLine(“时间大多!”);         return 三; /* 总分为10 */
    } }

委托

噩运的是,每当Peter忙于通过接口的兑现和CEO沟通时,就从未机会立即文告宇宙了。至少她应有忽视身在天边的高管娘的引用,好让其余完毕了IWorker伊芙nts的目的获得他的做事报告。(”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” 原话如此,不知情到底是怎么着意思:))

她的老董依旧抱怨得非常棒。“Peter!”他COO吼道,“你干什么在做事一开头和做事开始展览中都来烦小编?!小编不关切这几个事件。你不光强迫笔者完成了这几个情势,而且还在浪费本身宝贵的工作时间来处理你的风浪,尤其是当自身出门的时候更是如此!你能还是不能够不再来烦作者?”

于是乎,彼得意识到接口尽管在众多情景都很有用,不过当用作事件时,“粒度”不够好。他愿意可以仅在别人想要时才通告他们,于是他控制把接口的办法分别为单身的委托,每种委托都像一个小的接口方法:

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();     } }

静态监听者

这么,Peter不会再拿她总经理不想要的轩然大波来烦他老板了,不过他还未曾把宇宙放到他的监听者列表中。因为宇宙是个包容一切的实业,看来不符合利用实例方法的委托(想像一下,实例化1个“宇宙”要费用多少能源…..),于是Peter就需求能够对静态委托开始展览联络,委托对那一点支撑得很好:

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();     } }

事件

不幸的是,宇宙太忙了,也不习惯时刻关切它里面的个人,它能够用自身的寄托替换了Peter首席执行官的寄托。那是把Peter的Worker类的的委托字段做成public的2个潜意识的副效能。同样,借使Peter的小业主不耐烦了,也得以控制自个儿来刺激彼得的寄托(真是一个强行的老板):

        // Peter~s boss taking matters into his own hands         if(
peter.completed != null ) peter.completed();
彼得不想让那个事爆发,他发现到必要给各类委托提供“注册”和“反注册”功效,那样监听者就能够团结充足和移除委托,但还要又无法清空整个列表也不能随意激发彼得的事件了。Peter并不曾来本身完毕那么些职能,相反,他选用了event关键字让C#编写翻译器为他创设那个格局:

class Worker { …     public event WorkStarted started;     public
event WorkProgressing progressing;     public event WorkCompleted
completed; }

Peter知道event关键字在委托的异乡包装了2个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();     }

“收获”全体结果

到此时,Peter终于能够送一口气了,他不负众望地满意了独具监听者的必要,同时防止了与特定完成的紧耦合。可是他留意到他的主管和宇宙都为它的行事打了分,可是他可是接收了一个分数。面对三个监听者,他想要“收获”全部的结果,于是他深深到代办里面,轮询监听者列表,手工业三个个调用:

public void DoWork() {         …         Console.WriteLine(““工作:
工作成功””);         if( completed != null ) {             foreach(
WorkCompleted wc in completed.GetInvocationList() ) {                
int grade = wc();                 Console.WriteLine(“工人的办事得分=” +
grade);             }         }     }

异步公告:激发 & 忘掉

并且,他的老总娘和大自然还要忙于处理别的工作,也正是说他们给Peter打分所消费的风波变得不行长:

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;     }     … }
很不幸,Peter每一遍布告一个监听者后必须等待它给自个儿打分,未来这个布告开销了她太多的劳作事件。于是她操纵忘掉分数,仅仅异步激发事件:

public void DoWork() {         …         Console.WriteLine(““工作:
工作形成””);         if( completed != null ) {             foreach(
WorkCompleted wc in completed.GetInvocationList() )             {
                wc.BeginInvoke(null, null);             }         }    
}

异步公告:轮询

那使得Peter能够布告她的监听者,然后立刻回去工作,让进程的线程池来调用那些代理。随着岁月的死亡,Peter发现他不见了她工作的申报,他明白听取别人的褒奖和着力干活同样主要,于是她异步激发事件,可是周期性地轮询,取得可用的分数。

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(一);                 int
grade = wc.EndInvoke(res);                
Console.WriteLine(“工人的做事得分=” + grade);             }         }
    }

异步公告:委托

不幸地,Peter有重临了壹先河就想幸免的意况中来,比如,高管站在骨子里瞅着他干活。于是,他控制利用本身的委托作为他调用的异步委托完毕的布告,让他协调霎时赶回工作,可是还能够在人家给他的干活打分后取得公告:

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);     }

大自然中的幸福

Peter、他的小业主和宇宙最后都知足了。Peter的总老板娘和大自然能够选用他们感兴趣的事件通报,减弱了贯彻的承担和非必需的来往“出差旅行费”。Peter能够文告他们,而任由他们要花多久来从指标方法中回到,同时又足以异步地获取他的结果。Peter知道,那并不*十分*差不多,因为当她异步激发事件时,方法要在此外3个线程中履行,Peter的指标方法成功的通报也是同一的道理。然而,Mike和Peter是好情人,他很熟识线程的事体,能够在这么些圈子提供辅导。

 

她们世世代代甜蜜地生活下去……<完>

紧耦合
过去,在南方1块奇异的土地上,有个工友名称叫Peter,他充足费力,对她的业主连连百依百顺。不过他的业主是个吝啬的人,从不信任旁人,坚决须要随时精晓Peter的工作进度,以预防她偷懒。可是彼得又不想让CEO呆在他的办公室里站在暗自瞧着她,于是就对COO做出承诺:无论哪天,只要本身的办事取得了某个拓展小编都会马上让您精通。Peter通过周期性地使用“带项指标引用”(原来的书文为:“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() { /*COO娘不关怀。 */ }
    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();
    }
}

接口

今昔,Peter成了1个特殊的人,他非但能耐受吝啬的老总娘,而且和她相近的宇宙空间也有了精心的联系,以至于他认为宇宙对她的工作进程也感兴趣。不幸的是,他必须也给宇宙添加一个新鲜的回调函数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() { /* COO不关注。 */ }
    public int WorkCompleted() {
        Console.WriteLine(“时间大概!”);
        return 3; /* 总分为10 */
    }
}

委托

不幸的是,每当Peter忙于通过接口的完成和COO娘交换时,就从未机会及时通报宇宙了。至少她应该忽视身在天边的CEO娘的引用,好让任何落成了IWorker伊芙nts的对象获得她的工作报告。(”At
least he’d abstracted the reference of his boss far away from him so
that others who implemented the IWorker伊夫nts interface could be
notified of his work progress” 原话如此,不知晓到底是什么样意思 )

他的业主照旧抱怨得非常的厉害。“Peter!”他老董吼道,“你为何在工作1伊始和做事进展中都来烦小编?!小编不关怀这个事件。你不单强迫自身完成了那一个艺术,而且还在荒废自身宝贵的劳作时间来拍卖你的风云,特别是当自家出门的时候更是如此!你能还是不可能不再来烦作者?”

于是,Peter意识到接口即便在重重情景都很有用,可是当用作事件时,“粒度”不够好。他期待能够仅在人家想要时才布告他们,于是她操纵把接口的不贰诀窍分别为单身的信托,每一个委托都像1个小的接口方法:

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();
    }
}

静态监听者

那样,Peter不会再拿他总首席营业官不想要的风云来烦他首席营业官了,不过她还没有把宇宙放到他的监听者列表中。因为宇宙是个兼容1切的实体,看来不相符选择实例方法的寄托(想像一下,实例化四个“宇宙”要开销多少财富…..),于是Peter就必要能够对静态委托进行沟通,委托对那点支撑得很好:

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();
    }
}

事件

欠好的是,宇宙太忙了,也不习惯时刻关心它在那之中的私有,它可以用自个儿的寄托替换了彼得首席营业官的寄托。这是把Peter的Worker类的的委托字段做成public的三个无意识的副作用。同样,即便彼得的小业主不耐烦了,也可以决定本人来振奋Peter的寄托(真是2个强行的COO):

// Peter’s boss taking matters into his own hands
if( peter.completed != null ) peter.completed();
Peter不想让那一个事发生,他意识到须要给各个委托提供“注册”和“反注册”功能,这样监听者就足以友善加上和移除委托,但还要又不能够清空整个列表也无法随随便便激发Peter的风浪了。Peter并不曾来自身达成那些职能,相反,他选拔了event关键字让C#编写翻译器为她营造这一个点子:

class Worker {

    public event WorkStarted started;
    public event WorkProgressing progressing;
    public event WorkCompleted completed;
}

Peter知道event关键字在信托的内地包装了1个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();
}

“收获”全数结果

到那儿,Peter终于得以送一口气了,他不负众望地满足了独具监听者的供给,同时制止了与一定完毕的紧耦合。不过她小心到她的首席营业官娘和大自然都为它的干活打了分,不过她仅仅接收了2个分数。面对几个监听者,他想要“收获”全数的结果,于是她深远到代办里面,轮询监听者列表,手工业四个个调用:

public void DoWork() {
    …
    Console.WriteLine(““工作: 工作成就””);
    if( completed != null ) {
        foreach( WorkCompleted wc in completed.GetInvocationList() ) {
            int grade = wc();
            Console.WriteLine(“工人的干活得分=” + grade);
        }
    }
}

异步布告:激发 & 忘掉

并且,他的业主和大自然还要忙于处理别的业务,约等于说他们给Peter打分所消费的风浪变得可怜长:

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;
    }
    …
}
很懊恼,Peter每一次布告贰个监听者后必须等待它给协调打分,未来那些通告开销了他太多的行事事件。于是她操纵忘掉分数,仅仅异步激发事件:

public void DoWork() {
    …
    Console.WriteLine(““工作: 工作完结””);
    if( completed != null ) {
        foreach( WorkCompleted wc in completed.GetInvocationList() )
        {
            wc.BeginInvoke(null, null);
        }
    }
}

异步通告:轮询

那使得Peter能够通报他的监听者,然后随即赶回工作,让进程的线程池来调用这一个代理。随着岁月的过逝,彼得发现她丢掉了她干活的反映,他掌握听取外人的讴歌和大力干活同样主要,于是他异步激发事件,但是周期性地轮询,取得可用的分数。

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);
        }
    }
}

异步公告:委托

倒霉地,Peter有重回了1起来就想制止的情况中来,比如,COO站在私行望着她工作。于是,他控制利用本身的嘱托作为他调用的异步委托完毕的关照,让她自身立即回到工作,可是仍可以够在旁人给她的劳作打分后拿走关照:

    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);
    }

自然界中的幸福

Peter、他的CEO娘和宇宙最终都满意了。Peter的业主和大自然能够接收他们感兴趣的风浪通报,收缩了贯彻的负责和非必需的来回来去“出差旅行费”。Peter能够通告他们,而不论他们要花多久来从目的方法中回到,同时又足以异步地获得她的结果。Peter知道,那并不*十分*简不难单,因为当他异步激发事件时,方法要在别的3个线程中推行,彼得的目标方法成功的打招呼也是相同的道理。不过,Mike和Peter是好对象,他很熟习线程的事情,能够在那么些世界提供带领。

他俩永远幸福地生活下去……<完>

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图