首页 > 代码库 > 对[yield]的浅究到发现[async][await]
对[yield]的浅究到发现[async][await]
上篇对[foreach]的浅究到发现[yield]写完后,觉得对[yield]还没有理解清楚,想起曾经看过一位大牛的帖子讲的很深刻(链接在此),回顾了下,在这里写出自己的理解,与各位分享。
一、通常的异步
现在我们假设一种平时经常遇到的情况,现有三个方法,其中funcOne和funcTwo比较耗时需要异步执行,而且他们的逻辑是必须在funcOne执行完后才可以执行funcTwo,同理funcTwo执行完后才能执行funcThree。
按照这样的设定,通常的做法请看代码段[1]:
1 public class Program 2 { 3 public delegate void CallBack(string nextName); 4 public void funcOne(CallBack callback) 5 { 6 ThreadPool.QueueUserWorkItem((state1) => 7 { 8 Console.WriteLine("[One] async Continue!"); 9 Console.WriteLine("[One] do something!"); 10 callback("Called Two"); 11 }); 12 } 13 public void funcTwo(CallBack callback) 14 { 15 ThreadPool.QueueUserWorkItem((state2) => 16 { 17 Console.WriteLine("[Two] async Continue!"); 18 Console.WriteLine("[Two] do something!"); 19 callback("Called Three"); 20 }); 21 } 22 public void funcThree(CallBack callback) 23 { 24 Console.WriteLine("[Three] do something!"); 25 callback("Called ..."); 26 } 27 static void Main() 28 { 29 Program p = new Program(); 30 p.funcOne((name1) => 31 { 32 Console.WriteLine(name1); 33 p.funcTwo((name2) => 34 { 35 Console.WriteLine(name2); 36 //执行funcThree 37 p.funcThree((name3) => 38 { 39 Console.WriteLine(name3); 40 //当然还有可能继续嵌套 41 Console.WriteLine("End!"); 42 }); 43 }); 44 }); 45 Console.Read(); 46 } 47 }
相信看完代码后我们的感觉是一样的,好繁琐,就是不断的嵌套!那有没有方法可以避免这样呢,也就是说用同步的写法来写异步程序。
二、改进后的异步
该[yield]粉墨登场了,先看代码段[2]:
1 //三个方法以及委托CallBack的定义不变,此处不再列出。 2 //新增了静态的全局变量enumerator,和静态方法funcList. 3 public static System.Collections.IEnumerator enumerator = funcList(); 4 public static System.Collections.IEnumerator funcList() 5 { 6 Program p = new Program(); 7 p.funcOne((name1) => 8 { 9 enumerator.MoveNext(); 10 }); 11 yield return 1; 12 Console.WriteLine("Called Two"); 13 p.funcTwo((name2) => 14 { 15 enumerator.MoveNext(); 16 }); 17 yield return 2; 18 Console.WriteLine("Called Three"); 19 p.funcThree((name3) => 20 { 21 //当然还有可能继续嵌套 22 }); 23 Console.WriteLine("Called ..."); 24 Console.WriteLine("End!"); 25 yield return 3; 26 } 27 28 //变化后的Main函数 29 static void Main() 30 { 31 enumerator.MoveNext(); 32 Console.Read(); 33 }
现在看看,是不是清爽了一些,没有无止尽的嵌套。代码中我们只需要定义一个迭代器,在迭代器中调用需要同步执行的方法,用[yield]来分隔,各方法通过在callback里调用迭代器的MoveNext()方法来保持同步。
通过这样的实践,我们可以理解为每当[yield return ..],程序会把迭代器的[上下文环境]暂时保存下来,等到MoveNext()时,再调出来继续执行到下一个[yield return ..]。
三、是我想太多
以上纯属瞎扯,在.net 4.5之后,我们有了神器:async/await,下面看看多么简洁吧。
代码段[3]:
1 public class Program 2 { 3 public async Task funcOne() 4 { 5 Console.WriteLine("[One] async Continue!"); 6 Console.WriteLine("[One] do something!"); 7 //await ... 8 } 9 public async Task funcTwo() 10 { 11 Console.WriteLine("[Two] async Continue!"); 12 Console.WriteLine("[Two] do something!"); 13 //await ... 14 } 15 public void funcThree() 16 { 17 Console.WriteLine("[Three] do something!"); 18 } 19 public static async Task funcList() 20 { 21 Program p = new Program(); 22 await p.funcOne(); 23 await p.funcTwo(); 24 p.funcThree(); 25 //无尽的嵌套可以继续await下去。 26 Console.WriteLine("End!"); 27 } 28 static void Main() 29 { 30 funcList(); 31 Console.Read(); 32 } 33 }
我已经感觉到了您的惊叹之情。
async修饰符将方法指定为异步方法(注意!:异步不异步,并不是async说了算,如果这个方法中没有await语句,就算用了async修饰符,它依然是同步执行,因为它就没有异步基因)。
被指定为异步方法后,方法的返回值只能为Task、Task<TResult>或者void,返回的Task对象用来表示这个异步方法,你可以对这个Task对象进行控制来操作这个异步方法,详细的可以参考msdn中给出的Task解释与示例代码。
await用于挂起主线程(这里的主线程是相对的),等待这个异步方法执行完成并返回,接着才继续执行主线程的方法。用了await,主线程才能得到异步方法返回的Task对象,以便于在主线程中对它进行操作。如果一个异步方法调用时没有用await,那么它就会去异步执行,主线程不会等待,就像我们代码段[3]中Main方法里对funcList方法的调用那样。
最后就分析到这儿吧,希望各位兄弟博友能一起讨论,共同进步。
当然,别吝啬您的[赞]哦 :)
更新:现在大家看到的是改进之后的文章,在此谢谢文章下面几位高手的讨论,让我学会了不少。抱拳!