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

什么是异步编程？

异步编程指的就是不用阻塞当前线程来等待任务的完成，而是将任务扔到线程池中去执行，当前线程可以继续向下执行，直至其它线程将任务完成，并回调通知当前线程。

整个任务从开始到结束都是异步完成的，不会阻塞当前线程。因此，异步编程很重要的一点就是，不会阻塞当前线程。

异步编程实现

 在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>
///<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})开始执行计算任务.
",Thread.CurrentThread.ManagedThreadId);
         Console.WriteLine("异步线程(ThreadId={0})计算中...
",Thread.CurrentThread.ManagedThreadId);
          Thread.Sleep(3000);
           int result=x+y;
           Console.WriteLine("异步线程(ThreadId={0}）结束执行计算任务.
",Thread.CurrentThread.ManagedThreadId);
            return result;
}
}
///<summary>
///实现异步编程，主线程不会阻塞
///</summary>
public class AsynCallbackClass
{
    public static int result;
   public static void Main(string[] args)
     {
          Console.WriteLine("主线程(ThreadId={0})开始执行.
",Thread.CurrentThread.ManagedThreadId);
          AddDel addDel=new AddDel(TaskClass.AddTask);
          int x=123457,y=48759;
          Console.WriteLine("主线程(ThreadId={0})调用BeginInvoke()方法开始执行异步操作.
",
           Thread.CurrentThread.ManagedThreadId);
        //开始执行异步操作，Callback为定义的回调方法
addDel.BeginInvoke(x,y,Callback,null);
         Console.WriteLine("主线程(ThreadId={0})继续执行...
",Thread.CurrentThread.ManagedThreadId);
         Thread.Sleep(5000);
//输出计算任务返回的结果
         Console.WriteLine("计算结果:{0}+{1}={2}.
",x,y,result);
          Console.WriteLine("主线程(ThreadId={0})执行结束.
",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()方法结束执行异步操作，获取计算任务结果.
",Thread.CurrentThread.ManagedThreadId);
 //结束执行异步操作，并返回计算任务结果
result=addDel.EndInvoke(ar);
}
}

运行结果：

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

总结

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

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