async await

专门用于处理一些文件IO（潜规则）

网络IO和文件IO都有一些异步方法，MemoryStream ，FileStream ，WebRequest

Task是用于最大限度使用WorkThread

 

优点：

异步代码简洁

提升开发效率

 

状态机StateMachine

 

用于处理IO消耗的多线程

        static void Main(string[] args)
        {
            var info = Hello().Result;

            Console.WriteLine(info);

            Console.Read();
        }

        static async Task<string> Hello()
        {
            //主线程执行，底层还会调用一个 AwaitUnsafeOnCompleted 委托给线程池
            Console.WriteLine("hello world");

            //在工作线程中执行
            var x = await Task.Run(() =>
              {
                  Console.WriteLine("i'm middle");

                  return "i'm ok";
              });

            Console.WriteLine("我是结尾哦:{0}", x);

            return x;
        }

　　

• AsyncTaskMethodBuilder： 扮演了一个TaskcomplationSource一个角色，就是做Task的包装器。
• state：扮演者状态机状态的角色,记录当前状态
• AwaitUnsafeOnCompleted ：这个函数是丢给线程池去执行的，当某一时刻执行结束，会调用Movenext

    class Program
    {
        static void Main(string[] args)
        {
            var info = Hello();

            Console.WriteLine("我去： " + info.Result);

            Console.Read();
        }

        static Task<string> Hello()
        {
            MyStateMachine machine = new MyStateMachine();

            //类似TaskCompletionSource，包装器
            machine.t_builder = AsyncTaskMethodBuilder<string>.Create();            

            machine.state = -1;

            var t_builder = machine.t_builder;

            t_builder.Start(ref machine);

            return machine.t_builder.Task;
        }
    }

    public class MyStateMachine : IAsyncStateMachine
    {
        public AsyncTaskMethodBuilder<string> t_builder;

        public int state;

        private MyStateMachine machine = null;

        private TaskAwaiter<string> myawaiter;

        string result = string.Empty;

        public MyStateMachine()
        {
        }

        public void MoveNext()
        {
            try
            {
                switch (state)
                {
                    case -1:
                        Console.WriteLine("hello world");

                        var waiter = Task.Run(() =>
                        {
                            Console.WriteLine("i'm middle");

                            return "i'm ok";
                        }).GetAwaiter();

                        state = 0;  //设置下一个状态
                        myawaiter = waiter;

                        machine = this;

                        //丢给线程池执行了。。。
                        t_builder.AwaitUnsafeOnCompleted(ref waiter, ref machine);
                        break;

                    case 0:

                        var j = myawaiter.GetResult();

                        Console.WriteLine("我是结尾哦:{0}", j);

                        t_builder.SetResult(j);
                        break;
                }
            }
            catch (Exception ex)
            {
                t_builder.SetException(ex);  //设置t_builder的异常
            }
        }

        public void SetStateMachine(IAsyncStateMachine stateMachine)
        {
        }
    }

 

异步执行IO操作

 线程池将Task交给驱动程序的队列，立即返回。

 等文件系统操作完成后，通知CLR，CLR使用IO线程通知应用程序（调用回调函数）

同步阻塞执行IO操作

 

 

 

 

?GetAwaiter?

 

 

 

 

https://www.cnblogs.com/HDK2016/p/9932905.html