使用C#委托来实现异步编程

最近在我参与的几个.Net项目中都有用到异步编程，作为一名.Net小白，很有必要好好地学习一下异步编程。

什么是异步编程

异步编程指的就是不用阻塞当前线程来等待任务的完成，而是将任务扔到线程池中去执行，当前线程可以继续向下执行，直至其它线程将任务完成，并回调通知当前线程。整个任务从开始到结束都是异步完成的，不会阻塞当前线程。因此，异步编程很重要的一点就是，不会阻塞当前线程。

异步编程实现

在C#语言中，通过委托可以很方便地实现异步编程，在委托类型中定义了两个方法BeginInvoke()和EndInvoke()。

/// <summary>
/// 开始执行异步操作.
/// </summary>
/// <param name="param">委托方法的参数</param>
/// <param name="callback"></param>
/// <param name="object"></param>
/// <returns></returns>
IAsyncResult BeginInvoke(int param, AsyncCallback callback, Object @object);
/// <summary>
/// 结束执行异步操作，并且返回异步操作结果.
/// </summary>
/// <param name="result"></param>
/// <returns>委托方法的返回类型</returns>
string EndInvoke(IAsyncResult result);

下面就通过一段代码来具体实现异步编程

 /// <summary>
 /// 定义一个委托类型
 /// </summary>
 public delegate int AddDel(int x, int y);

 /// <summary>
 /// 任务类
 /// </summary>
 public class TaskClass
 {
     //计算任务
     public static int AddTask(int x, int y)
     {
         Console.WriteLine("异步线程(ThreadId = {0})开始执行计算任务.\n", Thread.CurrentThread.ManagedThreadId);

         Console.WriteLine("异步线程(ThreadId = {0})计算中...\n", Thread.CurrentThread.ManagedThreadId);

         Thread.Sleep();

         int result = x + y;

         Console.WriteLine("异步线程(ThreadId = {0})结束执行计算任务.\n", Thread.CurrentThread.ManagedThreadId);

         return result;
     }
 }

 /// <summary>
 /// 实现异步编程，主线程不会阻塞
 /// </summary>
 public class AsynCallbackClass
 {
     public static int result;

     public static void Main(string[] args)
     {
         Console.WriteLine("主线程(ThreadId = {0})开始执行.\n", Thread.CurrentThread.ManagedThreadId);

         AddDel addDel = new AddDel(TaskClass.AddTask);

         int x = , y = ;

         Console.WriteLine("主线程(ThreadId = {0})调用BeginInvoke()方法开始执行异步操作.\n", Thread.CurrentThread.ManagedThreadId);

         //开始执行异步操作，Callback为定义的回调方法.
         addDel.BeginInvoke(x, y, Callback, null);

         Console.WriteLine("主线程(ThreadId = {0})继续执行...\n", Thread.CurrentThread.ManagedThreadId);

         Thread.Sleep();

         //输出计算任务返回的结果
         Console.WriteLine("计算结果：{0} + {1} = {2}.\n", x, y, result);

         Console.WriteLine("主线程(ThreadId = {0})执行结束.\n", Thread.CurrentThread.ManagedThreadId);
     }

     /// <summary>
     /// 回调方法
     /// </summary>
     /// <param name="ar"></param>
     public static void Callback(IAsyncResult ar)
     {
         AsyncResult asyncResult = ar as AsyncResult;

         if (asyncResult == null) { return; }

         AddDel addDel = asyncResult.AsyncDelegate as AddDel;

         if (addDel == null) { return; }

         Console.WriteLine("回调方法中调用EndInvoke()方法结束执行异步操作，获取计算任务结果.\n", Thread.CurrentThread.ManagedThreadId);

         //结束执行异步操作，并返回计算任务结果.
         result = addDel.EndInvoke(ar);
     }
 }

运行结果：

从运行结果中，我们可以发现主线程在调用了BeginInvoke()方法后，没有阻塞，而是继续向下执行，而且任务也确实由一个新的线程来执行，任务执行结束后，调用回调方法，在回调方法中调用EndInvoke()方法来获取任务执行结果。

总结

1. 在异步编程中，当前线程是不会被阻塞的。

2. C#的委托机制可以很方便地实现异步编程。