异步编程(AsyncCallback委托,IAsyncResult接口,BeginInvoke方法,EndInvoke方法的使用小结)

转自 http://blog.csdn.net/richnaly/article/details/6697669，作者richnaly

(一)让我们来看看同步异步的区别

同步方法调用在程序继续执行之前需要等待同步方法执行完毕返回结果。

异步方法则在被调用之后立即返回以便程序在被调用方法完成其任务的同时执行其它操作。

.NET框架基类库中有好几种类都可以提供同步和异步的方法调用。

因为同步方法调用会导致程序流程中途等待，所以采用同步方法的情况下往往会导致程序执行的延迟，相比来说，在某些条件下选择异步方法调用就可能更好一些。

例如：有的时候程序需要给多个Web服务发出请求，还有远程处理信道（HTTP、TCP）和代理，这时就最好采用异步方法。

.NET Framework允许异步调用任何方法，定义与需要调用的方法具有相同签名的委托。CLR将自动为该委托定义添加适当签名的BeginInvoke虚方法和EndInvoke虚方法和Invoke方法。

(二) 我们先来了解这2个方法和一个委托和一个接口

(1)BeginInvoke方法可启动异步调用。

它与您需要异步执行的方法具有相同的参数，另外它还有两个可选参数。第一个参数是一个AsyncCallback 委托，该委托引用在异步调用完成时要调用的方法。第二个参数是一个用户定义的对象，该对象可向回调方法传递信息。BeginInvoke立即返回，不等待异步调用完成。BeginInvoke 会返回 IAsyncResult，这个结果可用于监视异步调用进度。

结果对象IAsyncResult是从开始操作返回的，并且可用于获取有关异步开始操作是否已完成的状态。结果对象被传递到结束操作，该操作返回调用的最终返回值。在开始操作中可以提供可选的回调。如果提供回调，在调用结束后，将调用该回调；并且回调中的代码可以调用结束操作。

(2)EndInvoke方法检索异步调用的结果。

调用 BeginInvoke 后可随时调用 EndInvoke方法；如果异步调用尚未完成，EndInvoke 将一直阻止调用线程，直到异步调用完成后才允许调用线程执行。EndInvoke 的参数包括您需要异步执行的方法的 out 和 ref 参数以及由BeginInvoke 返回的 IAsyncResult。

(3)AsyncCallback委托用于指定在开始操作完成后应被调用的方法

AsyncCallback委托被作为开始操作上的第二个到最后一个参数传递。

代码原型如下：

[Serializable]

publicdelegate void AsyncCallback(IAsyncResult ar);

AsyncCallback为客户端应用程序提供完成异步操作的方法。开始异步操作时，该回调委托被提供给客户端。AsyncCallback引用的事件处理程序包含完成客户端异步任务的程序逻辑。

AsyncCallback使用 IAsyncResult 接口获取异步操作的状态。

(4)IAsyncResult接口

它表示异步操作的状态.该接口定义了4个公用属性。

代码原型如下：

publicinterface IAsyncResult

(三) 控制台源码

[csharp]  view plain  copy

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Threading;  
6.   
7. namespace AsyncStudy  
8. {  
9.     class Program  
10.     {  
11.         static void Main(string[] args)  
12.         {  
13.             DemoSyncCall(); //示例 1  
14.             //DemoEndInvoke();//示例 2  
15.             //DemoWaitHandle();//示例 3  
16.             //DemoPolling();//示例 4  
17.             //DemoCallback();//示例 5  
18.             Console.ReadLine();  
19.         }  
20.   
21.         /// <summary>  
22.         /// 实现委托的方法  
23.         /// </summary>  
24.         /// <param name="iCallTime"></param>  
25.         /// <param name="iExecThread"></param>  
26.         /// <returns></returns>  
27.         public static string LongRunningMethod(int iCallTime, out int iExecThread)  
28.         {  
29.             Thread.Sleep(iCallTime);  
30.             iExecThread = AppDomain.GetCurrentThreadId();  
31.             return "MyCallTime was:" + iCallTime.ToString();  
32.         }  
33.   
34.         delegate string MethodDelegate(int iCallTime, out int iExecThread);  
35.  
36.         #region 示例 1： 同步调用方法  
37.         /// <summary>  
38.         /// 同步调用方法  
39.         /// </summary>  
40.         public static void DemoSyncCall()  
41.         {  
42.             string str;  
43.             int iExecThread;  
44.             MethodDelegate md = new MethodDelegate(LongRunningMethod);  
45.             str = md(3000, out iExecThread);  
46.             Console.WriteLine("the Delegate call returned string:{0},and the thread ID is:{1}", str, iExecThread.ToString());  
47.             //sara Bareilles  
48.         }  
49.         #endregion  
50.  
51.         #region 示例 2： 通过EndInvoke()调用模式异步调用模式  
52.         /* 
53.          * 使用调用模式是要调用 BeginInvoke ， 做某些处理主线程, 并调用 EndInvoke() 。  
54.          * 注意不 EndInvoke() 不返回直到异步调用已完成。  
55.          * 此调用模式是有用当要有调用线程正在执行异步调用， 同时工作。  
56.          * 有同时发生工作可改善许多应用程序的性能。  
57.          * 常见任务以异步运行以此方式是文件或网络操作。  
58.          * */  
59.         /// <summary>  
60.         /// 通过EndInvoke()调用模式异步调用模式  
61.         /// </summary>  
62.         public static void DemoEndInvoke()  
63.         {  
64.             string str;  
65.             int iExecTread;  
66.             MethodDelegate dlgt = new MethodDelegate(LongRunningMethod);  
67.             IAsyncResult iar = dlgt.BeginInvoke(5000, out iExecTread, null, null);  
68.             str = dlgt.EndInvoke(out iExecTread, iar);  
69.             Console.WriteLine("the Delegate call returned string:{0},and the number is:{1}", str, iExecTread.ToString());  
70.         }  
71.         #endregion  
72.         #region  示例 3：异步调用方法并使用 A WaitHandle 来等待调用完成  
73.         /* 
74.          * 由 BeginInvoke() 返回 IAsyncResult 具有一个 AsyncWaitHandle 属性。  
75.          * 该属性返回 WaitHandle 异步调用完成后， 通知是。 等待 WaitHandle 是常见线程同步技术。  
76.          * 通过是 WaitHandle WaitOne() 方法调用线程等待 WaitHandle 上。  
77.          * 直到是通知 WaitHandle WaitOne() 块。 当 WaitOne() 返回, 您在调用 EndInvoke() 之前进行一些额外工作。  
78.          * 对于执行文件或网络操作， 否则会阻塞调用主线程存为, 以前示例中此技术很有用。 
79.          * */  
80.         /// <summary>  
81.         /// 异步调用方法并使用 A WaitHandle 来等待调用完成  
82.         /// </summary>  
83.         public static void DemoWaitHandle()  
84.         {  
85.             string str;  
86.             int iExecTread;  
87.             MethodDelegate dlgt = new MethodDelegate(LongRunningMethod);  
88.             IAsyncResult iar = dlgt.BeginInvoke(3000, out iExecTread, null, null);  
89.             iar.AsyncWaitHandle.WaitOne();  
90.             str = dlgt.EndInvoke(out iExecTread, iar);  
91.             Console.WriteLine("the Delegate call returned string:{0},and the number is:{1}", str, iExecTread.ToString());  
92.         }  
93.         #endregion  
94.         #region 示例 4： 异步调用方法通过轮询调用模式  
95.         /* 
96.          * 由 BeginInvoke() 返回 IAsyncResult 对象有个 IsCompleted 属性异步调用完成后返回 True 。  
97.          * 然后可调用 EndInvoke() 。 如果您应用程序不断工作对不做要长期函数调用已被此调用模式很有用。  
98.          * MicrosoftWindows 应用程序是这样的示例。  
99.          * 主线程的 Windows 应用程序可以继续以执行异步调用时处理用户输入。  
100.          * 它可定期检查 IsCompleted 到调用是否完成。 它调用 EndInvoke 当 IsCompleted 返回 True 。  
101.          * 直到它知道操作已完成因为 EndInvoke() 阻止直到异步操作为完整, 应用程序不调用它。  
102.          * */  
103.         /// <summary>  
104.         ///  异步调用方法通过轮询调用模式  
105.         /// </summary>  
106.         public static void DemoPolling()  
107.         {  
108.             string str;  
109.             int iExecThread;  
110.             MethodDelegate dlgt = new MethodDelegate(LongRunningMethod);  
111.             IAsyncResult iar = dlgt.BeginInvoke(3000, out iExecThread, null, null);  
112.             while(iar.IsCompleted==false)  
113.             {  
114.                 Thread.Sleep(10);  
115.             }  
116.             str = dlgt.EndInvoke(out iExecThread, iar);  
117.             Console.WriteLine("the Delegate call returned string:{0},and the number is:{1}", str, iExecThread.ToString());  
118.         }  
119.         #endregion  
120.  
121.         #region 示例 5： 异步方法完成后执行回调  
122.         /* 
123.          * 本节, 中示例提供对 BeginInvoke() 函数， 异步调用完成后系统执行回调委托。  
124.          * 回调调用 EndInvoke() 并处理异步调用的结果。  
125.          * 如果启动异步调用线程不需要处理结果是调用此调用模式很有用。  
126.          * 异步调用完成后系统调用线程以外启动线程上调。  
127.          * 若使用此调用模式, 作为第二到最后 - BeginInvoke() 函数的参数必须传递 AsyncCallback 类型的委托。  
128.          * BeginInvoke() 还有最后参数键入 对象 到您可以将任何对象。 当它调用该对象可用于您回调函数。  
129.          * 为此参数一个重要用途是以传递用于初始化调用该委托。  
130.          * 回调函数然后使用与该委托 EndInvoke() 函数来完成调用。 此调用模式是所示。 
131.          * */  
132.         /// <summary>  
133.         /// 异步方法完成后执行回调  
134.         /// </summary>  
135.         public static void DemoCallback()  
136.         {  
137.             MethodDelegate dlgt = new MethodDelegate(LongRunningMethod);  
138.             int iExecThread;  
139.             AsyncCallback asyncCallback = new AsyncCallback(MyAsyncCallback);  
140.             IAsyncResult iar = dlgt.BeginInvoke(5000,out iExecThread, asyncCallback, dlgt);  
141.         }  
142.   
143.         /// <summary>  
144.         ///  异步方法完成后执行回调  
145.         /// </summary>  
146.         /// <param name="iar"></param>  
147.         public static void MyAsyncCallback(IAsyncResult iar)  
148.         {  
149.             string str;  
150.             int iExecThread;  
151.             MethodDelegate dlgt = (MethodDelegate)iar.AsyncState;  
152.             str = dlgt.EndInvoke(out iExecThread, iar);  
153.             Console.WriteLine("the Delegate call returned string:{0},and the number is:{1}", str, iExecThread.ToString());  
154.         }  
155.         #endregion  
156.     }  
157. }  

(四)总结

四种使用BeginInvoke和EndInvoke进行异步调用的常用方法。在调用BeginInvoke 之后，可以执行下列操作：

1.进行某些操作，然后调用 EndInvoke 一直阻止到调用完成。

2.使用 System.IAsyncResult.AsyncWaitHandle 属性获取 WaitHandle，使用它的 WaitOne 方法一直阻止执行直到发出 WaitHandle 信号，然后调用 EndInvoke。

3.轮询由 BeginInvoke 返回的 IAsyncResult，确定异步调用何时完成，然后调用 EndInvoke。

4.将用于回调方法的委托传递给 BeginInvoke。异步调用完成后，将在ThreadPool 线程上执行该方法。该回调方法将调用 EndInvoke。

注意： 每次都要调用EndInvoke来完成异步调用。