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 != -3)
                    {
                        TaskAwaiter<string> taskAwaiter;
                        if (num != 0)
                        {
                            taskAwaiter = Test.task2().GetAwaiter();
                            if (!taskAwaiter.IsCompleted)
                            {
                                this.<>1__state = 0;
                                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 = -1;
                        }
                        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 = -2;
                    this.<>t__builder.SetException(exception);
                    return;
                }
                this.<>1__state = -2;
                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 = -1;
            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(3000);
                awaiter.SetResult (100);
            });
            return awaiter;
        }
    }

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

    Begin await:

    Await Task Result:100