[C#] 走进异步编程的世界 - 剖析异步方法（下）

走进异步编程的世界 - 剖析异步方法（下）

序

　　感谢大家的支持，这是昨天发布《走进异步编程的世界 - 剖析异步方法（上）》的补充篇。

目录

• 异常处理
• 在调用方法中同步等待任务
• 在异步方法中异步等待任务
• Task.Delay() 暂停执行

　　

一、异常处理

　　await 表达式也可以使用 try...catch...finally 结构。

     internal class Program
     {
         private static void Main(string[] args)
         {
             var t = DoExceptionAsync();
             t.Wait();

             Console.WriteLine($"{nameof(t.Status)}: {t.Status}");   //任务状态
             Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}");     //任务完成状态标识
             Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}");     //任务是否有未处理的异常标识

             Console.Read();
         }

         /// <summary>
         /// 异常操作
         /// </summary>
         /// <returns></returns>
         private static async Task DoExceptionAsync()
         {
             try
             {
                 await Task.Run(() => { throw new Exception(); });
             }
             catch (Exception)
             {
                 Console.WriteLine($"{nameof(DoExceptionAsync)} 出现异常！");
             }
         }
     }

图1-1

　　【分析】await 表达式位于 try 块中，按普通的方式处理异常。但是，为什么图中的状态（Status）、是否完成标识（IsCompleted）和是否失败标识（IsFaulted）分别显示：运行完成（RanToCompletion） 、已完成（True） 和 未失败（False） 呢？因为：任务没有被取消，并且异常都已经处理完成！

二、在调用方法中同步等待任务

　　调用方法可能在某个时间点上需要等待某个特殊的 Task 对象完成，才执行后面的代码。此时，可以采用实例方法 Wait 。

     internal class Program
     {
         private static void Main(string[] args)
         {
             var t = CountCharactersAsync("http://www.cnblogs.com/liqingwen/");

             t.Wait();   //等待任务结束
             Console.WriteLine($"Result is {t.Result}");

             Console.Read();
         }

         /// <summary>
         /// 统计字符数量
         /// </summary>
         /// <param name="address"></param>
         /// <returns></returns>
         private static async Task<int> CountCharactersAsync(string address)
         {
             var result = await Task.Run(() => new WebClient().DownloadStringTaskAsync(address));
             return result.Length;
         }
     }

图2-1

　　Wait() 适合用于单一 Task 对象，如果想操作一组对象，可采用 Task 的两个静态方法 WaitAll() 和 WaitAny() 。

     internal class Program
     {
         private static int time = ;
         private static void Main(string[] args)
         {
             var t1 = GetRandomAsync();
             var t2 = GetRandomAsync();

             //IsCompleted 任务完成标识
             Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
             Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");

             Console.Read();
         }

         /// <summary>
         /// 获取一个随机数
         /// </summary>
         /// <param name="id"></param>
         /// <returns></returns>
         private static async Task<int> GetRandomAsync(int id)
         {
             var num = await Task.Run(() =>
             {
                 time++;
                 Thread.Sleep(time * );
                 return new Random().Next();
             });

             Console.WriteLine($"{id} 已经调用完成");
             return num;
         }
     }

图2-2 两个任务的 IsCompleted 属性都显示未完成

　　现在，在 Main() 方法中新增两行代码（6 和 7 两行），尝试调用 WaitAll() 方法。

         private static void Main(string[] args)
         {
             var t1 = GetRandomAsync();
             var t2 = GetRandomAsync();

             Task<int>[] tasks = new Task<int>[] { t1, t2 };
             Task.WaitAll(tasks);    //等待任务全部完成，才继续执行

             //IsCompleted 任务完成标识
             Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
             Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");

             Console.Read();
         }

图2-3 两个任务的 IsCompleted 属性都显示 True

　　现在，再次将第 7 行改动一下，调用 WaitAny() 方法试试。

         private static void Main(string[] args)
         {
             var t1 = GetRandomAsync();
             var t2 = GetRandomAsync();

             Task<int>[] tasks = new Task<int>[] { t1, t2 };
             Task.WaitAny(tasks);    //等待任一 Task 完成，才继续执行

             //IsCompleted 任务完成标识
             Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
             Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");

             Console.Read();
         }

图2-4 有一个任务的 IsCompleted 属性显示 True （完成） 就继续执行

三、在异步方法中异步等待任务

　　上节说的是如何使用 WaitAll() 和 WaitAny() 同步地等待 Task 完成。这次我们使用 Task.WhenAll() 和 Task.WhenAny()  在异步方法中异步等待任务。

     internal class Program
     {
         private static int time = ;

         private static void Main(string[] args)
         {
             var t = GetRandomAsync();

             Console.WriteLine($"t.{nameof(t.IsCompleted)}: {t.IsCompleted}");
             Console.WriteLine($"Result: {t.Result}");

             Console.Read();
         }

         /// <summary>
         /// 获取一个随机数
         /// </summary>
         /// <param name="id"></param>
         /// <returns></returns>
         private static async Task<int> GetRandomAsync()
         {
             time++;
             var t1 = Task.Run(() =>
             {
                 Thread.Sleep(time * );
                 return new Random().Next();
             });

             time++;
             var t2 = Task.Run(() =>
             {
                 Thread.Sleep(time * );
                 return new Random().Next();
             });

             //异步等待集合内的 Task 都完成，才进行下一步操作
             await Task.WhenAll(new List<Task<int>>() { t1, t2 });

             Console.WriteLine($"    t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
             Console.WriteLine($"    t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");

             return t1.Result + t2.Result;
         }
     }

图3-1 调用 WhenAll()  方法

　　【注意】WhenAll() 异步等待集合内的 Task 都完成，不会占用主线程的时间。

　

　　现在，我们把 GetRandomAsync() 方法内的 WhenAll() 方法替换成 WhenAny()，并且增大一下线程挂起时间，最终改动如下：

         private static async Task<int> GetRandomAsync()
         {
             time++;
             var t1 = Task.Run(() =>
             {
                 Thread.Sleep(time * );
                 return new Random().Next();
             });

             time++;
             var t2 = Task.Run(() =>
             {
                 Thread.Sleep(time * );   //这里由 100 改为 500，不然看不到效果
                 return new Random().Next();
             });

             //异步等待集合内的 Task 都完成，才进行下一步操作
             //await Task.WhenAll(new List<Task<int>>() { t1, t2 });
             await Task.WhenAny(new List<Task<int>>() { t1, t2 });

             Console.WriteLine($"    t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
             Console.WriteLine($"    t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");

             return t1.Result + t2.Result;
         }

图3-2 调用 WhenAny() 方法

四、Task.Delay() 暂停执行

　　Task.Delay() 方法会创建一个 Task 对象，该对象将暂停其在线程中的处理，并在一定时间之后完成。和 Thread.Sleep 不同的是，它不会阻塞线程，意味着线程可以继续处理其它工作。

     internal class Program
     {
         private static void Main(string[] args)
         {
             Console.WriteLine($"{nameof(Main)} - start.");
             DoAsync();
             Console.WriteLine($"{nameof(Main)} - end.");

             Console.Read();
         }

         private static async void DoAsync()
         {
             Console.WriteLine($"    {nameof(DoAsync)} - start.");

             await Task.Delay();

             Console.WriteLine($"    {nameof(DoAsync)} - end.");
         }
     }

图4-1

传送门

　　入门：《开始接触 async/await 异步编程》

　　上篇：《走进异步编程的世界 - 剖析异步方法（上）》

　　下篇：《走进异步编程的世界 - 在 GUI 中执行异步操作》

---

【原文链接】http://www.cnblogs.com/liqingwen/p/5866241.html

【参考】《Illustrated C# 2012》