感谢Marco CAO指出的两点错误，已做出修改与补充

异步函数（async/await）简单应用

.NET Framework4.5提供了针对异步函数语法糖，简化了编写异步函数的复杂度。

下面通过一个简单的示例，介绍.NET Framework4.5对异步函数的支持。

窗体页面

窗体代码

    public partial class Form1 : Form

    {

        public Form1()

        {

            InitializeComponent();

        }

        private async void btnGetText_Click(object sender, EventArgs e)

        {

            string urlString = string.Empty;

            using (HttpClient client = new HttpClient())

            {

                //异步获取“http://10.32.112.82/epms/”内容（线程返回）。用户界面依旧可以操作

                urlString = await client.GetStringAsync(@"http://10.32.112.82/epms/");

            }

            txtUrlString.Text = urlString;

        }

    }

说明

1.点击获取url，程序开始获取url内容。（注意：这里我写的url是我们公司内部的网址，必须通过代理才可以访问，所以肯定会有延迟效果。）

2.虽然有延迟效果，但是窗体依旧可以操作（在第一个textBox中可以输入内容）。表明窗体并没有被阻塞，也就是说获取url内容是异步操作。

3.一段时间后，你会发现窗体报错，表明获取url内容操作完毕，操作失败。

讲解

1.异步函数的关键字：async；等待异步结果的关键字：await

2.异步方法的调用，与获取异步方法的结果，在同一个方法体内。这点极大了简化异步方法维护的成本。（以前BeginInvoke()、EndInvoke()，起码是2个方法，且不能在同一方法体内调用。下文异步函数简化APM模型有介绍。）

3.await作用的方法表示：【进入该方法的线程】会返回线程池，程序会在此挂起等待返回结果（这里需要注意，因为程序得到返回结果再执行时，是从线程池中另起了一个线程在执行），同时【子线程】会执行await后面的方法。（这点是：async与await的核心）

异步函数（async/await）实现异步原理（状态机）

async/await关键点：

1.有几个async方法，就创建几个【状态机】。

.【状态机】的几种状态（-1：初始化；-2：方法体执行结束；0：第一个await方法；1：第二个await方法；。。。依次往下）

3.【状态机】控制着异步方法执行流程（MoveNext方法）

通过上面的介绍，我们知道【状态机】控制着方法执行流程，下面我们就来对【状态机】如何控制方法执行流程一探究竟。

下面这段测试代码，来自：CLR via C#（第4版）

示例代码

        private static async Task<string> MyMethodAsync(int argument)

        {

            int local = argument;

            try

            {

                Type1 result1 = await Method1Async();

                for (int x = ; x < ; x++)

                {

                    Type2 result2 = await Method2Async();

                }

            }

            catch (Exception)

            {

                Console.WriteLine("Catch");

            }

            finally

            {

                Console.WriteLine("Finally");

            }

            return "Done";

        }

        private static async Task<Type1> Method1Async()

        {

            string a = await Task.Run<string>(() => "Method1");

            return new Type1();

        }

        private static async Task<Type2> Method2Async()

        {

            string a = await Task.Run<string>(() => "Method2");

            return new Type2();

        }

        sealed class Type1 { }

        sealed class Type2 { }

用Reflector.exe反编译后，得到如下代码（MyMethodAsync）

[CompilerGenerated]

private struct <MyMethodAsync>d__9 : IAsyncStateMachine

{

    // Fields

    public int <>1__state;

    public AsyncTaskMethodBuilder<string> <>t__builder;

    private object <>t__stack;

    private TaskAwaiter<Program.Type1> <>u__$awaitere;

    private TaskAwaiter<Program.Type2> <>u__$awaiterf;

    public int <local>5__a;

    public Program.Type1 <result1>5__b;

    public Program.Type2 <result2>5__d;

    public int <x>5__c;

    public int argument;

    // Methods

    private void MoveNext()

    {

        string str;

        try

        {

            bool flag = true;

            switch (this.<>1__state)

            {

                case -:

                    goto Label_01E1;

                case :

                case :

                    break;

                default:

                    this.<local>5__a = this.argument;

                    break;

            }

            try

            {

                switch (this.<>1__state)

                {

                }

                try

                {

                    TaskAwaiter<Program.Type1> awaiter;

                    switch (this.<>1__state)

                    {

                        case :

                            break;

                        case :

                            goto Label_0137;

                        default:

                            awaiter = Program.Method1Async().GetAwaiter();

                            if (awaiter.IsCompleted)

                            {

                                goto Label_00D7;

                            }

                            this.<>1__state = ;

                            this.<>u__$awaitere = awaiter;

                            this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<Program.Type1>, Program.<MyMethodAsync>d__9>(ref awaiter, ref this);

                            flag = false;

                            return;

                    }

                    awaiter = this.<>u__$awaitere;

                    this.<>u__$awaitere = new TaskAwaiter<Program.Type1>();

                    this.<>1__state = -;

                Label_00D7:

                    Program.Type1 introduced11 = awaiter.GetResult();

                    awaiter = new TaskAwaiter<Program.Type1>();

                    Program.Type1 type = introduced11;

                    this.<result1>5__b = type;

                    this.<x>5__c = ;

                    while (this.<x>5__c < )

                    {

                        TaskAwaiter<Program.Type2> awaiter3 = Program.Method2Async().GetAwaiter();

                        if (awaiter3.IsCompleted)

                        {

                            goto Label_0156;

                        }

                        this.<>1__state = ;

                        this.<>u__$awaiterf = awaiter3;

                        this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<Program.Type2>, Program.<MyMethodAsync>d__9>(ref awaiter3, ref this);

                        flag = false;

                        return;

                    Label_0137:

                        awaiter3 = this.<>u__$awaiterf;

                        this.<>u__$awaiterf = new TaskAwaiter<Program.Type2>();

                        this.<>1__state = -;

                    Label_0156:

                        Program.Type2 introduced12 = awaiter3.GetResult();

                        awaiter3 = new TaskAwaiter<Program.Type2>();

                        Program.Type2 type2 = introduced12;

                        this.<result2>5__d = type2;

                        this.<x>5__c++;

                    }

                }

                catch (Exception)

                {

                    Console.WriteLine("Catch");

                }

            }

            finally

            {

                if (flag)

                {

                    Console.WriteLine("Finally");

                }

            }

            str = "Done";

        }

        catch (Exception exception)

        {

            this.<>1__state = -;

            this.<>t__builder.SetException(exception);

            return;

        }

    Label_01E1:

        this.<>1__state = -;

        this.<>t__builder.SetResult(str);

    }

    [DebuggerHidden]

    private void SetStateMachine(IAsyncStateMachine param0)

    {

        this.<>t__builder.SetStateMachine(param0);

    }

}

这里我要说一句抱歉，这里贴出的代码可读性很差（没有关键字，没有着色）。本来想截图的，但是由于反编译的代码很长，无法在我显示器中一屏显示完，所以我也没截图。下面讲解的时候，采用分段截图来说明，希望大家看得明白。同时也推荐大家自己用Reflector.exe反编译后，自己阅读。

代码阅读

1.【状态机】初始化（-1）

2.【状态机】Start入口-》MoveNext方法

3.【状态机】个数（3个async方法，所以3个状态机）

4.核心代码（MoveNext方法）

这段代码的大致意思是：<>1__state初始状态为-1，进入default分支，判断Method1Async()是否执行完毕，若未执行完毕，<>1__state设计为0（表示返回第一个await对应的方法块），调用了一个方法（红框标注），然后return（线程返回线程池，函数挂起等待返回结果）。若执行完毕，【goto Label_00D7】正好就是获取第一个await结果的代码块。

下面重点关注一下，红框标注的代码（AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted()）做了什么？

依旧需要借助反编码工具，查到这个调用的真实代码，如下

第一句是关键，方法名称：得到完成时调用的委托。进入方法一探究竟

AsyncTaskMethodBuilder.GetCompletionAction()代码如下

红框的批注，action就是完成时调用的方法，进入要MoveNextRunner.Run()方法中。

真相大白，action就是状态机的MoveNext()方法。

总结：AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted()做得事就是，当异步函数执行完毕后，回调状态机的MoveNext()方法

异步函数（async/await）简化异步编程模型（APM）

APM编程代码

        static void Main(string[] args)

        {

            AsyncAPM();

        }

        static void AsyncAPM()

        {

            Console.WriteLine("Main thread ID={0}", Thread.CurrentThread.ManagedThreadId);

            byte[] s_data = new byte[];

            FileStream fs = new FileStream(@"d:\1.txt", FileMode.Open, FileAccess.Read, FileShare.Read, , FileOptions.Asynchronous);

            fs.BeginRead(s_data, , s_data.Length, ReadIsDone, fs);

            Console.WriteLine("主线程执行完毕");

            Console.ReadLine();

        }

        private static void ReadIsDone(IAsyncResult ar)

        {

            Thread.Sleep();

            Console.WriteLine("ReadIsDone thread ID={0}", Thread.CurrentThread.ManagedThreadId);

            FileStream fs = (FileStream)ar.AsyncState;

            int bytesRead = fs.EndRead(ar);

            fs.Close();

            Console.WriteLine("Number of bytes read={0}", bytesRead);

        }

这种编程模式有一个很大的缺点：如果我想【获取异步返回的结果，然后打印出来】。那么【获取异步返回结果，然后打印出来】必须放在回调函数中，也就是另一块代码中（上面的实例，获取字节数，然后打印出来。就必须放在ReadIsDone函数中），这其实给阅读代码增添了难度（如果多个异步函数，阅读代码时就要在很多方法中来回跳转）。当然你也可以在一个方法中用EndInvoke()来做等待。这样虽然也是异步，但是会出现主程序阻塞，等待异步返回结果。

异步函数简化代码

        static void Main(string[] args)

        {

            SimplifyAsyncToAPM();

            Console.ReadLine();

        }

        static async void SimplifyAsyncToAPM()

        {

            int length = await AsyncToAPM();

            Console.WriteLine("File length={0}", length);

        }

        static async Task<int> AsyncToAPM()

        {

            byte[] s_data = new byte[];

            FileStream fs = new FileStream(@"d:\1.txt", FileMode.Open, FileAccess.Read, FileShare.Read, , FileOptions.Asynchronous);

            return await Task.Factory.FromAsync<byte[], int, int, int>(fs.BeginRead, fs.EndRead, s_data, , s_data.Length, fs);

        }

异步函数（async/await）应用于事件编程模型

示例代码（读取网络中一张图片的字节数）

        static void Main(string[] args)

        {

            Task<int> result = AsyncEvent(new Uri("http://image.baidu.com/search/detail?ct=503316480&z=0&ipn=d&word=%E5%9B%BE%E7%89%87&pn=0&spn=0&di=84991311930&pi=&rn=1&tn=baiduimagedetail&ie=utf-8&oe=utf-8&cl=2&lm=-1&cs=3063552411%2C3030228420&os=1484689785%2C3968535026&simid=0%2C0&adpicid=0&ln=30&fr=ala&fm=&sme=&cg=&bdtype=11&oriquery=&objurl=http%3A%2F%2Fwww.52ij.com%2Fuploads%2Fallimg%2F160317%2F1110104P8-4.jpg&fromurl=ippr_z2C%24qAzdH3FAzdH3Fooo_z%26e3Bcdt3_z%26e3Bv54AzdH3F25g2xtw5AzdH3F9cmaa0_z%26e3Bip4s&gsm=0"));

            Console.WriteLine(result.Result);

        }

        static async Task<int> AsyncEvent(Uri uri)

        {

            WebClient wc = new WebClient();

            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();

            wc.DownloadDataCompleted += (s, e) =>

            {

                if (e.Cancelled)

                    tcs.SetCanceled();

                else if (e.Error != null)

                    tcs.SetException(e.Error);

                else

                    tcs.SetResult(e.Result.Count());

            };

            wc.DownloadDataAsync(uri);

            return await tcs.Task;

        }

感谢大家的耐心阅读

巴特西

异步async/await简单应用与探究

异步函数（async/await）简单应用

异步函数（async/await）实现异步原理（状态机）

异步函数（async/await）简化异步编程模型（APM）

异步函数（async/await）应用于事件编程模型

最新文章

热门文章