他的业主来落成他的应允bt365体育在线

英文版原作者:ChrisSells(www.sellsbrothers.com
翻译:袁晓辉(www.farproc.com
http://blog.csdn.net/uoyevoli
原文地址: http://dev.csdn.net/article/82/82644.shtm

 

过去,在南方一块奇异的土地上,有个工友名叫Peter,他那多少个辛苦,对她的小业主连连百依百顺。可是他的老董娘是个吝啬的人,从不信任别人,坚决必要随时精通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() { /* 老总不关怀。 */ }    
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成了一个非正规的人,他不但能容忍吝啬的业主,而且和他周围的天体也有了精心的联络,以至于他认为宇宙对他的工作进程也感兴趣。不幸的是,他必须也给宇宙添加一个独特的回调函数Advise来促成同时向她经理和宇宙报告工作进程。Peter想要把潜在的关照的列表和那一个公告的落到实处方式分别开来,于是她操纵把办法分别为一个接口:

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() { /*
老董不关心。 */ }     public void WorkProgressing() { /* CEO不爱抚。
*/ }     public int WorkCompleted() {        
Console.WriteLine(“时间大多!”);         return 3; /* 总分为10 */
    } }

委托

噩运的是,每当Peter忙于通过接口的落到实处和老总调换时,就从未机会马上告示宇宙了。至少她应有忽视身在海外的业主的引用,好让此外落成了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!”他CEO吼道,“你怎么在干活一起头和劳作拓展中都来烦我?!我不爱慕那几个事件。你不仅强迫我落成了那几个格局,而且还在浪费自己宝贵的干活时间来处理你的事件,越发是当自己出门的时候更是如此!你能不可能不再来烦我?”

于是乎,Peter意识到接口即使在成千上万场馆都很有用,然而当用作事件时,“粒度”不够好。他期待能够仅在别人想要时才布告他们,于是他操纵把接口的不二法门分别为单独的委托,每个委托都像一个小的接口方法:

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不会再拿她主任不想要的事件来烦他总老板了,可是他还不曾把宇宙放到他的监听者列表中。因为宇宙是个包容一切的实业,看来不符合利用实例方法的委托(想像一下,实例化一个“宇宙”要开支多少资源…..),于是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的一个无意的副功能。同样,若是Peter的老总娘不耐烦了,也得以控制自己来刺激Peter的委托(真是一个凶暴的业主):

        // Peter~s boss taking matters into his own hands         if(
peter.completed != null ) peter.completed();
Peter不想让那个事暴发,他发现到须要给各类委托提供“注册”和“反注册”效率,那样监听者就可以团结充足和移除委托,但与此同时又无法清空整个列表也不可能轻易激发Peter的轩然大波了。彼得并从将来源己完成这一个功效,相反,他运用了event关键字让C#编译器为他打造那个点子:

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

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

“收获”所有结果

到那儿,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发现她丢掉了他干活的反馈,他驾驭听取外人的称扬和着力干活一样首要,于是他异步激发事件,然而周期性地轮询,取得可用的分数。

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

大自然中的幸福

Peter、他的小业主和宇宙最后都满意了。Peter的老总娘和大自然可以选用他们感兴趣的轩然大波通报,裁减了达成的负担和非必需的往返“差旅费”。Peter可以通告他们,而无论是他们要花多久来从目标方法中回到,同时又可以异步地取得他的结果。彼得知道,那并不*十分*简简单单,因为当他异步激发事件时,方法要在此外一个线程中推行,Peter的目标方法成功的打招呼也是千篇一律的道理。可是,迈克和Peter是好爱人,他很熟练线程的事情,可以在这几个领域提供率领。

 

她俩永远幸福地生存下去……<完>

紧耦合
往年,在南方一块奇异的土地上,有个工友名叫Peter,他丰盛劳顿,对她的小业主连连百依百顺。可是他的主任娘是个吝啬的人,从不信任别人,坚决要求随时明白Peter的工作进度,以预防她偷懒。可是Peter又不想让总CEO呆在她的办公里站在骨子里望着他,于是就对业主做出承诺:无论哪一天,只要我的行事获得了好几展开我都会及时让你领悟。Peter通过周期性地使用“带项目的引用”(原文为:“typed
reference” 也就是delegate??)“回调”他的COO来兑现他的承诺,如下:
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();
    }
}

接口

如今,Peter成了一个新鲜的人,他不仅能忍受吝啬的经理,而且和他方圆的大自然也有了精心的联络,以至于他以为宇宙对她的工作进程也感兴趣。不幸的是,他必须也给宇宙添加一个破例的回调函数Advise来完结同时向他老板和大自然报告工作进程。Peter想要把地下的布告的列表和那个通告的得以达成方式分别开来,于是他决定把措施分别为一个接口:

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忙于通过接口的完毕和业主调换时,就一直不机会及时通报宇宙了。至少她应该忽视身在国外的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” 原话如此,不明了到底是怎样意思 )

她的CEO依然抱怨得很厉害。“Peter!”他老董吼道,“你干吗在办事一最先和办事展开中都来烦我?!我不关怀那个事件。你不单强迫自己完成了这几个措施,而且还在荒废自己宝贵的劳作时间来拍卖你的轩然大波,尤其是当我出门的时候更是如此!你能否不再来烦我?”

于是,Peter意识到接口固然在许多景况都很有用,不过当用作事件时,“粒度”不够好。他期望可以仅在旁人想要时才公告他们,于是她控制把接口的措施分别为单身的寄托,每个委托都像一个小的接口方法:

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不会再拿他COO不想要的风云来烦他高管了,可是她还一贯不把宇宙放到他的监听者列表中。因为宇宙是个包容一切的实体,看来不符合选择实例方法的嘱托(想像一下,实例化一个“宇宙”要费用多少资源…..),于是彼得就需求可以对静态委托开展联络,委托对那点支撑得很好:

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的一个无意的副成效。同样,即使Peter的业主不耐烦了,也足以决定自己来刺激Peter的信托(真是一个粗犷的老董娘):

// 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关键字在委托的外地包装了一个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);
        }
    }
}

异步公告:激发 & 忘掉

与此同时,他的业主和大自然还要忙于处理其余业务,也就是说他们给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;
    }
    …
}
很不佳,彼得每一次布告一个监听者后必须等待它给协调打分,现在这几个文告开销了他太多的干活事件。于是她决定忘掉分数,仅仅异步激发事件:

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

异步布告:委托

噩运地,Peter有重返了一初阶就想防止的事态中来,比如,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、他的老董娘和大自然最后都满意了。Peter的老董和宇宙可以收到他们感兴趣的事件通报,裁减了已毕的负责和非必需的往来“差旅费”。Peter可以通报他们,而无论是他们要花多久来从目标方法中回到,同时又可以异步地得到他的结果。Peter知道,这并不*十分*粗略,因为当他异步激发事件时,方法要在其余一个线程中推行,Peter的目标方法成功的文告也是千篇一律的道理。但是,迈克和Peter是好对象,他很熟稔线程的事情,可以在那个领域提供指引。

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

相关文章