C#异步模式

C#提供了几种针对异步代码编程的模式，我们一个一个看一下。

APM

APM即异步编程模型的简写（Asynchronous Programming Model），.NET 1.0 就开始提供的异步编程方式。

针对一些需要异步编程的同步方法，会同时提供BeginXXX和EndXXX的异步编程搭配方法，比如Socket的Connect方法是同步方法，对应的异步编程方法就是“BeginConnect”和“EndConnect”。

我们直接看看官方提供的同步和异步方法的声明：

// 同步方法，阻塞当前线程，连接成功后继续运行
public void Connect(EndPoint remoteEP)
// 异步方法，开新线程运行代码，不会阻塞当前线程
public IAsyncResult BeginConnect(EndPoint remoteEP, AsyncCallback callback, object state)
public void EndConnect(IAsyncResult asyncResult)

我们可以发现异步方法除了返回值变成了 IAsyncResult 对象外，还会额外增加 AsyncCallback 类型的 callback 参数，和 object 类型的 state 参数，下面我们说说这些对象的作用：

BeginXXX

开始一个异步操作，不会阻塞当前线程的执行，返回的IAsyncResult可以标识当前的异步操作对象。

EndXXX

需要传入BeginXXX返回的IAsyncResult对象，在对应的BeginXXX异步操作还没有结束时，调用该方法后会立即阻塞当前的线程的执行，并等待异步完成后，返回异步操作的结果并让线程继续执行。

注意，Socket的同步方法Connect没有返回值，所以EndConnect也没有返回值；我们看看FileStream的Read方法有一个int返回值(读入缓冲区中的总字节数。)，当使用异步方法调用时，要获得这个返回值就可以通过调用EndRead方法得到了。

IAsyncResult

标记当前异步操作的唯一标识，提供当前异步操作是否完成的标志、而AsyncState属性，就是调用BeginXXX时，传入的最后一个对象。

AsyncCallback

本质是一个委托，我们看下其定义：

public delegate void AsyncCallback(IAsyncResult ar);

在异步执行完成后。会调用这个委托方法告知到主线程异步完成。

异步APM实现

除了使用官方提供的BeginXXX和EndXXX之外，我们该如何自己实现类似的异步方法呢？请往下看：

委托的异步APM

.NET除了对大量的API提供了BeginXXX和EndXXX的APM异步编程模型实现，还会对所有的委托都提供 BeginInvoke 和 EndInvoke 的方法，如同API中提供的 BeginXXX 和 EndXXX 一致，我们可以通过这个特性，快速的编写异步代码，如下：

using System;
using System.Diagnostics;
using System.Threading;

namespace NewStudyTest
{
    public class APMDelegateTest
    {
        public APMDelegateTest()
        {
            Func<int, int> WaitSecond = time =>
            {
                Console.Out.WriteLine("开始执行异步操作");

                Thread.Sleep(time);

                Console.Out.WriteLine("异步操作执行完成");

                return new Random().Next();
            };

            WaitSecond.BeginInvoke(3000, ar =>
            {
                Console.Out.WriteLine("返回值: " + WaitSecond.EndInvoke(ar) + ", " + ar.AsyncState);
            }, "hello APM");

            Console.Out.WriteLine("程序继续执行");

            // 因为 BeginInvoke 启动的是后台线程，所以这里要避免程序主线程关闭
            Thread.Sleep(5000);
        }
    }
}

注意：BeginInvoke方法是从ThreadPool中取出一个线程来执行这个方法。

实现自己的BeginXXX和EndXXX

其实我们运用上面提到的委托的 BeginInvoke 和 EndInvoke 方法就可以实现自己的异步方法，如下：

using System;
using System.Threading;

namespace NewStudyTest
{
    public class APMTest
    {
        public static void Test()
        {
            var test = new APMTest();
            test.BeginWaitSecond(3000, ar =>
            {
                Console.Out.WriteLine("返回值: " + test.EndWaitSecond(ar) + ", " + ar.AsyncState);
            }, "hello APM");

            Console.Out.WriteLine("程序继续执行");

            // 因为 BeginInvoke 启动的是后台线程，所以这里要避免程序主线程关闭
            Thread.Sleep(5000);
        }

        public Func<int, int> _waitSecond;

        public APMTest()
        {
            _waitSecond = WaitSecond;
        }

        public int WaitSecond(int time)
        {
            Thread.Sleep(time);
            return new Random().Next();
        }

        public IAsyncResult BeginWaitSecond(int time, AsyncCallback callback, object state)
        {
            return _waitSecond.BeginInvoke(time, callback, state);
        }

        public int EndWaitSecond(IAsyncResult asyncResult)
        {
            return _waitSecond.EndInvoke(asyncResult);
        }
    }
}

直接调用委托对应的方法即可，是不是非常简单。

EAP

EAP 是 Event-based Asynchronous Pattern(基于事件的异步模型)的简写，在APM中不支持对异步操作的取消，也没有提供对进度报告的功能，所以在 .NET 2.0 中增加了 EAP 来处理这些问题。

基于EPA的类将具有一个或者多个以Async为后缀的方法和对应的Completed等相应的事件，并且这些类都支持异步方法的取消、进度报告和报告结果。

当我们调用实现基于事件的异步模式的类的 XxxAsync方法时，即代表开始了一个异步操作，该方法调用完之后会使一个线程池线程去执行耗时的操作。并且基于事件的异步模式是建立了APM的基础之上的。

下面我们看一个例子：

using System;
using System.Net;

namespace NewStudyTest
{
    public class EAPTest
    {
        public EAPTest()
        {
            WebClient wc = new WebClient();
            wc.DownloadStringCompleted += DownloadStringCompleted;
            wc.DownloadStringAsync(new Uri("http://www.baidu.com"));
            Console.ReadKey();
        }

        private static void DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            Console.WriteLine("网页：" + e.Result);
        }
    }
}

使用上是不是更加的简洁和直观了。

实现自己的XXXAsync

using System;
using System.ComponentModel;
using System.Runtime.Remoting.Messaging;
using System.Threading;

namespace NewStudyTest
{
    /// <summary>
    /// 扩展 AsyncCompletedEventArgs 添加内容属性
    /// </summary>
    public class DownloadCompletedEventArgs : AsyncCompletedEventArgs
    {
        private string _content;

        public DownloadCompletedEventArgs(string content, Exception error, bool cancelled, Object userState) : base(error, cancelled, userState)
        {
            _content = content;
        }

        public string Content
        {
            get { return _content; }
        }
    }

    public class EAPDownloader
    {
        public static void Test()
        {
            var downloader = new EAPDownloader();
            downloader.progressChanged += (sender, args) =>
            {
                Console.Out.WriteLine("下载中: " + args.ProgressPercentage);
            };
            downloader.downloadCompleted += (sender, args) =>
            {
                Console.Out.WriteLine("下载完成：" + args.Content + "，是否取消：" + args.Cancelled);
            };
            downloader.DownloadAsync("http://xiazai.com/xxx.avi", "Hello");

            Thread.Sleep(5000);
            downloader.CancelAsync();

            Console.Out.WriteLine("程序继续执行");
            Console.ReadKey();
        }

        // 下载完成委托
        public delegate void DownloadCompletedEventHandler(object sender, DownloadCompletedEventArgs e);

        // 对外的事件
        public event ProgressChangedEventHandler progressChanged;
        public event DownloadCompletedEventHandler downloadCompleted;

        // AsyncOperation 使用的委托
        private SendOrPostCallback _onProgressChangedDelegate;
        private SendOrPostCallback _onDownloadCompletedDelegate;

        // 实际上实现下载模拟的代码委托, 即耗时函数
        private delegate string DownLoadHandler(string url, string name, AsyncOperation asyncOp);

        // 记录是否调用了取消异步方法
        private bool _cancelled = false;

        public EAPDownloader()
        {
            _onProgressChangedDelegate = new SendOrPostCallback(onProgressChanged);
            _onDownloadCompletedDelegate = new SendOrPostCallback(onDownloadComplete);
        }

        private void onProgressChanged(object state)
        {
            if (progressChanged != null)
            {
                ProgressChangedEventArgs e = state as ProgressChangedEventArgs;
                progressChanged(this, e);
            }
        }

        private void onDownloadComplete(object state)
        {
            if (downloadCompleted != null)
            {
                DownloadCompletedEventArgs e = state as DownloadCompletedEventArgs;
                downloadCompleted(this, e);
            }
        }

        public string DownLoad(string url, string name)
        {
            return RealDownLoad(url, name, null);
        }

        public void DownloadAsync(string url, string name)
        {
            // 异步操作的唯一标识对象
            AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(null);

            // 这里异步的实现本质上还是使用 APM 的方式
            DownLoadHandler dh = new DownLoadHandler(RealDownLoad);
            dh.BeginInvoke(url, name, asyncOp, new AsyncCallback(DownloadCallBack), asyncOp);
        }

        private void DownloadCallBack(IAsyncResult iar)
        {
            AsyncResult aresult = (AsyncResult)iar;
            DownLoadHandler dh = aresult.AsyncDelegate as DownLoadHandler;
            // 获取返回值
            string r = dh.EndInvoke(iar);
            AsyncOperation ao = iar.AsyncState as AsyncOperation;
            // 抛出完成事件
            ao.PostOperationCompleted(_onDownloadCompletedDelegate, new DownloadCompletedEventArgs(r, null, _cancelled, null));
        }

        private string RealDownLoad(string url, string name, AsyncOperation asyncOp)
        {
            _cancelled = false;
            for (int i = 0; i < 10; i++)
            {
                int p = i * 10;
                Console.Out.WriteLine("执行线程:" + Thread.CurrentThread.ManagedThreadId + "，传输进度：" + p + "%");
                Thread.Sleep(1000);
                // 取消异步操作
                if (_cancelled)
                {
                    return name + "文件下载取消！";
                }
                // 不为空则是异步
                if (asyncOp != null)
                {
                    // 抛出进度事件
                    asyncOp.Post(_onProgressChangedDelegate, new ProgressChangedEventArgs(p, null));
                }
            }
            return name + "文件下载完成！";
        }

        public void CancelAsync()
        {
            _cancelled = true;
        }
    }
}

例子中，我们模拟了下载的异步操作，并实现了下载进度的通知和取消异步的操作。

实际上，我们发现，EAP的异步实现仍然使用的还是APM的委托来实现的。

AsyncOperation

标记一个唯一的异步操作，可以简单的理解为异步操作的唯一ID，提供的Post和PostOperationCompleted方法可以向调用的线程发送指定的消息，其用的PostMessage发送到线程，具体发送到那个线程，要看你同步上下文是和那个线程相关的。

接收消息的地方统一使用SendOrPostCallback委托来接收即可，接收到消息再调用对应的事件即可完成事件的异步调用了。

BackgroundWorker

上面我们发现实现一个EAP的异步模型还是需要编写比较多的代码的，为了简化编写的代码量，微软为我们提供了名为BackgroundWorker的类来使用。

一些耗时较长的CPU密集型运算需要开新线程执行时，就可以方便的用该类实现EAP的异步模型。

using System;
using System.ComponentModel;
using System.Threading;

namespace NewStudyTest
{
    public class BackgroundWorkerTest
    {
        public static void Test()
        {
            BackgroundWorker backgroundWorker = new BackgroundWorker();

            // 支持报告进度事件
            backgroundWorker.WorkerReportsProgress = true;
            // 支持异步取消
            backgroundWorker.WorkerSupportsCancellation = true;

            backgroundWorker.ProgressChanged += (sender, args) =>
            {
                Console.Out.WriteLine("执行中：" + args.ProgressPercentage + ", " + args.UserState);
            };
            backgroundWorker.RunWorkerCompleted += (sender, args) =>
            {
                if (args.Cancelled)
                {
                    Console.Out.WriteLine("执行取消！");
                }
                else
                {
                    Console.Out.WriteLine("执行完毕：" + args.Result);
                }
            };
            backgroundWorker.DoWork += (sender, args) =>
            {
                BackgroundWorker bw = sender as BackgroundWorker;

                // 获取参数
                int count = (int)args.Argument;

                int sum = 0;
                for (int i = 0; i < count; i++)
                {
                    sum++;

                    // 模拟耗时操作
                    Thread.Sleep(1000);

                    if (bw.CancellationPending)
                    {
                        args.Cancel = true;
                        return;
                    }

                    // 通知进度
                    bw.ReportProgress(i, "msg " + i);
                }

                args.Result = sum;
            };
            // 开始执行，可传参数
            backgroundWorker.RunWorkerAsync(10);

            Thread.Sleep(5000);
            backgroundWorker.CancelAsync();

            Console.Out.WriteLine("程序继续执行");
            Console.ReadKey();
        }
    }
}

可以发现通过使用BackgroundWork类可以省去自己实现EAP的繁琐步骤，可以专注于异步的实现。

TAP

进入.NET4.0的时代，微软提出了基于任务的异步模式(Task-based Asynchronous Pattern)，该模式主要使用同样在.NET4.0中引入的任务（即 System.Threading.Tasks.Task 和 Task<T> 类）来完成异步编程。

我们怎样区分.NET类库中的类实现了基于任务的异步模式呢? 这个识别方法很简单，当看到类中存在TaskAsync为后缀的方法时就代表该类实现了TAP。

我们先直接看例子：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace NewStudyTest
{
    public class TAPTest
    {
        public TAPTest()
        {
            CancellationTokenSource cts = new CancellationTokenSource();

            Task task = new Task((() =>
            {
                int result = DoCacl(10, cts.Token, new Progress<int>((i =>
                {
                    Console.Out.WriteLine("执行中：" + i);
                })));
                Console.Out.WriteLine("执行完毕：" + result);
            }));
            task.Start();

            Thread.Sleep(5000);
            cts.Cancel();

            Console.Out.WriteLine("程序继续执行");
            Console.ReadKey();
        }

        public int DoCacl(int count, CancellationToken ct, IProgress<int> progress)
        {
            int sum = 0;

            for (int i = 0; i < count; i++)
            {
                sum++;

                // 模拟耗时操作
                Thread.Sleep(1000);

                // 取消异步的判断
                if (ct.IsCancellationRequested)
                {
                    return -1;
                }

                // 进度报告
                progress.Report(i);
            }

            return sum;
        }
    }
}

我们发现通过使用Task类，异步代码的编写变得更加的简洁和易于理解，下面我们说说用到的一些类型。

CancellationTokenSource

支持取消异步操作的类。

CancellationToken

标识唯一的异步进程，当CancellationTokenSource调用取消后，可以通过判断其IsCancellationRequested来确定是否要退出耗时操作。

IProgress

向外部通知进度消息的接口。

异步方法直接返回值的例子

using System;
using System.Threading;
using System.Threading.Tasks;

namespace NewStudyTest
{
    public class TAPTest
    {
        public TAPTest()
        {
            Task<int> task = new Task<int>((() =>
            {
                Thread.Sleep(3000);

                return 123;
            }));
            task.Start();

            Console.Out.WriteLine("程序继续执行");

            // 阻塞线程等待 Task 执行完毕
            task.Wait();

            Console.Out.WriteLine("异步结果：" + task.Result);

            Console.ReadKey();
        }
    }
}

语法糖await和async

为了更方便的编写异步代码，.NET4.5（C#5.0）中，提供了语法糖await和async来实现用同步的方式来编写异步代码，注意需要和Task配合。

我们先看一个没有用该语法糖的例子：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace NewStudyTest
{
    public class TaskTest
    {
        public TaskTest()
        {
            Task.Run((() =>
            {
                Task task1 = Execute1();
                task1.Wait();
                Task<int> task2 = Execute2();
                task2.Wait();
                Console.Out.WriteLine("返回值: " + task2.Result);
                Task task3 = Execute3();
                task3.Wait();

                Console.Out.WriteLine("执行完毕");
            }));

            Console.Out.WriteLine("程序继续执行");
            Console.ReadKey();
        }

        private Task Execute1()
        {
            Task task = new Task((() =>
            {
                Thread.Sleep(1000);
                Console.Out.WriteLine("耗时操作1");
            }));
            task.Start();
            return task;
        }

        private Task<int> Execute2()
        {
            Task<int> task = new Task<int>((() =>
            {
                Thread.Sleep(1000);
                Console.Out.WriteLine("耗时操作2");
                return 123;
            }));
            task.Start();
            return task;
        }

        private Task Execute3()
        {
            Task task = new Task((() =>
            {
                Thread.Sleep(1000);
                Console.Out.WriteLine("耗时操作3");
            }));
            task.Start();
            return task;
        }
    }
}

再看使用了await和async语法糖的例子：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace NewStudyTest
{
    public class Task2Test
    {
        public Task2Test()
        {
            Task.Run(async () =>
            {
                await Execute1();
                Console.Out.WriteLine("返回值: " + await Execute2());
                await Execute3();

                Console.Out.WriteLine("执行完毕");
            });

            Console.Out.WriteLine("程序继续执行");
            Console.ReadKey();
        }

        private async Task Execute1()
        {
            Thread.Sleep(1000);
            Console.Out.WriteLine("耗时操作1");
        }

        private async Task<int> Execute2()
        {
            Thread.Sleep(1000);
            Console.Out.WriteLine("耗时操作2");
            return 123;
        }

        private async Task Execute3()
        {
            Thread.Sleep(1000);
            Console.Out.WriteLine("耗时操作3");
        }
    }
}

实现的效果完全一致，但是使用await和async可以更简洁也更像同步代码易于理解。

需要注意的地方

标记为 async 的异步函数的返回类型只能为: Task、Task<TResult>。

• Task<TResult>: 代表一个返回值T类型的操作。
• Task: 代表一个无返回值的操作。

await 只能修饰被调用的 async 的方法。