async await实现原理，反编译源代码解读

    public class ThreadAsync
    {
        public static void Show() 
        {
            Console.WriteLine("Show:Start");
            TestTwo();
            Console.WriteLine("Show:End");
        }

        public static async void TestTwo()
        {
            Console.WriteLine("********************  TestTwo ***********************");
            Console.WriteLine("AAA:This is step one: Begain");
            await Task.Run(() =>
            {
                Thread.Sleep(1000);
                Console.WriteLine("BBB:This is Await_Method_One");
            });
            Console.WriteLine("CCC:This is step between await one and await two");
            await Task.Run(() =>
            {
                Thread.Sleep(1000);
                Console.WriteLine("DDD:This is Await_Method_Two");
            });
            Console.WriteLine("EEE:This is step End");
        }

    }

public class ThreadAsync
{
    [CompilerGenerated]
    private sealed class <TestTwo>d__1 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncVoidMethodBuilder <>t__builder;

        private TaskAwaiter <>u__1;

        private void MoveNext()
        {
            int num = <>1__state;
            try
            {
                TaskAwaiter awaiter;
                TaskAwaiter awaiter2;
                if (num != 0)
                {
                    if (num == 1)
                    {
                        awaiter = <>u__1;
                        <>u__1 = default(TaskAwaiter);
                        num = (<>1__state = -1);
                        goto IL_012c;
                    }
                    Console.WriteLine("********************  TestTwo ***********************");
                    Console.WriteLine("AAA:This is step one: Begain");
                    awaiter2 = Task.Run(delegate
                    {
                        Thread.Sleep(1000);
                        Console.WriteLine("BBB:This is Task_Method");
                    }).GetAwaiter();
                    if (!awaiter2.IsCompleted)
                    {
                        num = (<>1__state = 0);
                        <>u__1 = awaiter2;
                        <TestTwo>d__1 stateMachine = this;
                        <>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
                        return;
                    }
                }
                else
                {
                    awaiter2 = <>u__1;
                    <>u__1 = default(TaskAwaiter);
                    num = (<>1__state = -1);
                }
                awaiter2.GetResult();
                Console.WriteLine("CCC:This is step between await one and await two");
                awaiter = Task.Run(delegate
                {
                    Thread.Sleep(1000);
                    Console.WriteLine("DDD:This is Task_Method");
                }).GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    num = (<>1__state = 1);
                    <>u__1 = awaiter;
                    <TestTwo>d__1 stateMachine = this;
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
                    return;
                }
                goto IL_012c;
                IL_012c:
                awaiter.GetResult();
                Console.WriteLine("EEE:This is step End");
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            <>1__state = -2;
            <>t__builder.SetResult();
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine([System.Runtime.CompilerServices.Nullable(1)] IAsyncStateMachine stateMachine)
        {
        }

        void IAsyncStateMachine.SetStateMachine([System.Runtime.CompilerServices.Nullable(1)] IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    public static void Show()
    {
        Console.WriteLine("Show:Start");
        TestTwo();
        Console.WriteLine("Show:End");
    }

    [AsyncStateMachine(typeof(<TestTwo>d__1))]
    [DebuggerStepThrough]
    public static void TestTwo()
    {
        <TestTwo>d__1 stateMachine = new <TestTwo>d__1();
        stateMachine.<>t__builder = AsyncVoidMethodBuilder.Create();
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
    }
}

// System.Runtime.CompilerServices.IAsyncStateMachine
using System.Runtime.CompilerServices;

[NullableContext(1)]
public interface IAsyncStateMachine
{
    void MoveNext();

    void SetStateMachine(IAsyncStateMachine stateMachine);
}