C#异步方法 async、await用法和解析

什么是异步方法？

异步方法在完成其工作之前返回到调用方法，并在调用方法继续执行的时候完成其工作。

语法上有如下特征：

① 方法使用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语句，也得不到任何东西。

异步方法的控制流

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

①首先是第一个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属性。届时，如果异步方法设置了该属性，调用方法获取其值并继续。否则就等待该属性被设置，然后再继续执行。

    class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Task Start !");
         
            //DOTaskWithAsync(i);
            Task<int> a0 = GetResultAsync(0);
            Task<int> a1 = GetResultAsync(1);
            Task<int> a2 = GetResultAsync(2);
            Task<int> a3 = GetResultAsync(3);
            Task<int> a4 = GetResultAsync(4);

            Console.WriteLine("+++++++++++++++++++++++++++++++++");

            Console.WriteLine("a0:{0}", a0.Result);  //要获得它结果的时候，则会等待它执行完
            Console.WriteLine("a1:{0}", a1.Result);
            Console.WriteLine("a2:{0}", a2.Result);
            Console.WriteLine("a3:{0}", a3.Result);
            Console.WriteLine("a4:{0}", a4.Result);

            Console.WriteLine("Task End !");
            Console.ReadLine();
        }

        //public static async void DOTaskWithAsync(int t)
        //{
        //    Console.WriteLine("Await Taskfunction Start {0} !!!", t);
        //    await Task.Run(() =>
        //        {
        //            for (int i = 0; i < 26; i++)
        //            {
        //                Console.Write("{0}", (char)(i+65));
        //                Console.WriteLine("");
        //            } 
        //        }
        //    );
        //}

        //异步方法带有返回值
        public static async Task<int> GetResultAsync(int t)
        {
            int value = 0;
            await Task.Run(() =>
            {
                for (int i = 0; i < 100000; i++)
                {
                    value += i;
                }
                Console.WriteLine("......{0}......finished....{1}", t, value);
            });
            return value;
        }
    }