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