Async Programming - 1 async-await 糖的本质（1）

原文出处：Pointer-SMQ的博客，已将所有图片改为代码方便观看

这一个系列的文章主要来讲 C# 中的语言特性 async-await 在语言层面的本质，我们都知道 await 是编译器进行了一个 rewrite，然而这个 rewrite 并不是直接 rewrite 成其他没有原生支持 await 的语言的 lambda 回调的形式，而是整个对方法进行了重写，下面就让我们来从最简单的方法，一步一步剖析 await 糖的工作机制。

一个 async 方法，就是你在代码执行到一半的时候，告诉电脑：我要把函数返回，你先去干别的事情（比如 UI 操作），等我这边的事完成之后，再回复现场继续从刚才返回的地方执行。方法的执行是依靠状态机驱动的，一系列的 MoveNext 方法推动状态机的执行，编译器则会将方法分而治之，把 async 方法体拆分成许多部分，每一部分是一个状态机中的状态，放进 MoveNext 中

新建一个控制台工程，我们从最简单的 async 方法开始：FooAsync

using System;
using System.Runtime.CompilerServices;

namespace StateMachineDemo
{
    class Program
    {
        static void Main(string[] args)
        {
        
        }
        
        public static async void FooAsync()
        {
            return;
        }
    }
}

编译器已经提示我这个 async 标识符没卵用了，没关系

然后我们再写一个方法来对照被编译器重写过的方法：FooAsync2

using System;
using System.Runtime.CompilerServices;

namespace StateMachineDemo
{
    class Program
    {
        static void Main(string[] args)
        {
        
        }
        
        public static async void FooAsync()
        {
            return;
        }
        
        public static void FooAsync2()
        {
        
        }
    }
}

这还没完，一个异步方法中执行的各项操作，运算，中间暂停然后返回，最后 return 结果，是由状态机推动的，所以我们手动 rewrite 的 FooAsync2 方法中需要一个状态机，并且要实现系统的 IAsyncStateMachine 接口。

using System;
using System.Runtime.CompilerServices;

namespace StateMachineDemo
{
    class Program
    {
        static void Main(string[] args)
        {
        
        }
        
        public static async void FooAsync()
        {
            return;
        }
        
        public static void FooAsync2()
        {
        
        }
        
        public struct FooAsyncStaticMachine : IAsyncStateMachine
        {
            public void MoveNext()
            {
                throw new NotImplementException();
            }
            
            public void SetStateMachine(IAsyncStateMachine stateMachine)
            {
                throw new NotImplementException();
            }
        }
    }
}

state machine 是一个 struct，默认情况下一个 async 方法不需要等待，所以我们不希望有一个在堆上的东西来增加我们的运行负担。

你可以看到这个接口要求两个方法，第二个我们之后再讲，你可能会奇怪为什么一个 IAsyncStateMachine 实例需要 SetStateMachine 另一个实例（后面会说，这其实是他自己），由于我们的 state machine 是一个 struct，所以当方法 await 的时候，整个栈就回退给其他方法来用了，所以你需要把这个 state machine 以及其他的参数转移到堆上，然后用这个方法来获得他自己，这个时候堆上的对象的运行时消耗才是值得的。而 MoveNext 就是之前我们说过的用来推动整个方法运行的方法。

方法里已经装了一个 state machine 的实例了，然后我们来看看谁要来驱动着方法一步一步向前走，当控制流回到方法内部的时候他需要来执行一些操作，尽管我们这里的方法什么都没干，我们还是要把所有的机构都弄好。我们需要一个 AsyncMethodBuilder，这个东西也已经在 System.Runtime.CompilerServices 里面提供了。

using System;
using System.Runtime.CompilerServices;

namespace StateMachineDemo
{
    class Program
    {
        static void Main(string[] args)
        {
        
        }
        
        public static async void FooAsync()
        {
            return;
        }
        
        public static void FooAsync2()
        {
            var stateMachine = new FooAsyncStaticMachine();
            stateMachine.MethodBuilder = new AsyncVoidMethodBuilder();
            
        }
        
        public struct FooAsyncStaticMachine : IAsyncStateMachine
        {
            public void MoveNext()
            {
                throw new NotImplementException();
            }
            
            public void SetStateMachine(IAsyncStateMachine stateMachine)
            {
                throw new NotImplementException();
            }
        }
    }
}

这个 method builder 放在了状态机内，因为方法可能返回而我们一直需要它，所以要借助 state machine 转移到栈上的同时把它一起转移了。AsyncVoidMethodBuilder 也是一个 struct，同样也是我们不希望堆上的东西增加额外的运行时负担。

method builder 是我们在控制流开始，await，返回的时候应该去使用的东西，这个东西应该在 MoveNext 函数中被使用，这里我们的方法什么都没干，所以 MoveNext 中只有一个状态的转移：开始->返回。返回通过 method builder 的 SetResult 方法完成，所有的 return 都会被 rewrite 成 SetResult。

using System;
using System.Runtime.CompilerServices;

namespace StateMachineDemo
{
    class Program
    {
        static void Main(string[] args)
        {
        
        }
        
        public static async void FooAsync()
        {
            return;
        }
        
        public static void FooAsync2()
        {
            var stateMachine = new FooAsyncStaticMachine();
            stateMachine.MethodBuilder = new AsyncVoidMethodBuilder();
            
        }
        
        public struct FooAsyncStaticMachine : IAsyncStateMachine
        {
            public void MoveNext()
            {
                MethodBuilder.SetResult();
            }
            
            public void SetStateMachine(IAsyncStateMachine stateMachine)
            {
                throw new NotImplementException();
            }
        }
    }
}

最后方法怎么开始呢？我们看看 method builder 有没有 Start 方法，哈！有。Start 方法需要 state machine 的引用，为什么需要，因为 method builder 需要在方法一步步进行的时候调用 ModeNext，为什么要引用，这也说的通，方法的状态只需要一份，使用引用，避免拷贝，以及 state machine 有可能在栈上（现在这样）也有可能在堆上，需要用引用来指向它。

using System;
using System.Runtime.CompilerServices;

namespace StateMachineDemo
{
    class Program
    {
        static void Main(string[] args)
        {
        
        }
        
        public static async void FooAsync()
        {
            return;
        }
        
        public static void FooAsync2()
        {
            var stateMachine = new FooAsyncStaticMachine();
            stateMachine.MethodBuilder = new AsyncVoidMethodBuilder();
            
            stateMachine.MethodBuilder.Start(ref stateMachine);
        }
        
        public struct FooAsyncStaticMachine : IAsyncStateMachine
        {
            public void MoveNext()
            {
                MethodBuilder.SetResult();
            }
            
            public void SetStateMachine(IAsyncStateMachine stateMachine)
            {
                throw new NotImplementException();
            }
        }
    }
}

现在的 FooAsync2 就是 async 方法 FooAsync 被 rewrite 之后的样子。我们在 Main 里调用 FooAsync2，单步执行

从调用堆栈看，Start 方法调用了 MoveNext，然后我们的 MoveNext 方法就像 FooAsync 一样，什么都没干，直接 SetResult 然后返回，然后 Start 返回，FooAsync2 返回，Main 返回，一个没卵用的异步方法完成了。

这样就是一个最简单的异步方法被 rewrite 之后的样子，这一篇就到这里，下一篇讲讲稍微复杂点的方法。