描绘在面前

描绘于前

  于学异步,有各项园友推荐了《async in
C#5.0》,没找到中文版,恰巧也想增强下英文,用自己拙劣的英文翻译一些重点的一些,纯属娱乐,简单分享,保持上,谨记谦虚。

  在模仿异步,有个园友推荐了《async in
C#5.0》,没找到中文版,恰巧也想增强下英文,用自家拙劣的英文翻译一些最主要之片段,纯属娱乐,简单分享,保持上,谨记谦虚。

  如果您当这起事情没意义翻译的又差,尽情的践踏吧。如果你觉得值得鼓励,感谢留下您的称,愿爱技术的园友们于后来各国一样软当重突破之上,不选知难而退。在各个一样破当单独思想的时段,不拣按照波逐流,应该尽力的时候,不挑尽量,不辜负每一样秒存在的意思。

  如果你觉得就起事情没意义翻译的又不同,尽情的践踏吧。如果您当值得鼓励,感谢留下您的歌唱,愿爱技术之园友们于之后各一样次于当可以突破的时刻,不挑知难而退。在每一样差当单独思考的当儿,不选按波逐流,应该奋力的时光,不选择尽量,不辜负每一样秒存在的义。

  
转载和爬虫请注明原文链接http://www.cnblogs.com/tdws/p/5659003.html,博客园
蜗牛 2016年6月27日。

  
转载以及爬虫请注明原文链接http://www.cnblogs.com/tdws/p/5659003.html,博客园
蜗牛 2016年6月27日。

图片 1

图片 2

目录

目录

第01回 异步编程介绍

第01章 异步编程介绍

第02章 为什么以异步编程

第02章 为什么采取异步编程

第03章节 手动编写异步代码

第03回 手动编写异步代码

第04章 编写Async方法

第04章 编写Async方法

第05章 Await究竟做了呀

第05段 Await究竟开了什么

第06章节
以Task为根基的异步模式

第06章
以Task为底蕴的异步模式

第07段 异步代码的一些家伙

第07章节 异步代码的部分器

第08回 哪个线程在运作而的代码

第08节 哪个线程在运行而的代码

第09章节 异步编程中之死去活来

第09回 异步编程中之异常

第10章 并行使用异步编程

第10段 并行使用异步编程

第11章 单元测试你的异步代码

第11章 单元测试你的异步代码

第12章 ASP.NET应用被的异步编程

第12章 ASP.NET应用中之异步编程

第13段 WinRT应用被之异步编程

第13章节 WinRT应用被的异步编程

第14章 编译器在底层为你的异步做了啊

第14段 编译器在底层为而的异步做了呀

第15回 异步代码的性能

第15章 异步代码的性

await究竟开了哟?

await究竟做了呀?

  我们发出零星栽角度来对待C#5.0之async功能特色,尤其是await关键字上闹了呀:

  我们发三三两两种角度来对C#5.0底async功能特色,尤其是await关键字上发生了什么:

  ·作为一个言语的机能特色,他是一个供应您上之曾定义好之表现

  ·作为一个言语的作用特色,他是一个供应您念的已经定义好之行为

  ·作为一个于编译时之转换,这是一个C#语法糖,为了简略之前复杂的异步代码

  ·作为一个在编译时之转移,这是一个C#语法糖,为了简略之前复杂的异步代码

  这都是当真;它们就比如相同枚硬币的有数迎。在本章,我们将会晤集中在首先接触上来探索异步。在次十四章我们拿会打另外一个角度来探讨,即再复杂的,但是提供了片细节而debug和总体性考虑越来越分明。

  这还是实在;它们就是像相同朵硬币的鲜冲。在本章,我们拿会集中在第一触及及来探讨异步。在程序十四章咱用会由任何一个角度来探索,即再扑朔迷离的,但是提供了有些细节要debug和性考虑进一步清楚。

休眠和唤醒一个智

休眠和提醒一个道

   当你的程序执行遇到await关键字时,我们纪念要出两桩事:

   当您的程序执行遇到await关键字时,我们纪念要产生两码事:

  
·为了使您的代码异步,当前实行你代码的线程应该叫释放。这象征,在普通,同步的角度来拘禁,你的主意应该回到。

  
·为了使您的代码异步,当前实践你代码的线程应该受放飞。这代表,在普通,同步的角度来拘禁,你的计应该回到。

  
·当你await的Task完成时,你的不二法门应该从之前的职务连续,就像其从未在早些时候被归。

  
·当你await的Task完成时,你的点子应该由前面的岗位连续,就如她从未在早些时候被归。

  为了成功这个作为,你的方要于碰到await时暂停,然后以明天的有时刻恢复执行。

  为了成功这作为,你的艺术必须在碰到await时刹车,然后于前之某时刻恢复执行。

  我管此历程作为一个蛰伏一令计算机的稍框框情况来拘禁(S4
sleep)。这个法当前底状态会给储存起来(译者:状态存储起来,正如我们第二回厨房特别例子,厨师会把已经在烤箱中之食物的烹调状态为标签的款式贴在面),并且是办法了剥离(厨师走了,可能失去举行其他工作了)。当一华电脑休眠,计算机的动态数据和运作数据为保留到磁盘,并且变得净关闭。下面就段话和处理器休眠大概一个理,一个正值await的章程除了用一点内存,不动另外资源,那么可作为是刚刚推行的线程已经为放。

  我拿这个进程作为一个休眠一宝电脑的有些圈圈情况来拘禁(S4
sleep)。这个点子当前的状态会受贮存起来(译者:状态存储起来,正如我们第二回厨房特别例子,厨师会将曾经居烤箱中的食品的烹饪状态为标签的款式贴于点),并且这个方法了脱离(厨师走了,可能失去开另外业务了)。当一高微机休眠,计算机的动态数据和周转数据被封存至磁盘,并且变得全关闭。下面这段话与处理器休眠大概一个道理,一个在await的点子除了用一点内存,不行使任何资源,那么好作为是刚刚推行之线程已经深受保释。

      
进一步用类似上一样段子的类似比较:一个阻塞型方法更如您暂停一尊微机(S3
sleep),它则使于少的资源,但从根本上来讲它一直以运行着。

      
进一步使类似上同一段落的类比较:一个阻塞型方法重复像而暂停一高计算机(S3
sleep),它则使于少之资源,但从根本上来讲它直接当运作在。

  于精彩的情下,我们盼望编程者察觉不交此的休眠。尽管实际上休眠和提醒一个道的中实施是老大复杂的,C#为拿会确保您的代码被提示,就像什么还尚未出同样。(译者:不得不称微软对语法糖的包裹和拍卖)。

  于大好的情况下,我们要编程者察觉不交这里的休眠。尽管实际上休眠和唤醒一个道的中实施是殊复杂的,C#啊将会晤保证您的代码被提拔,就像什么还尚未发同样。(译者:不得不赞叹微软对语法糖的包和处理)。

方法的状态

方法的状态

  为了准确的整治明白在您利用await时C#究竟为咱召开了小事情,我想列有具有关于艺术状态的具备我们铭记和了解的细节。

  为了规范之干明白在您用await时C#到底为咱做了多少工作,我想列有装有有关艺术状态的有我们记住和询问的底细。

  首先,你方中本地的变量的值会被铭记,包括因下值:

  首先,你道中本地的变量的值会被记住,包括为下值:

  ·你方的参数

  ·你道的参数

  ·在本范围外所有你定义的变量

  ·在本范围外有所你定义的变量

  ·其他变量包括循环数

  ·其他变量包括循环数

  ·如果你的点子非静态,那么连this变量。这样,你好像的分子变量在道唤醒时犹是可用之。

  ·如果你的法非静态,那么连this变量。这样,你仿佛的成员变量在点子唤醒时都是可用的。

  他们还于存在.NET
垃圾回收堆(GC堆)的一个对象上。因此当您利用await时,一个消耗一些资源的靶子将会晤受分配,但是以大部景下非用担心性能问题。

  他们都吃存在.NET
垃圾回收堆(GC堆)的一个靶及。因此当您以await时,一个消耗一些资源的目标将会晤受分配,但是在多数情况下不用担心性能问题。

  C#呢会铭记在法的哎位置会履到await。这得行使数字存储起来,用来表示await关键字在现阶段方式的职务。

  C#啊会铭记在点子的哎位置会履到await。这好采取数字存储起来,用来表示await关键字于时下法的职位。

  在有关怎样使await关键字没啊特别的范围,例如,他们可为用在一个增长表达式上,可能带有不止一个await:

  以有关怎样行使await关键字没啊特别的限量,例如,他们可以让用当一个增长表达式上,可能包含不止一个await:

int myNum = await AlexsMethodAsync(await myTask, await StuffAsync());
int myNum = await AlexsMethodAsync(await myTask, await StuffAsync());

  为了去记住剩余部分的表达式的状态在await某些事物常常,增加了额外的格。比如,当我们运行await
StuffAsync()时,await
myTask的结果待被铭记。.NET中间语言(IL)在栈上存储这种子类表达式,因此
,这个库房就是咱们await关键字用仓储的。

  为了失去记住剩余部分的表达式的状态在await某些事物时,增加了额外的条件。比如,当我们运行await
StuffAsync()时,await
myTask的结果需让记住。.NET中间语言(IL)在栈上存储这种子类表达式,因此
,这个库房就是咱await关键字用仓储的。

  最要紧之是,当程序执行到第一独await关键字时,方法就赶回了(译者:关于艺术以遇到await时回来,建议读者从第一章拆分的有限个措施来理解)。如果她不是一个async
void方法,一个Task在这随时给归,因此调用者可以等我们以某种方式成就。C#呢必须存储一种植操作返回的Task的法子,这样当您的办法好,这个Task也移得completed,并且执行者也可以回到到方式的异步链当中。确切的体制以见面在第十四章中介绍。

  最要害的凡,当程序执行到第一个await关键字时,方法就是回到了(译者:关于艺术在碰到await时回来,建议读者从第一节拆分的个别单艺术来明)。如果其不是一个async
void方法,一个Task在这随时被归,因此调用者可以等我们坐某种方式就。C#啊要存储一种植操作返回的Task的方,这样当你的法好,这个Task也转移得completed,并且执行者也堪返回到方法的异步链当中。确切的建制将会见于第十四节中介绍。

上下文

上下文

  作为一个如await的历程尽量透明的一对,C#捕捉各种上下文在碰到await时,然后于回复措施而将该死灰复燃。

  作为一个一旦await的长河尽量透明底有的,C#捕捉各种上下文在遇见await时,然后在平复措施要将那个恢复。

  于有着工作受到最要的要么一头上下文(synchronization
context),即好叫用于恢复措施在一个非常类型的线程上。这对UI
app尤其重要,就是那种只能于对的线程上操作UI的(就是winform
wpf之类的)。同步上下文是一个犬牙交错的话题,第八章以见面详细分解。

  于装有事情受到极度关键的还是一道上下文(synchronization
context),即好于用来恢复措施在一个异类别的线程上。这对UI
app尤其重点,就是那种只能在是的线程上操作UI的(就是winform
wpf之类的)。同步上下文是一个错综复杂的话题,第八章将会晤详细分解。

  其他品种的上下文也会受于眼前调用的线程捕捉。他们的支配是通过一个一致名称的类似来兑现的,所以自己拿列出一些第一之光景文类型:

  其他项目的上下文也会见给由眼前调用的线程捕捉。他们之主宰是经一个如出一辙名称的类来落实之,所以我用列出一些关键的内外文类型:

  ExecutionContext

  ExecutionContext

  这是父级上下文,所有其他上下文都是她的同样片段。这是.NET的网机能,如Task使用该捕捉与散播上下文,但是它自己不带有什么作为。

  这是父级上下文,所有其他上下文都是她的平等片。这是.NET的体系功能,如Task使用那捕捉与传唱上下文,但是它们自身不分包什么表现。

  SecurityContext

  SecurityContext

  这是咱们发现并找到日常被拘在手上线程的平安信息之地方。如果你的代码需要周转在一定的用户,你或许会,模拟或去这个用户,或者ASP.NET将会见协助您兑现扮演。在这种状况下,模拟信息会设有SecurityContext。

  这是咱发现并找到日常给界定以现阶段线程的安康信息的地方。如果你的代码用周转于一定的用户,你或会,模拟或去这个用户,或者ASP.NET将会晤帮忙你实现扮演。在这种情景下,模拟信息会存在SecurityContext。

  CallContext(这个事物耳熟能详吧,相信用了EF的且掌握)

  CallContext(这个东西耳熟能详吧,相信用过EF的都了解)

  这允许编程者存储他们以逻辑线程的生命周期中一直可用的数量。即使考虑到在无数状况下出不好的呈现,它仍然可以避免程序中艺术的参数传来传去。(译者:因为若怀到callcontext里,随时都得得呀,不用通过污染参数传来传去矣)。LogicalCallContextis是一个系的足跨用应用程序域的。

  这允许编程者存储他们在逻辑线程的生命周期中一直可用之多寡。即使考虑到当广大情景下产生不好的显现,它依旧可以免程序中方法的参数传来传去。(译者:因为您怀到callcontext里,随时都可得呀,不用经过污染参数传来传去了)。LogicalCallContextis是一个连锁的好跨用应用程序域的。

      
值得注意的凡线程本地存储(TLS),它与CallContext的目标一般,但它们以异步的状况下是无干活之,因为于一个耗时操作着,线程被放出掉了,并且可能给用来拍卖任何事情了。你的点子也许被提示并实行于一个两样之线程上。

      
值得注意的是线程本地存储(TLS),它与CallContext的对象一般,但它们以异步的情状下是不做事的,因为在一个耗时操作着,线程被假释掉了,并且可能为用来拍卖任何事情了。你的方法也许被唤醒并施行于一个不等之线程上。

  C#用会见当你方恢复(resume,这里就是是只是的“恢复”)的下恢复(restore,我当这里指从内存中还原)这些类别的上下文。恢复上下文将发生局部开销,比如,一个主次于使模拟(之前的套身份之类的)的早晚并大方用到async将会转换得重新缓慢有。我提议一定变.NET创建上下文的功效,除非你当这确来必不可少。

  C#拿会当您方恢复(resume,这里虽是只有的“恢复”)的当儿恢复(restore,我以为这里指从内存中还原)这些品种的上下文。恢复上下文将出一些开发,比如,一个先后在使用模拟(之前的学身份之类的)的时候并大方使用async将会晤变换得再缓慢有。我建议一定变.NET创建上下文的效能,除非您道当下确发生必要。

await能就此当何方?

await能因此在哪里?

  await可以为此在其余标志async的道以及和艺术外多数之地方,但是生一些地方你无可知为此await。我拿解释为什么在某些情况下非允await。

  await可以据此当其余标记async的法子及同道外大部分底地方,但是来部分地方你免能够因此await。我用分解为何当一些情况下未同意await。

catch和finally块

catch和finally块

  虽然于try块中运用await是截然同意的,但是他不允以catch和finally块中动用。通常在catch和finall块被,异常依然在库中未缓解的状态,并且之后将会晤受撇下来。如果await在这个时刻前使用,栈将会见有所不同,并且抛来特别的表现拿会转换得难以定义。

  虽然当try块中以await是一心同意的,但是他未允许在catch和finally块中采取。通常以catch和finall块被,异常依然当仓房中莫缓解之状态,并且之后以见面吃废弃来。如果await在斯随时前应用,栈将会迥然不同,并且抛来很的行事将会晤换得难以定义。

  请记住替代在catch块中使block的主意是以该背后,通过返回一个布尔值来记录操作是否丢来一个老大。示例如下:

  请牢记替代以catch块中运用block的道是在那背后,通过返回一个布尔值来记录操作是否丢来一个很。示例如下:

try
{
   page = await webClient.DownloadStringTaskAsync("http://oreilly.com");
}
catch (WebException)
{
   page = await webClient.DownloadStringTaskAsync("http://oreillymirror.com");
}
try
{
   page = await webClient.DownloadStringTaskAsync("http://oreilly.com");
}
catch (WebException)
{
   page = await webClient.DownloadStringTaskAsync("http://oreillymirror.com");
}

   你得因如下方式代替:

   你可为如下方式代替:

bool failed = false;
try
{
   page = await webClient.DownloadStringTaskAsync("http://oreilly.com");
}
catch (WebException)
{
   failed = true;
}
if (failed)
{
   page = await webClient.DownloadStringTaskAsync("http://oreillymirror.com");
}
bool failed = false;
try
{
   page = await webClient.DownloadStringTaskAsync("http://oreilly.com");
}
catch (WebException)
{
   failed = true;
}
if (failed)
{
   page = await webClient.DownloadStringTaskAsync("http://oreillymirror.com");
}

  lock块

  lock块

  lock是均等种助编程人员防止其他线程和目前线程访问同一对象的法门。因为异步代码通常会释放开始执行异步的线程,并且会于回调并且有回调在一个免确定的时间量之后,即给放走掉后和开始的线程不同(译者:即使同一之线程,它呢是自由掉后的了),所以于await上加锁没有其它意义。

  lock是均等种植助编程人员防止其他线程和目前线程访问同一对象的主意。因为异步代码通常会放开始履行异步的线程,并且会为回调并且产生回调在一个勿确定的时间量之后,即给放走掉后以及始发的线程不同(译者:即使同样之线程,它吗是假释掉后的了),所以在await上加锁没有另外意义。

  
于片情形下,保护而的靶子不受起访问是深重点之,但是以未曾外线程在await期间来做客你的靶子,使用锁是从未有过必要的。在这些情况下,你的操作是起把冗余的,显式地锁定了简单不良,如下:

  
在部分情况下,保护而的目标非叫冒出访问是特别关键的,但是当从来不另外线程在await期间来走访你的目标,使用锁是从未有过必要之。在这些状况下,你的操作是来头冗余的,显式地锁定了区区差,如下:

lock (sync)
{
    // Prepare for async operation
}
    int myNum = await AlexsMethodAsync();
lock (sync)
{
    // Use result of async operation
}
lock (sync)
{
    // Prepare for async operation
}
    int myNum = await AlexsMethodAsync();
lock (sync)
{
    // Use result of async operation
}

  另外,你可以使一个类库来开展拍卖并发控制,比如NAct,我们将会晤以第十章介绍

  另外,你可以应用一个类库来进行处理并发控制,比如NAct,我们拿会以第十章介绍

  如果你不够幸运,你也许用以执行异步操作时保持某种锁。这时,你尽管用苦思冥想并小心谨慎,因为一般锁住异步调用资源,而休招争用和死锁是杀紧的。也许遇到这种情况想其他方法或重构你的次序是不过好的取舍。

  如果您不够幸运,你或用在履异步操作时保持某种锁。这时,你就算待苦思冥想并小心谨慎,因为一般锁住异步调用资源,而非招争用和死锁是不行拮据的。也许遇到这种状态想其他方法或重构你的先后是极其好之取舍。

  Linq Query表达式

  Linq Query表达式

  C#生同一种语法帮助我们更爱之夺通过写querys来达成过滤,排序,分组等目的。这些query可以吃实施于.NET平台上要更换成为数据库操作还是其他数据源操作。

  C#产生雷同栽语法帮助我们越来越便于的失去通过书写querys来达到过滤,排序,分组等目的。这些query可以吃实践于.NET平台及还是转移成数据库操作还是其他数据源操作。

IEnumerable<int> transformed = from x in alexsInts
where x != 9
select x + 2;
IEnumerable<int> transformed = from x in alexsInts
where x != 9
select x + 2;

  C#凡当大多数职是无允以Query表达式中使await关键字的。是坐这些位置会叫编译成lambda表达式,正因为这么,该lambda表达式需要标记为async关键字。只是这样含有蓄的lambda表达式不有,即使要确实如此做呢会于丁confuse。

  C#是于大部分职是休容许在Query表达式中使await关键字的。是盖这些岗位会为编译成lambda表达式,正因为如此,该lambda表达式需要标记为async关键字。只是这样含有蓄的lambda表达式不存,即使要真的如此做吗会见被人口confuse。

  我们尚是生点子,你得写当量的表达式,通过应用Linq内部带来的拓方法。然后lambda表达式变得亮了不过读,继而你呢就得记他们吧async,从而采取await了。(译者:请对照上下代码来读)

  我们尚是起道,你可形容当量的表达式,通过使用Linq内部带来的展开方法。然后lambda表达式变得理解了但读,继而你也就是足以记他们吗async,从而以await了。(译者:请对照上下代码来读书)

IEnumerable<Task<int>> tasks = alexsInts
.Where(x => x != 9)
.Select(async x => await DoSomthingAsync(x) + await DoSomthingElseAsync(x));
IEnumerable<int> transformed = await Task.WhenAll(tasks);
IEnumerable<Task<int>> tasks = alexsInts
.Where(x => x != 9)
.Select(async x => await DoSomthingAsync(x) + await DoSomthingElseAsync(x));
IEnumerable<int> transformed = await Task.WhenAll(tasks);

  为了搜集结果,我用了Task.WhenAll,这是吧Task集合所工作之家伙,我将会晤以第七章介绍细节。

  为了搜集结果,我动用了Task.WhenAll,这是吧Task集合所工作之家伙,我以见面在第七章介绍细节。

  不安全(unsafe)的代码

  不安全(unsafe)的代码

  代码被记为unsafe的匪可知包含await,非安全之代码应该形成好不可多得而该维持方法独用和免待异步。反正在编译器对await做转换的时候吗会跳出unsafe代码。(译者:我认为其实这里并非太在意啦,反正没写了unsafe关键字之代码)

  代码被记为unsafe的免克包含await,非安全的代码应该形成死难得而该保持方法独用和莫欲异步。反正在编译器对await做转换的时节呢会见跳出unsafe代码。(译者:我看其实这里并非太在意啦,反正没写过unsafe关键字的代码)

抓获异常

抓获异常

  异步方法的杀捕获被微软企划之玩命与咱们例行同步代码一样的。然而异步的错综复杂意味着她们中尚见面聊细微差别。在此处自己拿介绍异步如何简单的处理好,我耶以在第九章详尽讲解注意事项。

  异步方法的万分捕获被微软设计的玩命与咱们如常同步代码一样的。然而异步的复杂意味着他们中间尚会见稍细微差别。在这边自己以介绍异步如何简单的处理好,我为用于第九章详见讲解注意事项。

  当耗时操作完时,Task类型会生一个定义来表明成功或者败诉。最简单易行的即使是由IsFaulted属性来向他暴露,在实践进程遭到起很它的价值就是是true。await关键字用会晤发现到这一点并且会丢掉来Task中蕴藏的大。

  当耗时操作结束时,Task类型会生一个概念来表明成功还是失败。最简便易行的就算是由于IsFaulted属性来为他暴露,在实行过程中来甚它的值就是true。await关键字用会发觉到及时或多或少并且会废弃来Task中蕴含的异常。

           
如果你熟悉.NET异常机制,用或会担心生的库房跟踪在废除来十分时怎样科学的保留。这在过去可能是不可能的。然而在.NET4.5遭,这个限制于改掉了,通过一个叫做ExceptionDispatchInfo的近乎,即一个搭档十分的捕捉,抛来与科学的库跟踪的类似。

           
如果您熟悉.NET异常机制,用或会担心很的堆栈跟踪在扔来老时怎么正确的保存。这当过去或许是免容许的。然而在.NET4.5面临,这个范围受涂改掉了,通过一个叫做ExceptionDispatchInfo的接近,即一个合作十分的捕捉,抛来和不错的库房跟踪的类。

  异步方法吧克觉察到深。在实施异步方法中产生任何特别,都非会见给捕捉,他们见面趁Task的回来而回到给调用者。当有这种情况常常,如果调用者在await这个Task,那么稀将会见于此处抛出。(译者:之前有讲到十分在异步中会为传送)。在这种办法下,异常通过调用者传播,会形成一个虚拟的库房跟踪,完全就是像它发生在齐代码中相同。

  异步方法也能够觉察到不可开交。在实践异步方法中生其他异常,都无会见受捕捉,他们会趁机Task的归来而返给调用者。当有这种情形常,如果调用者在await这个Task,那么好将会当此地抛出。(译者:之前来说话到不行在异步中见面吃传送)。在这种艺术下,异常通过调用者传播,会形成一个虚构的堆栈跟踪,完全就如她起在同代码中相同。

           
我把它乘坐虚拟堆栈跟踪,因为堆栈是一个单线程拥有的如此的定义,并且以异步代码中,当前线程实际的仓库和来大那个线程的仓库可能是坏例外之。异常捕捉的凡用户意图中的堆栈跟踪,而无是C#争挑选执行这些办法的底细。

           
我把它乘坐虚拟堆栈跟踪,因为堆栈是一个单线程拥有的如此的定义,并且在异步代码中,当前线程实际的仓库和生异常那个线程的库可能是甚例外之。异常捕捉的凡用户意图中之堆栈跟踪,而休是C#争挑选执行这些方法的底细。

直到被得前面异步方法都是同台的

以至于被需要前面异步方法都是一同的

  我前面说之,使用await只能消费(调用)异步方法。直到await结果来,这个调用方法的讲话以调用他们的线程中运作,就比如一道方法一致。这十分具有现实意义,尤其是因一个一起的过程完成有异步方法链时。(译者:当用await的上,的确就是按同的顺序来施行)

  我前说的,使用await只能消费(调用)异步方法。直到await结果发生,这个调用方法的言语以调用他们之线程中运行,就如一头方法同样。这十分富有现实意义,尤其是坐一个齐声的历程一气呵成有异步方法链时。(译者:当用await的时候,的确就是以联合的逐条来推行)

  还记得之前异步方法暂停在率先不行相遇await时。即使如此,它有时为不需要暂停,因为偶然await的Task已经到位了。一个Task已经给成功的情况如下:

  还记之前异步方法暂停在第一次于碰到await时。即使如此,它有时也未需要暂停,因为有时await的Task已经到位了。一个Task已经深受成功的状况如下:

  
·他是深受创造好的,通过Task.FromResult工具方法。我们用会见当第七回详细探索。

  
·他是为创造好的,通过Task.FromResult工具方法。我们用会当第七章节详细探索。

   ·由没遇到async的async方法返回。

   ·由没遇到async的async方法返回。

   ·它运行一个实在的异步操作,但是本已经好了(很可能是由于当下线程在遇到await之前就开了某些事情)。

   ·它运行一个真的异步操作,但是今就成功了(很可能是由于当下线程在遇见await之前已举行了某些事情)。

  
·它给一个相遇await的asunc方法返回,但是所await的这前面便已经完成了。

  
·它叫一个相逢await的asunc方法返回,但是所await的是前面便曾就了。

  由于最后一个可能,一些妙趣横生之事体闹在公await一个早已好的Task,很可能是于一个深度的异步方法链中。整个链条很像了同步的。这是坐在异步方法链中,第一单await被调用的主意总是异步链最深的一个。其他的法门到达晚,最酷的章程才出机遇回到。(
The others are only reached after the deepest method has had a chance to
return
synchronously.译者:按照语法来提我之当即句话貌似翻译的匪得法,但是自个人觉得实在状况就算是自个儿说的此法。在遇到第一只await后,后面异步方法链中的await依次执行,逐个返回,最后才回到结果到最充分的方法,也尽管是率先只法子,有哲人来提出此的见地吗?)

  由于最后一个可能性,一些妙不可言的事情时有发生在公await一个既做到的Task,很可能是在一个深的异步方法链中。整个链条很像全同的。这是因以异步方法链中,第一单await被调用的法子总是异步链最老的一个。其他的点子到达后,最深的主意才出空子回到。(
The others are only reached after the deepest method has had a chance to
return
synchronously.译者:按照语法来发话自己的就句话貌似翻译的匪得法,但是自个人觉得实在状况便是自身说的这个法。在遇到第一只await后,后面异步方法链中的await依次执行,逐个返回,最后才回结果到最好充分的方式,也尽管是第一只方式,有哲人来提出此的观吗?)

  
你可能会怀疑为什么在首先种植或第二种情况下还利用async。如果这些方法承诺一直同的归来,你是无可非议的,并且这样形容同步的代码效率超过异步并且没有await的过程。然后,这不过是方并返回的景。比如,一个方式缓存其结果到内存中,并于缓存可用之时候,结果可以为一起地回,但是当它需要异步的网要。当您知发生一个吓会吃你利用异步方法,在某种程度上而或许还想如果术返回Task或者Task<T>。(异步:既然方法链中产生一个而异步,那么就会影响整体都使用异步)。

  
你可能会怀疑为什么在首先种或第二种情况下还利用async。如果这些点子承诺一直同的归来,你是科学的,并且这样勾画同步的代码效率超过异步并且没有await的过程。然后,这不过是方法并返回的情事。比如,一个术缓存其结果到内存中,并当缓存可用之时段,结果好为一道地回去,但是当它需异步的网络要。当你掌握有一个吓会吃您采取异步方法,在某种程度上你恐怕还惦记如果术返回Task或者Task<T>。(异步:既然方法链中发出一个而异步,那么就是见面潜移默化整体都采用异步)。

写于终极

形容以终极

  关于异步我还有许多困惑,也是趁文章逐步掌握,我吗指望能够尽快一些啊。

  关于异步我还有不少困惑,也是趁文章逐步了解,我耶期能尽早一些啊。

相关文章