C#异步编程模型

什么是异步编程模型

异步编程模型(Asynchronous Programming Model，简称APM)是C#1.1支持的一种实现异步操作的编程模型，虽然已经比较“古老”了，但是依然可以学习一下的。通过对APM的学习，我总结了以下三点：

1. APM的本质是使用委托和线程池来实现异步编程的。

2. 实现APM的关键是要实现IAsyncResult接口。

3. 实现了APM的类都会定义一对形如BeginXXX()和EndXXX()的方法，例如，FileStream类定义了BeginRead()方法和EndRead()方法，可以实现异步读取文件内容。

下面我们就通过具体的代码来实现异步编程模型。

实现异步编程模型

1. 实现IAsyncResult接口

IAsyncResult接口是C#类库中定义的一个接口，表示异步操作的状态，具体介绍可以查看MSDN。

  public interface IAsyncResult
 {
     object AsyncState { get; }
 
     WaitHandle AsyncWaitHandle { get; }
 
     bool CompletedSynchronously { get; }
 
     bool IsCompleted { get; }
 }

上面的代码是IAsyncResult接口声明的四个属性：

1. AsyncState属性是一个用户定义的对象，包含异步操作状态信息。例如，当我们调用FileStream类的BeginRead()方法进行异步读取文件内容时，传入的最后一个参数对应的就是AsyncState属性。

2. AsyncWaitHandle属性主要的作用是阻塞当前线程来等待异步操作完成。WaitHandle抽象类，有一个很重要的派生类ManualResetEvent。

3. CompletedSynchronously属性比较特别，用来判断异步操作是否是同步完成(这个有点儿绕~)。

4. IsCompleted属性就比较简单了，用来判断异步操作是否完成，true表示已完成，false表示还未完成。

在实现IAsyncResult接口时，我们主要会用到AsyncState，IsCompleted和AsyncWaitHandle属性。

 /// <summary>
 /// CalculatorAsyncResult<T>类，实现了IAsyncResult接口
 /// </summary>
 /// <typeparam name="T"></typeparam>
 public class CalculatorAsyncResult<T> : IAsyncResult
 {
     private ManualResetEvent _waitHandle;
 
     private object _asyncState;
 
     private bool _completedSynchronously;
 
     private bool _isCompleted;
 
     //我们传入的异步回调方法
     private AsyncCallback _asyncCallback;
 
     //保存异步操作返回结果
     public T CalulatorResult { get; set; }
 
     public static CalculatorAsyncResult<T> CreateCalculatorAsyncResult(Func<T> work, AsyncCallback asyncCallback, object obj)
     {
         var asyncResult = new CalculatorAsyncResult<T>(obj, asyncCallback, false, false);
 
         asyncResult.ExecuteWork(work);
 
         return asyncResult;
     }
 
     public CalculatorAsyncResult(object obj, AsyncCallback asyncCallback, bool completedSynchronously, bool isCompleted)
     {
         _waitHandle = new ManualResetEvent(false);
 
         _asyncState = obj;
 
         _completedSynchronously = completedSynchronously;
 
         _isCompleted = isCompleted;
 
         _asyncCallback = asyncCallback;
     }
 
     public object AsyncState
     {
         get { return _asyncState; }
     }
 
     public WaitHandle AsyncWaitHandle
     {
         get{ return _waitHandle; }
     }
 
     public bool CompletedSynchronously
     {
         get { return _completedSynchronously; }
     }
 
     public bool IsCompleted
     {
         get { return _isCompleted; }
     }
 
     public void Wait()
     {
         _waitHandle.WaitOne();
     }
 
     /// <summary>
     /// 调用异步回调方法
     /// </summary>
     private void InvokeAsyncCallback()
     {
         _isCompleted = true;
 
         if (_waitHandle != null)
         {
             _waitHandle.Set();
         }
 
         //调用我们传入的异步回调方法
         _asyncCallback(this);
     }
 
     /// <summary>
     /// 执行异步工作
     /// </summary>
     /// <param name="work"></param>
     public void ExecuteWork(Func<T> work)
     {
         if(_asyncCallback != null)
         {
             Task<T> task = Task.Factory.StartNew<T>(work);
 
             task.ContinueWith(t =>
             {
                 CalulatorResult = t.Result;
 
                 InvokeAsyncCallback();
             });
         }
         else
         {
             _isCompleted = true;
 
             if(_waitHandle != null)
             {
                 _waitHandle.Set();
             }
         }
     }
 }

2. 定义BeginXXX()和EndXXX()方法

下面就来定义我们自己的APM接口和具体实现类，编写BeginXXX()和EndXXX()方法。

 /// <summary>
 /// 异步计算接口
 /// </summary>
 /// <typeparam name="T"></typeparam>
  public interface ICalculator<T>
  {
      IAsyncResult BeginAdd(T x, T y, AsyncCallback asyncCallback, Object obj);
 
      T EndAdd(IAsyncResult ar);
  }

 /// <summary>
 /// 异步计算接口实现类
 /// </summary>
  public class Calculator : ICalculator<double>
 {
     public IAsyncResult BeginAdd(double x, double y, AsyncCallback asyncCallback, Object obj)
     {
         return CalculatorAsyncResult<double>.CreateCalculatorAsyncResult(delegate { return Add(x, y); }, asyncCallback, obj);
     }
 
     public double EndAdd(IAsyncResult ar)
     {
         var calculatorAsyncResult = (CalculatorAsyncResult<double>)(ar);
 
         calculatorAsyncResult.Wait();
 
         return calculatorAsyncResult.CalulatorResult;
     }
 
     /// <summary>
     /// 计算方法
     /// </summary>
     /// <param name="x"></param>
     /// <param name="y"></param>
     /// <returns></returns>
     protected double Add(double x, double y)
     {
         Console.WriteLine("Async thread(id={0}) begins.\n", Thread.CurrentThread.ManagedThreadId);
 
         Console.WriteLine("Async thread(id={0}) is calculating...\n", Thread.CurrentThread.ManagedThreadId);
 
         Thread.Sleep();
 
         var r = x + y;
 
         Console.WriteLine("Async thread(id={0}) ends.\n", Thread.CurrentThread.ManagedThreadId);
 
         return r;
     }
 }

3. 获取异步操作结果

APM提供了四种获取异步操作的结果方式供我们选择：

1. 通过IAsyncResult的AsyncWaitHandle属性，调用它的WaitOne()方法使调用线程阻塞来等待异步操作完成再调用EndXXX()方法来获取异步操作结果。

2. 在调用BeginXXX()方法的线程上调用EndXXX()方法来获取异步操作结果。这种方式也会阻塞调用线程(阻塞原理同方式1，具体在上面的代码中有体现)。

3. 轮询IAsyncResult的IsComplete属性，当异步操作完成后再调用EndXXX()方法来获取异步操作结果。

4. 使用 AsyncCallback委托来指定异步操作完成时要回调的方法，在回调方法中调用EndXXX()方法来获取异步操作结果。

在上述的四种方式中，只有第四种方式是完全不会阻塞调用线程的，所以多数情况下我们都会选择回调的方式来获取异步操作结果。

  public class Program
 {
     public static double result = ;
 
     static void Main(string[] args)
     {
         Console.WriteLine("Main thread(id={0}) begins.\n", Thread.CurrentThread.ManagedThreadId);
 
         var calculator = new Calculator();
 
         Console.WriteLine("Main thread(id={0}) invokes BeginAdd() function.\n", Thread.CurrentThread.ManagedThreadId);
 
         calculator.BeginAdd(, , Callback, calculator);
 
         Console.WriteLine("Main thread(id={0}) is sleeping...\n", Thread.CurrentThread.ManagedThreadId);
 
         Thread.Sleep();
 
         Console.WriteLine("The calculating result of async operation is {0}.\n", result);
 
         Console.WriteLine("Main thread(id={0}) ends.\n", Thread.CurrentThread.ManagedThreadId);
     }
 
     /// <summary>
     /// 我们定义的回调方法
     /// </summary>
     /// <param name="ar"></param>
     public static void Callback(IAsyncResult ar)
     {
         var calculator = (Calculator)(ar.AsyncState);
 
         result = calculator.EndAdd(ar);
     }
 }

运行结果：

至此，我们已经完整地实现了APM异步编程模型，从运行结果中我们可以得出，通过回调的方式来获取异步操作结果是完全不会阻塞调用线程的。

总结

1. 实现APM的关键是实现IAsyncResult接口。在IAsyncResult实现类中，需要使用线程池来异步地执行操作，在操作完成之后，再调用传入的回调方法来返回操作结果。

2. 实现了APM的类中都会定义一对BeginXXX()和EndXXX()方法，开始异步操作，结束异步操作并返回异步操作结果。

3. 获取异步操作结果有四种方式，但是只有回调方式是完全不会阻塞调用线程的，其他的都会阻塞调用线程。