澳门1495

寄托的成效,睡觉前旧事

九月 6th, 2019  |  澳门新葡亰

英文版原来的著笔者: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??)“回调”他的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() { /* COO不关心。 */ }    
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成了三个出色的人,他不只有能耐受吝啬的总COO娘,并且和她相近的宇宙空间也可能有了细致的牵连,以至于他以为宇宙对她的工作进程也感兴趣。不幸的是,他必须也给宇宙增多一个独竖一帜的回调函数Advise来落到实处同期向她COO和大自然报告专门的学问进程。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() { /*
COO不关切。 */ }     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!”他老总吼道,“你为何在劳作一起首和劳作扩充中都来烦笔者?!作者不关怀这个事件。你非但强迫本身落成了那个方法,何况还在荒芜本人宝贵的办事时间来拍卖你的风波,非常是当自家出门的时候更是如此!你能否不再来烦小编?”

于是乎,彼得意识到接口即使在大多景况都很有用,然则当用作事件时,“粒度”远远不足好。他期望能够仅在别人想要时才通告他们,于是他决定把接口的方式分别为独立的嘱托,各样委托都像一个小的接口方法:

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主任的委托。那是把彼得的Worker类的的嘱托字段做成public的多少个下意识的副功效。一样,如若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();     }

“收获”全部结果

到此刻,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(1);                 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、他的小业主和宇宙最后都满意了。彼得的CEO娘和大自然能够摄取他们感兴趣的平地风波通报,减弱了落到实处的担任和非必须的往返“出差旅行费”。Peter可以布告他们,而不论是他们要花多久来从指标方法中回到,同有的时候间又能够异步地猎取她的结果。Peter知道,那并不*十分*一句话来讲,因为当他异步激发事件时,方法要在别的贰个线程中实践,Peter的指标方法成功的关照也是大同小异的道理。然则,迈克和Peter是好对象,他很熟稔线程的政工,能够在那一个领域提供教导。

 

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

紧耦合
往昔,在西部一块离奇的土地上,有个工人名为彼得,他不行努力,对他的CEO娘连连百依百顺。可是她的COO是个吝啬的人,从不信任外人,坚决要求随时驾驭Peter的事业进度,以幸免她偷懒。但是Peter又不想让业主呆在他的办公室里站在偷偷瞅着她,于是就对老总做出承诺:无论曾几何时,只要自个儿的劳作获得了有些进展笔者都会霎时令你驾驭。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来促成同一时间向他COO和大自然报告专门的学问进程。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() { /* COO不关切。 */ }
    public void WorkProgressing() { /* 老总不关注。 */ }
    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 IWorkerEvents interface could be
notified of his work progress” 原话如此,不知道到底是怎样意思 )

她的业主还是抱怨得极屌。“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了,不过她还未有把宇宙放到他的监听者列表中。因为宇宙是个包容一切的实体,看来不适合利用实例方法的寄托(想像一下,实例化二个“宇宙”要费用多少财富…..),于是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的寄托(真是七个暴虐的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关键字在信托的异乡包装了贰个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每一次公告二个监听者后必需等待它给自身打分,未来那个通告费用了她太多的劳作事件。于是他垄断(monopoly)忘掉分数,仅仅异步激发事件:

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是好相爱的人,他很熟练线程的专门的学业,能够在那么些领域提供辅导。

她俩世世代代幸福地活着下去……<完>

相关文章

Your Comments

近期评论

    功能


    网站地图xml地图