C#当中使用async和await

 

最近在写程序的时候，常常遇到大量须要异步访问的状况，可是对于async和await到底怎么写，还不是很是明确。因而参考《C#图解教程》了异步编程一节。

1.普通的程序怎么写？

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

    class MyDownLoadString
    {
        Stopwatch sw = new Stopwatch();
        public void DoRun()
        {
            const int LargeNumber = 6000000;
            sw.Start();

            int t1 = CountCharacters(1, "http://www.microsoft.com");
            int t2 = CountCharacters(2, "http://www.illustratedcsharp.com");

            CountToALargeNumber(1, LargeNumber);
            CountToALargeNumber(2, LargeNumber);
            CountToALargeNumber(3, LargeNumber);
            CountToALargeNumber(4, LargeNumber);
          
            Console.WriteLine("Chars in Call1:{0}",t1);
            Console.WriteLine("Chars in Call1:{0}",t2);
        }

        private int CountCharacters(int id, string uriString)
        {
            WebClient wc1 = new WebClient();
            Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds);
            string result = wc1.DownloadString(new Uri(uriString));
            Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
            return result.Length;
        }

        private void CountToALargeNumber(int id, int value)
        {
            for (long i = 0; i < value; i++) ;
            Console.WriteLine("End CountToALargeNumber {0} : {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
        }
    }
}

结果：

Call 1 start: 1ms
Call 1 completed: 903ms
Call 2 start: 903ms
Call 2 completed: 1,355ms
End CountToALargeNumber 1 : 1,375ms
End CountToALargeNumber 2 : 1,399ms
End CountToALargeNumber 3 : 1,417ms
End CountToALargeNumber 4 : 1,435ms
Chars in Call1:161702
Chars in Call1:5164

从运行结果能够看到，同步执行的时间主要花在了两次请求外部地址上，计算长度并不费时，用图来表示就像下面

　　

2.使用async和await怎么写？

修改上面代码，以下

class MyDownLoadString
{
    Stopwatch sw = new Stopwatch();
    public void DoRun()
    {
        const int LargeNumber = 6000000;
        sw.Start();
         // Task<int> 保存结果对象，后面t1.Result则是获取结果
         Task<int> t1 = CountCharactersAsync(1, "http://www.microsoft.com");
        Task<int> t2 = CountCharactersAsync(2, "http://www.illustratedcsharp.com");
      
        //无需等待CountCharactersAsync执行完成
        CountToALargeNumber(1, LargeNumber);
        CountToALargeNumber(2, LargeNumber);
        CountToALargeNumber(3, LargeNumber);
        CountToALargeNumber(4, LargeNumber);
        
        //t1.Result获取结果
        Console.WriteLine("Chars in Call1:{0}",t1.Result);
        Console.WriteLine("Chars in Call1:{0}",t2.Result);
    }

    private async Task<int> CountCharactersAsync(int id, string uriString)
    {
        WebClient wc = new WebClient();
        Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds);
        string result = await wc.DownloadStringTaskAsync(new Uri(uriString));
        Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
        Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
        return result.Length;
    }

    private void CountToALargeNumber(int id, int value)
    {
        for (long i = 0; i < value; i++) ;
        Console.WriteLine("End CountToALargeNumber {0}: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    }
}

运行结果：

Call 1 start: 2ms
Call 2 start: 253ms
End CountToALargeNumber 1: 288ms
End CountToALargeNumber 2: 359ms
End CountToALargeNumber 3: 560ms
Call 1 completed: 770ms
End CountToALargeNumber 4: 844ms
Call 2 completed: 887ms
Chars in Call1:162262
Chars in Call2:5164

修改如上面的代码以后，咱们就能够无需等待两次CountCharactersAsync返回结果，而是直接调用了下面的CountToALargeNumber，在CountCharactersAsync请求返回的时候再获取结果。

 

3.async和await的细节

 

async和await能够建立和使用异步方法，这个特性的由三个部分组成：

①调用方法(calling method)：该方法调用异步方法，而后在异步方法（可能使用同一个线程也可能不在一个线程）执行其任务的时候继续执行

②异步方法（async）: 该方法异步执行其工做，而后当即方法到调用方法

③await表达式：用于异步方法内部，指明须要异步执行的惹怒我。一个异步方法能够包含任意多个await表达式，若是一个都不包含编译器会发出警告

举例说明一个async/await方法：

//1.调用方法
static void Main(string[] args)
{
    Task<int> t = DoSumAsync(1, 2);
    Console.WriteLine("结果:{0}", t.Result);
    Console.ReadKey();
}

//2.异步方法
public static async Task<int> DoSumAsync(int a, int b)
{
    //3.await 表达式
    int sum = await Task.Run(() => { return a + b; });
    return sum;
}

4.什么是异步方法？

上面简单举例了什么是异步方法，下面就详细学习一下：

异步方法在完成其工做以前返回到调用方法，并在调用方法继续执行的时候完成其工做。语法上有以下特征：

① 方法使用async做为修饰符

② 方法内部包含一个或者多个await表达式，表示能够异步完成的任务

③ 必须具有如下三种返回类型 void 、Task 、Task<T> ,其中后两种的返回对象标识讲座将来完成的工做，调用方法和异步方法能够继续执行。

④异步方法的参数能够任意类型，可是不能为out和ref参数

⑤约定俗成，通常异步方法都是以 Async做为后缀的。

⑥ 除了方法以外，Lambda表达式和匿名函数也能够做为异步对象。

像代码：

private async Task<int> CountCharactersAsync(int id, string uriString)
{
    WebClient wc = new WebClient();
    Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds);
    string result = await wc.DownloadStringTaskAsync(new Uri(uriString));
    Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    return result.Length;
}

详细说明：

①async关键字是一个上下文关键字，也就是说除了作为方法（lambda和匿名函数）的修饰符以外，还能够作标识符。

②返回类型

Task类型：若是调用方法不须要从异步方法中返回某个值，但须要检查异步方法的状态，能够返回一个Task，此时就算异步方法中出现了return语句，也不会返回任何东西。

Task<T>类型，除了上面Task的功能，还能够经过 Return属性来获取返回的T类型的值。

void类型：若是仅仅是执行异步方法，而不须要与它作任何进一步的交互（“调用并忘记”），此时能够用void，和Task同样，就算有return语句，也得不到任何东西。

 

5.异步方法的控制流

首先要明确“异步方法”的三个部分，以下图所示：

①首先是第一个await以前的部分，这部分应该是少许且无需长时间等待的代码。

②await表达式，表示须要被异步执行的任务，这里有两个await表达式，第二个await和以前的同步部分和第一个await以及以前的部分是同样的。

③后续部分：在await表达式以后出现的方法中的其他代码。

执行过程，能够参考下面的图

有几个注意的地方：

① await以前的部分是同步执行的

② 当达到awati的时候，会将异步方法的控制返回给调用方法。若是方法返回的类型是Task或者Task<T>，将建立一个Task对象，表示需异步完成的任务和后续，而后将该Task返回到调用方法。 这里的返回值并非await表达式的返回值，而是异步方法中声明的返回值类型。

③ 异步方法内部须要完成如下工做：

　　- 异步执行await表达是的空闲任务

       - 当await表达式执行完成以后，执行后续部分。后续自己也多是await表达式，处理过程和上一个一致。

　　- 后续部分若是遇到 return 或者 方法达到末尾，将作以下的事情：

　　　　l  若是返回的类型是void,控制流就退出了

　　　　l  若是返回的类型是Task，后续部分设置Task对象的属性并退出。

　　　　l  若是返回的类型是Task<T>，不只要设置Task对象属性，还要设置Task对象的Return属性。

  　　这个点要注意下：并非遇到return或者达到方法末尾，就能获取到返回值，它只是退出了。

④ 调用方法继续执行，会从异步方法获取Task对象。当须要其实际值的时候，就引用Task对象中的Result属性。届时，若是异步方法设置了该属性，调用方法获取其值并继续。不然就等待该属性被设置，而后再继续执行。

 

6. await表达式

 

await表达式指定了一个异步执行的任务。语法由 await关键字 + 一个空闲对象(称为任务)组成。这个任务多是一个Task对象，也能够不是，默认状况下由该线程异步执行。

一个空闲对象 指的是一个awaitable类型的实例，awaitable类型是指包含了GetAwaiter方法的类型，方法没有参数，返回一个称为awaiter类型的对象。

 

 一个awaiter对象包含了以下成员：

 

通常状况下咱们不须要本身构建一个awaiter对象，使用.net 本身的Task就能够了。最简单的方法就是使用Task.Run()来返回一个Task对象。关于Task.Run()有一个很是重要的点，他将在不一样的线程上运行你的方法。

6.异常处理和await表达式

先看下面这个例子，直接在异步方法内部使用了try..catch。

static void Main(string[] args)
{

    Task t = BadAsync();
    t.Wait();
    Console.WriteLine("Task Status:       {0}", t.Status );
    Console.WriteLine("Task IsFaulted:    {0}", t.IsFaulted );
    Console.WriteLine("Please enter a key to exit!");
    Console.ReadKey();

}

static async Task BadAsync()
{
    try
    {
        await Task.Run(() => { throw new Exception(); });
    }
    catch
    {
        Console.WriteLine("Exception in BadAsync");
    }
}

执行结果：

Exception in BadAsync
Task Status:       RanToCompletion
Task IsFaulted:    False
Please enter a key to exit!

从结果能够看到，虽然在异步方法内部进行了try..catch，而且也catch到了异常，可是对于调用函数，返回的Task状态依然为 RanToCompletion 。

为何这个亚子？，缘由以下：

① Task没有被取消掉

② 没有未处理的异常。相似的IsFaulted是false。

 

7.在调用方法中同步的等待任务（WaitAll、WaitAny）

对于单个Task ，能够经过task对象的wait()方法来进行等待。

Task<int> t = CountCharactersAsync("http://www.163.com");
t.Wait();

对于多个Task，可使用WaitAll()或者waitAny()方法，进行同步。

 WaitAll是等待因此的任务完成才继续操做

Task<int> t1 = CountCharactersAsync(1, "http://www.163.com");
Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com");
Task<int>[] tasks = new Task<int>[] { t1, t2 };
Task.WaitAll(tasks);

WaitAny是只要一个完成就能够继续操做

Task<int> t1 = CountCharactersAsync(1, "http://www.163.com");
Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com");
Task<int>[] tasks = new Task<int>[] { t1, t2 };
Task.WaitAny(tasks);

8.在异步方法中异步的等待任务 （WhenAll、.WhenAny）

上面说明了如何在“调用方法”中，同步等待Task的完成。 可是有时候，咱们在一个异步方法中也会存在多个任务，想要让它们经过await表达式等待。咱们能够经过Task.WhenAll() 和 Task.WhenAny() 方法实现。 这两个方法称为组合子（combinator）。

private async Task<int> CountCharactersAsync(string site1, string site2)
{
    WebClient wc1 = new WebClient();
    WebClient wc2 = new WebClient();

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

    List<Task<string>> tasks = new List<Task<string>>();
    tasks.Add(t1);
    tasks.Add(t2);

    //组合子
    await Task.WhenAll(tasks);
    //await Task.WhenAny(tasks);

    Console.WriteLine("   CCA:  T1 {0} Finished", t1.IsCompleted ? "" : "Not");
    Console.WriteLine("   CCA:  T2 {0} Finished", t2.IsCompleted ? "" : "Not");

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

9.使用Task.Delay 暂停线程处理

通常咱们都使用Thread.Sleep(xxxx) 进行线程的延时，可是 Thread.Sleep会阻塞线程。而Task.Delay则不会阻塞线程，线程能够继续处理其余的工做。

class Simple
{
    Stopwatch sw = new Stopwatch();
    public void DoRun()
    {
        Console.WriteLine("Caller: Before call");
        ShowDelayAsync();
        Console.WriteLine("Caller: After call");

    }
    private async void ShowDelayAsync()
    {
        sw.Start();
        Console.WriteLine("   Before Delay:  {0} ", sw.Elapsed.Milliseconds );
        await Task.Delay(1000);
        Console.WriteLine("   After  Delay:  {0} ", sw.Elapsed.Milliseconds);
    }
}