澳门1495

澳门新葡亰寄托的职能,睡前传说

三月 9th, 2019  |  澳门新葡亰

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

 

过去,在西部一块奇异的土地上,有个工友名叫彼得,他格外辛勤,对他的业主连连百依百顺。可是她的小业主是个吝啬的人,从不信任旁人,坚决供给随时领悟彼得的工作进程,以预防她偷懒。然则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() { /* 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();     } }

接口

于今,彼得成了一个非常的人,他不只好隐忍吝啬的小业主,而且和他方圆的宇宙空间也有了细致的关联,以至于他认为宇宙对他的工作进程也感兴趣。不幸的是,他必须也给宇宙添加二个出奇的回调函数Advise来落到实处同时向他老董和宇宙报告工作进程。Peter想要把地下的通告的列表和那一个布告的兑现情势分别开来,于是她控制把措施分别为1个接口:

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() { /* 总COO不关怀。
*/ }     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!”他老总吼道,“你为什么在劳作一初步和劳作拓展中都来烦作者?!小编不关怀这几个事件。你不但强迫我完毕了那么些情势,而且还在浪费本身宝贵的行事时间来处理你的事件,尤其是当自身出门的时候更是如此!你能或不能够不再来烦作者?”

于是乎,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不会再拿她CEO不想要的轩然大波来烦他老董了,不过他还从未把宇宙放到他的监听者列表中。因为宇宙是个包容一切的实业,看来不相符接纳实例方法的信托(想像一下,实例化2个“宇宙”要成本多少财富…..),于是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终于能够送一口气了,他不负众望地满意了独具监听者的必要,同时防止了与一定完成的紧耦合。不过他留意到她的小业主和宇宙都为它的办事打了分,不过他独自接收了一个分数。面对三个监听者,他想要“收获”全体的结果,于是他长远到代办里面,轮询监听者列表,手工业3个个调用:

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

异步公告:轮询

那使得彼得能够布告她的监听者,然后随即回到工作,让进度的线程池来调用这一个代理。随着时光的千古,彼得发现他丢掉了她工作的上报,他通晓听取旁人的歌唱和大力干活同样主要,于是她异步激发事件,然则周期性地轮询,取得可用的分数。

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、他的小业主和大自然最后都满意了。Peter的首席执行官娘和宇宙能够接收他们感兴趣的风浪通报,收缩了贯彻的承受和非必需的过往“出差旅行费”。Peter能够通报他们,而任由他们要花多久来从目的方法中回到,同时又有什么不可异步地收获他的结果。Peter知道,那并不*十分*不难,因为当她异步激发事件时,方法要在其余二个线程中施行,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() { /* 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成了3个万分的人,他不光能忍受吝啬的COO,而且和他方圆的宇宙也有了密切的交流,以至于他认为宇宙对他的工作进程也感兴趣。不幸的是,他必须也给宇宙添加三个出奇的回调函数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() { /* 老板不敬爱。 */ }
    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不会再拿她老总不想要的风云来烦他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的1个下意识的副作用。同样,假如Peter的首席营业官娘不耐烦了,也得以控制自身来鼓舞彼得的嘱托(真是3个强行的业主):

// 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关键字在信托的异地包装了3个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();
}

“收获”全体结果

到那时,彼得终于得以送一口气了,他成功地满意了装有监听者的需要,同时幸免了与特定完成的紧耦合。不过他在意到她的老总和大自然都为它的干活打了分,然则她单独接收了3个分数。面对多少个监听者,他想要“收获”全数的结果,于是他尖锐到代办里面,轮询监听者列表,手工业二个个调用:

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知道,那并不*十分*简不难单,因为当他异步激发事件时,方法要在其它1个线程中实施,Peter的目标方法成功的关照也是千篇一律的道理。不过,Mike和彼得是好爱人,他很熟习线程的事务,能够在那一个圈子提供辅导。

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

Your Comments

近期评论

    功能


    网站地图xml地图