async-await原理解析

在用async包裹的方法体中，可以使用await关键字以同步的方式编写异步调用的代码。那么它的内部实现原理是什么样的呢？我们是否可以自定义await以实现定制性的需求呢？先来看一个简单的例子：

     class Test {
         public static void Main (string[] args) {
             Task.Run (new Func<Task<string>>(task1));
             Console.ReadLine ();
         }

         private async static Task<string> task1() {
             string ret = await task2 ();
             Console.WriteLine ("Await Task Result:" + ret);
             return ret;
         }

         private static Task<string> task2() {
             return Task.FromResult<string> ("Task2");
         }
     }

通过ILSpy反编译（要关闭"视图-选项-反编译await/async"菜单项），得到如下代码：

     internal class Test
     {
         [CompilerGenerated]
         [StructLayout(LayoutKind.Auto)]
         private struct <task1>d__0 : IAsyncStateMachine
         {
             public int <>1__state;
             public AsyncTaskMethodBuilder<string> <>t__builder;
             public string <ret>5__1;
             private TaskAwaiter<string> <>u__$awaiter2;
             private object <>t__stack;

             void IAsyncStateMachine.MoveNext()
             {
                 string result;
                 try
                 {
                     int num = this.<>1__state;
                     if (num != -)
                     {
                         TaskAwaiter<string> taskAwaiter;
                         if (num != )
                         {
                             taskAwaiter = Test.task2().GetAwaiter();
                             if (!taskAwaiter.IsCompleted)
                             {
                                 this.<>1__state = ;
                                 this.<>u__$awaiter2 = taskAwaiter;
                                 this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<string>, Test.<task1>d__0>(ref taskAwaiter, ref this);
                                 return;
                             }
                         }
                         else
                         {
                             taskAwaiter = this.<>u__$awaiter2;
                             this.<>u__$awaiter2 = default(TaskAwaiter<string>);
                             this.<>1__state = -;
                         }
                         string arg_86_0 = taskAwaiter.GetResult();
                         taskAwaiter = default(TaskAwaiter<string>);
                         string text = arg_86_0;
                         this.<ret>5__1 = text;
                         Console.WriteLine("Await Task Result:" + this.<ret>5__1);
                         result = this.<ret>5__1;
                     }
                 }
                 catch (Exception exception)
                 {
                     this.<>1__state = -;
                     this.<>t__builder.SetException(exception);
                     return;
                 }
                 this.<>1__state = -;
                 this.<>t__builder.SetResult(result);
             }

             [DebuggerHidden]
             void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine param0)
             {
                 this.<>t__builder.SetStateMachine(param0);
             }
         }

         public static void Main(string[] args)
         {
             Task.Run<string>(new Func<Task<string>>(Test.task1));
             Console.ReadLine();
         }

         [DebuggerStepThrough, AsyncStateMachine(typeof(Test.<task1>d__0))]
         private static Task<string> task1()
         {
             Test.<task1>d__0 <task1>d__;
             <task1>d__.<>t__builder = AsyncTaskMethodBuilder<string>.Create();
             <task1>d__.<>1__state = -;
             AsyncTaskMethodBuilder<string> <>t__builder = <task1>d__.<>t__builder;
             <>t__builder.Start<Test.<task1>d__0>(ref <task1>d__);
             return <task1>d__.<>t__builder.Task;
         }

         private static Task<string> task2()
         {
             return Task.FromResult<string>("Task2");
         }
     }

按照代码的调用顺序，我们关注下task1()的内部实现。

首先是初始化结构体<task1>d_0的实例<task1>d__。那么<task1>d__0是个什么东东呢？由编译器的生成代码中可以看到，它是一个实现了IAsyncStateMachine接口的结构体，而用户代码则被编译器重新组织进了MoveNext()方法中。<task1>d__0有个内部状态成员<>1__state，MoveNext()方法根据这个状态调转到相应的代码块中加以执行。

了解了<task1>d__0的声明实现，再看下task1()方法中的具体调用。在创建实例<task1>d__之后，设置初始状态<>1__state为-1，并调用<>t__builder的Start方法。不难推断，在Start方法中会调用<task1>d__.MoveNext()，此时内部状态为-1，会先调用Test.task2().GetAwaiter()获取其所关联的TaskAwaiter实例。如果awaiter当前是未结束的话，则设置<>1__state为0，并将当前<task1>d__作为参数关联到TaskAwaiter实例的onCompletedContinuation回调延续中去。当未来某个时刻，TaskAwaiter所关联的Task任务结束时，会设置awaiter的异步结果并触发回调延续，导致调用<task1>d__.MoveNext()方法，并最终跳转到用户代码块中，获取awaiter的异步结果并交由用户代码处理。这个回调，基于Task.ConfigureAwait(true/false)的不同，会在后续切换到当前线程或是从线程池中取了一个空闲线程来处理(更细节可参考.net源码分析)。

这里要顺便提一句，在本例中，通过Task.Run创建了taskX1，await之后的代码与taskX1没有任何关系，从编译器生成的代码来看，在调用task1()方法并调用<task1>d__.Start()方法之后taskX便结束了，虽然task1()方法返回了新的Task<string>实例，但是只是特定类型的返回值而已，与taskX1或Task没有任何关系。

由以上分析可以看到，async/await只是一个语法糖，async告知编译器要生成状态机代码，await则是配合生成GetAwaiter()，并封装跳转的用户代码块。除此之外，async/await与Task没有任何直接关系。而TaskAwaiter的作用，是实现INotifyCompletion(在System.Runtime.CompilerServices命名空间)以桥接异步回调过程。那么第二个自定义await的问题便一目了然了：任何类型，只需要实现GetAwaiter()方法以返回INotifyCompletion实例，便可以被await。

举个例子：

     class TestAwaiter<T> : INotifyCompletion {
         private T result;
         private Action continuation;

         // INotifyCompletion Implement
         public void OnCompleted(Action continuation) { this.continuation = continuation; }

         // Compiler Call Methods
         public bool IsCompleted { get; private set; }
         public T GetResult() { return result; }
         public TestAwaiter<T> GetAwaiter() { return this; }

           // Self Call Methods
         public void SetResult(T ret) {
             result = ret;
             if (continuation != null) {
                 continuation ();
             }
         }
     }

     class Test {
         public static void Main (string[] args) {
             Task.Run (new Action(task1));
             Console.ReadLine ();
         }

         private async static void task1() {
             Console.WriteLine ("Begin await:");
             int ret = await testAwaiter ();
             Console.WriteLine ("Await Task Result:" + ret);
         }

         private static TestAwaiter<int> testAwaiter() {
             TestAwaiter<int> awaiter = new TestAwaiter<int> ();
             ThreadPool.QueueUserWorkItem (_ => {
                 Thread.Sleep();
                 awaiter.SetResult ();
             });
             return awaiter;
         }
     }

这里没有再定义单独的类型以返回TestAwaiter，而是把二者都封装在了TestAwaiter内部。运行结果如下：

Begin await:

Await Task Result:100