C#沉淀-异步编程 二

针对于await表达式的异常处理

using System;
using System.Net;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Threading;

namespace CodeForAsync
{

    class Program
    {
        //定义一个异步方法
        static async Task BadAsync()
        {
            try
            {
                //故意抛出一个异常
                await Task.Run(() => { throw new Exception(); });
            }
            catch (Exception ex)
            {
                //捕获异常
                Console.WriteLine("捕获一个异步"+ex.ToString());
            }
        }
        
        static void Main(string[] args)
        {
            Task t = BadAsync();
            t.Wait();

            Console.WriteLine("查看异步方法的状态："+t.Status);
            Console.WriteLine("查看是否有未经处理的异常："+t.IsFaulted);

            Console.ReadKey();
        }
    }
}

输出：

捕获一个异步System.Exception: 引发类型为“System.Exception”的异常。
   在 CodeForAsync.Program.<BadAsync>b__0() 位置 f:\我的文档\文档\C# 沉淀\CodeForAsync\CodeForAsync\Program.cs:行号 18
   在 System.Threading.Tasks.Task`1.InnerInvoke()
   在 System.Threading.Tasks.Task.Execute()
--- 引发异常的上一位置中堆栈跟踪的末尾 ---
   在 System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
   在 System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
   在 System.Runtime.CompilerServices.TaskAwaiter.GetResult()
   在 CodeForAsync.Program.<BadAsync>d__2.MoveNext() 位置 f:\我的文档\文档\C# 沉淀\CodeForAsync\CodeForAsync\Program.cs:行号 18
查看异步方法的状态：RanToCompletion
查看是否有未经处理的异常：False

从输出结果来看，Task的状态为RanToCompletion，说明即使捕获到异常也不会令Task终止或取消；IsFaulted的状态为False，说明没有未处理的异常

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

Task提供了一个实例方法Wait，可以在Task上调用该方法，同步的等待任务的完成

示例：

using System;
using System.Net;
using System.Diagnostics;
using System.Threading.Tasks;

namespace CodeForAsync
{
    static class MyDownloadString
    {
        public static void DoRun()
        {
            Task<int> t1 = CountCharactersAsync(1, "http://baidu.com");

            //等待任务结束
            t1.Wait();
            Console.WriteLine("任务已经结束，值：" + t1.Result);
        }

        //下载网站资源
        private static async Task<int> CountCharactersAsync(int id, string uristring)
        {
            string result = await (new WebClient()).DownloadStringTaskAsync(new Uri(uristring));
            return result.Length;
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            MyDownloadString.DoRun();

            Console.ReadKey();
        }
    }
}

这里的Wait用在了单一的Task对象上，也可以用于一组Task上，但是需要用到Task上的两个静态方法：

示例：WaitAll和WaitAny

using System;
using System.Net;
using System.Diagnostics;
using System.Threading.Tasks;

namespace CodeForAsync
{
    class MyDownloadString
    {
        Stopwatch sw = new Stopwatch();

        public void DoRun()
        {
            //下载百度资源
            Task<int> t1 = CountCharactersAsync(1, "http://baidu.com");
            //下载搜狗资源
            Task<int> t2 = CountCharactersAsync(2, "https://pinyin.sogou.com/");

            ///WaitAll会等待所包含的所有的Task都完成后才会往下执行
            ///WaitAny会等待所包含的所有的Taks中只要有一个完成即会向下执行
            Task<int>[] tasks = new Task<int>[] { t1, t2 };
            //Task.WaitAll(tasks);
            Task.WaitAny(tasks);

            ///下面的写法也是允许的
            ///这两个静态方法接收的是Taks类型的数组
            ///下面实现了隐式的转换
            //Task.WaitAll(t1, t2);
            //Task.WaitAny(t1, t2);

            Console.WriteLine("任务一是否完成：" + (t1.IsCompleted ? "完成" : "未完成").ToString());
            Console.WriteLine("任务二是否完成：" + (t2.IsCompleted ? "完成" : "未完成").ToString());
        }

        //下载网站资源
        private async Task<int> CountCharactersAsync(int id, string uristring)
        {
            WebClient wc = new WebClient();
            string result = await wc.DownloadStringTaskAsync(new Uri(uristring));

            return result.Length;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyDownloadString ds = new MyDownloadString();
            ds.DoRun();

            Console.ReadKey();
        }
    }
}

输出：

任务一是否完成：完成
任务二是否完成：未完成

WaitAll与WaitAny有许多重载，这里简单介绍两个：

//等待所有任务完成，或CancellationToken发出了取消信号
public static void WaitAll(Task[] tasks, CancellationToken cancellationToken);

//等待所有任务完成，如果在等待时间内仍未完成，则继续往下执行
public static bool WaitAll(Task[] tasks, int millisecondsTimeout);
public static bool WaitAll(Task[] tasks, TimeSpan timeout);

//等待所有任务完成，如果发生超时或者有取消动作，则继续往下执行不再等待
public static bool WaitAll(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken);

/////////////////////////////////////////

//等待一个任务完成，或CancellationToken发出了取消信号
public static void WaitAny(Task[] tasks, CancellationToken cancellationToken);

//等待一个任务完成，如果在等待时间内仍未完成，则继续往下执行
public static bool WaitAny(Task[] tasks, int millisecondsTimeout);
public static bool WaitAny(Task[] tasks, TimeSpan timeout);

//等待一个任务完成，如果发生超时或者有取消动作，则继续往下执行不再等待
public static bool WaitAny(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken);

在异步方法中异步的等待任务

await会等待一个或所有的任务完成，

可以通过Task.WhenAll与Task.WhenAny方法来实现。这两个方法称为组合子

示例：

using System;
using System.Net;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Collections.Generic;

namespace CodeForAsync
{
    class MyDownloadString
    {
        public void DoRun()
        {
            //下载百度资源
            Task<int> t = CountCharactersAsync("http://baidu.com", "https://pinyin.sogou.com");
            Console.WriteLine("任务t是否已经完成：{0}", t.IsCompleted ? "完成" : "未完成");
            Console.WriteLine("输出值:{0}", t.Result);
        }

        //下载网站资源
        private async Task<int> CountCharactersAsync(string uristring1, string uristring2)
        {
            WebClient wc1 = new WebClient();
            WebClient wc2 = new WebClient();

            Task<string> t1 = wc1.DownloadStringTaskAsync(new Uri(uristring1));
            Task<string> t2 = wc2.DownloadStringTaskAsync(new Uri(uristring2));

            List<Task<string>> tasks = new List<Task<string>>();
            tasks.Add(t1);
            tasks.Add(t2);
            
            //await Task.WhenAll(tasks);
            await Task.WhenAny(tasks);

            Console.WriteLine("任务一是否完成：{0}", t1.IsCompleted ? "完成" : "未完成");
            Console.WriteLine("任务二是否完成：{0}", t2.IsCompleted ? "完成" : "未完成");

            return t1.IsCompleted ? t1.Result.Length : t2.Result.Length;

        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyDownloadString ds = new MyDownloadString();
            ds.DoRun();

            Console.ReadKey();
        }
    }
}

输出：

任务t是否已经完成：未完成
任务一是否完成：完成
任务二是否完成：未完成
输出值:81

await 会等待一个Task任务的完成，如果await 调用Task.WhenAll，则会异步的等待所有方法都被调用完；而await调用Task.WhenAny时，则会异步的等待其中一个任务完成；同样，当代码遇到await时，会返回到调用方法上去

上例中使用了Task.WhenAny(tasks);，所以，当任务一完成而任务二未完成时，代码便向下执行了，不再等待，如果换成Task.WhenAll(tasks);，则代码会等待两个任务完成后才会向下执行

WaitAll/WaitAny/WhenAll/WhenAny之间的区别

最好理解的是WaitAll和WaitAny，它们都是发生在调用层的等待，阻塞当前线程，等待所有的异步方法有所返回以后才会继续当前的线程

而WhenAll与WhenAny也是等待，不过不是在调用层的线程中等待，而是在异步方法里等待，所以这里说它是“异步的等待”，它阻塞的是异步方法的内部过程，而调用方法因为遇到await会反加到调用层，所以调用层的线程不会被阻塞

也就是说它们的效果是一样的，但所在的包装层级不同

Task.Delay方法

Task.Delay方法会使任务暂停一段时间，我们知道Thread.Sleep也可以将程序暂停一段时间，不同的是，Task.Delay就在异步方法内部使用，不会导致调用层线程阻塞，而Thread.Sleep即使是在异步方法内部他用，也可能使用调用层被阻塞

示例：

using System;
using System.Net;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Threading;

namespace CodeForAsync
{
    class MyClass
    {
        public async void Hello()
        {
            Console.WriteLine("节点1");

            Thread.Sleep(1000);
            // await Task.Delay(1000);

            await Task.Run(() =>
            {
                Console.WriteLine("节点2");
            });
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            mc.Hello();

            Thread.Sleep(100);
            Console.WriteLine("节点3");

            Console.ReadKey();
        }
    }
}

输出：

节点1
节点2
节点3

Thread.Sleep(1000);会将当前线程与调用层的线程都阻塞，如果使用await Task.Delay(1000);的话，输出如下：

节点1
节点3
节点2

Task.Delay(1000)际上只是创建了一个消耗1000毫秒的任务罢了，因此他需要额外的消耗资源