异步编程：异步编程模型(APM)

异步编程模型 (APM)是.NET1.0的时候就已经推出的古老异步编程模式，此模式基于IAsyncResult接口实现。

创新互联公司专注于企业全网营销推广、网站重做改版、集安网站定制设计、自适应品牌网站建设、成都h5网站建设、购物商城网站建设、集团公司官网建设、外贸营销网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为集安等各大城市提供网站开发制作服务。

随着技术的发展，又在“.NET1.0异步编程模型 (APM)”之后推出了“.NET2.0基于事件的编程模式”及“.NET4.X基于任务的编程模式”两种异步编程模式。尽管在新的设计上我们推荐都使用“.NET4.0基于任务的编程模式”，但我还是计划整理出旧版的异步编程模型，因为：

1. 在一些特殊场合下我们可能觉得一种模式更适合；

2. 可以更充分认识三种模式之间的优劣，便于选择；

3. 很多遗留的代码包含了旧的设计模式；

4. 等等…

示例下载：异步编程：IAsyncResult异步编程模型.rar

IAsyncResult设计模式----规范概述

使用IAsyncResult设计模式的异步操作是通过名为 Begin*** 和 End*** 的两个方法来实现的，这两个方法分别指代开始和结束异步操作。例如，FileStream类提供BeginRead和EndRead方法来从文件异步读取字节。这两个方法实现了 Read 方法的异步版本。

在调用 Begin*** 后，应用程序可以继续在调用线程上执行指令，同时异步操作在另一个线程上执行。（如果有返回值还应调用 End*** 来获取操作的结果）。

1) Begin***

a) Begin*** 方法带有该方法的同步版本签名中声明的任何参数。

b) Begin*** 方法签名中不包含任何输出参数。方法签名最后两个参数的规范是：第一个参数定义一个AsyncCallback委托，此委托引用在异步操作完成时调用的方法。第二个参数是一个用户定义的对象。此对象可用来向异步操作完成时为AsyncCallback委托方法传递应用程序特定的状态信息（eg：可通过此对象在委托中访问End*** 方法)。另外，这两个参数都可以传递null。

c) 返回IAsyncResult对象。

 
 
 
    
  
  
  
  1. // 表示异步操作的状态。 
    2. 
  
  
  
  2. [ComVisible(true)] 
    3. 
  
  
  
  3. public interface IAsyncResult 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5.     // 获取用户定义的对象，它限定或包含关于异步操作的信息。 
    6. 
  
  
  
  6.     object AsyncState { get; } 
    7. 
  
  
  
  7.     // 获取用于等待异步操作完成的System.Threading.WaitHandle，待异步操作完成时获得信号。 
    8. 
  
  
  
  8.     WaitHandle AsyncWaitHandle { get; } 
    9. 
  
  
  
  9.     // 获取一个值，该值指示异步操作是否同步完成。 
    10. 
  
  
  
  10.     bool CompletedSynchronously { get; } 
    11. 
  
  
  
  11.     // 获取一个值，该值指示异步操作是否已完成。 
    12. 
  
  
  
  12.     bool IsCompleted { get; } 
    13. 
  
  
  
  13. } 
    14. 
  
  
  
  14.   
    15. 
  
  
  
  15. // 常用委托声明（我后面示例是使用了自定义的带ref参数的委托） 
    16. 
  
  
  
  16. public delegate void AsyncCallback(IAsyncResult ar)
    17.

2) End***

a) End*** 方法可结束异步操作，如果调用 End*** 时，IAsyncResult对象表示的异步操作还未完成，则 End*** 将在异步操作完成之前阻塞调用线程。

b) End*** 方法的返回值与其同步副本的返回值类型相同。End*** 方法带有该方法同步版本的签名中声明的所有out 和 ref 参数以及由BeginInvoke返回的IAsyncResult，规范上 IAsyncResult 参数放最后。

i. 要想获得返回结果，必须调用的方法;

ii. 若带有out 和 ref 参数，实现上委托也要带有out 和 ref 参数，以便在回调中获得对应引用传参值做相应逻辑;

现在我们清楚了IAsyncResult设计模式的设计规范，接下来我们再通过IAsyncResult异步编程模式的三个经典场合来加深理解。

#p#

一、基于IAsyncResult构造一个异步API

现在来构建一个IAsyncResult的类，并且实现异步调用。

 
 
 
    
  
  
  
  1. // 带ref参数的自定义委托 
    2. 
  
  
  
  2. public delegate void RefAsyncCallback(ref string resultStr, IAsyncResult ar); 
    3. 
  
  
  
  3.   
    4. 
  
  
  
  4. public class CalculateAsyncResult : IAsyncResult 
    5. 
  
  
  
  5. { 
    6. 
  
  
  
  6.     private int _calcNum1; 
    7. 
  
  
  
  7.     private int _calcNum2; 
    8. 
  
  
  
  8.     private RefAsyncCallback _userCallback; 
    9. 
  
  
  
  9.   
    10. 
  
  
  
  10.     public CalculateAsyncResult(int num1, int num2, RefAsyncCallback userCallback, object asyncState) 
    11. 
  
  
  
  11.     { 
    12. 
  
  
  
  12.         this._calcNum1 = num1; 
    13. 
  
  
  
  13.         this._calcNum2 = num2; 
    14. 
  
  
  
  14.         this._userCallback = userCallback; 
    15. 
  
  
  
  15.         this._asyncState = asyncState; 
    16. 
  
  
  
  16.         // 异步执行操作 
    17. 
  
  
  
  17.         ThreadPool.QueueUserWorkItem((obj) => { AsyncCalculate(obj); }, this); 
    18. 
  
  
  
  18.     } 
    19. 
  
  
  
  19.   
    20. 
  
  
  
  20.     #region IAsyncResult接口 
    21. 
  
  
  
  21.     private object _asyncState; 
    22. 
  
  
  
  22.     public object AsyncState { get { return _asyncState; } } 
    23. 
  
  
  
  23.   
    24. 
  
  
  
  24.     private ManualResetEvent _asyncWaitHandle; 
    25. 
  
  
  
  25.     public WaitHandle AsyncWaitHandle 
    26. 
  
  
  
  26.     { 
    27. 
  
  
  
  27.         get 
    28. 
  
  
  
  28.         { 
    29. 
  
  
  
  29.             if (this._asyncWaitHandle == null) 
    30. 
  
  
  
  30.             { 
    31. 
  
  
  
  31.                 ManualResetEvent event2 = new ManualResetEvent(false); 
    32. 
  
  
  
  32.                 Interlocked.CompareExchange<ManualResetEvent>(ref this._asyncWaitHandle, event2, null); 
    33. 
  
  
  
  33.             } 
    34. 
  
  
  
  34.             return _asyncWaitHandle; 
    35. 
  
  
  
  35.         } 
    36. 
  
  
  
  36.     } 
    37. 
  
  
  
  37.   
    38. 
  
  
  
  38.     private bool _completedSynchronously; 
    39. 
  
  
  
  39.     public bool CompletedSynchronously { get { return _completedSynchronously; } } 
    40. 
  
  
  
  40.   
    41. 
  
  
  
  41.     private bool _isCompleted; 
    42. 
  
  
  
  42.     public bool IsCompleted { get { return _isCompleted; } } 
    43. 
  
  
  
  43.     #endregion 
    44. 
  
  
  
  44.   
    45. 
  
  
  
  45.     /// <summary> 
    46. 
  
  
  
  46.     /// 
    47. 
  
  
  
  47.     /// 存储最后结果值 
    48. 
  
  
  
  48.     /// </summary> 
    49. 
  
  
  
  49.     public int FinnalyResult { get; set; } 
    50. 
  
  
  
  50.     /// <summary> 
    51. 
  
  
  
  51.     /// End方法只应调用一次，超过一次报错 
    52. 
  
  
  
  52.     /// </summary> 
    53. 
  
  
  
  53.     public int EndCallCount = 0; 
    54. 
  
  
  
  54.     /// <summary> 
    55. 
  
  
  
  55.     /// ref参数 
    56. 
  
  
  
  56.     /// </summary> 
    57. 
  
  
  
  57.     public string ResultStr; 
    58. 
  
  
  
  58.   
    59. 
  
  
  
  59.     /// <summary> 
    60. 
  
  
  
  60.     /// 异步进行耗时计算 
    61. 
  
  
  
  61.     /// </summary> 
    62. 
  
  
  
  62.     /// <param name="obj">CalculateAsyncResult实例本身</param> 
    63. 
  
  
  
  63.     private static void AsyncCalculate(object obj) 
    64. 
  
  
  
  64.     { 
    65. 
  
  
  
  65.         CalculateAsyncResult asyncResult = obj as CalculateAsyncResult; 
    66. 
  
  
  
  66.         Thread.SpinWait(1000); 
    67. 
  
  
  
  67.         asyncResult.FinnalyResult = asyncResult._calcNum1 * asyncResult._calcNum2; 
    68. 
  
  
  
  68.         asyncResult.ResultStr = asyncResult.FinnalyResult.ToString(); 
    69. 
  
  
  
  69.   
    70. 
  
  
  
  70.         // 是否同步完成 
    71. 
  
  
  
  71.         asyncResult._completedSynchronously = false; 
    72. 
  
  
  
  72.         asyncResult._isCompleted = true; 
    73. 
  
  
  
  73.         ((ManualResetEvent)asyncResult.AsyncWaitHandle).Set(); 
    74. 
  
  
  
  74.         if (asyncResult._userCallback != null) 
    75. 
  
  
  
  75.             asyncResult._userCallback(ref asyncResult.ResultStr, asyncResult); 
    76. 
  
  
  
  76.     } 
    77. 
  
  
  
  77. } 
    78. 
  
  
  
  78.   
    79. 
  
  
  
  79. public class CalculateLib 
    80. 
  
  
  
  80. { 
    81. 
  
  
  
  81.     public IAsyncResult BeginCalculate(int num1, int num2, RefAsyncCallback userCallback, object asyncState) 
    82. 
  
  
  
  82.     { 
    83. 
  
  
  
  83.         CalculateAsyncResult result = new CalculateAsyncResult(num1, num2, userCallback, asyncState); 
    84. 
  
  
  
  84.         return result; 
    85. 
  
  
  
  85.     } 
    86. 
  
  
  
  86.   
    87. 
  
  
  
  87.     public int EndCalculate(ref string resultStr, IAsyncResult ar) 
    88. 
  
  
  
  88.     { 
    89. 
  
  
  
  89.         CalculateAsyncResult result = ar as CalculateAsyncResult; 
    90. 
  
  
  
  90.         if (Interlocked.CompareExchange(ref result.EndCallCount, 1, 0) == 1) 
    91. 
  
  
  
  91.         { 
    92. 
  
  
  
  92.             throw new Exception("End方法只能调用一次。"); 
    93. 
  
  
  
  93.         } 
    94. 
  
  
  
  94.         result.AsyncWaitHandle.WaitOne(); 
    95. 
  
  
  
  95.   
    96. 
  
  
  
  96.         resultStr = result.ResultStr; 
    97. 
  
  
  
  97.   
    98. 
  
  
  
  98.         return result.FinnalyResult; 
    99. 
  
  
  
  99.     } 
    100. 
  
  
  
  100.   
    101. 
  
  
  
  101.     public int Calculate(int num1, int num2, ref string resultStr) 
    102. 
  
  
  
  102.     { 
    103. 
  
  
  
  103.         resultStr = (num1 * num2).ToString(); 
    104. 
  
  
  
  104.         return num1 * num2; 
    105. 
  
  
  
  105.     } 
    106. 
  
  
  
  106. }
    107.

使用上面通过IAsyncResult设计模式实现的带ref引用参数的异步操作，我将展示三种阻塞式响应异步调用和一种无阻塞式委托响应异步调用。即：

1. 执行异步调用后，若我们需要控制后续执行代码在异步操作执行完之后执行，可通过下面三种方式阻止其他工作：

a) IAsyncResult的AsyncWaitHandle属性，待异步操作完成时获得信号。

b) 通过IAsyncResult的IsCompleted属性进行轮询。通过轮询还可实现进度条功能。

c) 调用异步操作的 End*** 方法。

2. 执行异步调用后，若我们不需要阻止后续代码的执行，那么我们可以把异步执行操作后的响应放到回调中进行。

 
 
 
    
  
  
  
  1. public class Calculate_Test 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     public static void Test() 
    4. 
  
  
  
  4.     { 
    5. 
  
  
  
  5.         CalculateLib cal = new CalculateLib(); 
    6. 
  
  
  
  6.   
    7. 
  
  
  
  7.         // 基于IAsyncResult构造一个异步API 
    8. 
  
  
  
  8.         IAsyncResult calculateResult = cal.BeginCalculate(123, 456, AfterCallback, cal); 
    9. 
  
  
  
  9.         // 执行异步调用后，若我们需要控制后续执行代码在异步操作执行完之后执行，可通过下面三种方式阻止其他工作： 
    10. 
  
  
  
  10.         // 1、IAsyncResult 的 AsyncWaitHandle 属性，带异步操作完成时获得信号。 
    11. 
  
  
  
  11.         // 2、通过 IAsyncResult 的 IsCompleted 属性进行轮询。通过轮询还可实现进度条功能。 
    12. 
  
  
  
  12.         // 3、调用异步操作的 End*** 方法。 
    13. 
  
  
  
  13.         // *********************************************************** 
    14. 
  
  
  
  14.         // 1、calculateResult.AsyncWaitHandle.WaitOne(); 
    15. 
  
  
  
  15.         // 2、while (calculateResult.IsCompleted) { Thread.Sleep(1000); } 
    16. 
  
  
  
  16.         // 3、 
    17. 
  
  
  
  17.         string resultStr = string.Empty; 
    18. 
  
  
  
  18.         int result = cal.EndCalculate(ref resultStr, calculateResult); 
    19. 
  
  
  
  19.     } 
    20. 
  
  
  
  20.   
    21. 
  
  
  
  21.     ///  
    22. 
  
  
  
  22.     /// 异步操作完成后做出响应 
    23. 
  
  
  
  23.     ///  
    24. 
  
  
  
  24.     private static void AfterCallback(ref string resultStr, IAsyncResult ar) 
    25. 
  
  
  
  25.     { 
    26. 
  
  
  
  26.         // 执行异步调用后，若我们不需要阻止后续代码的执行，那么我们可以把异步执行操作后的响应放到回调中进行。 
    27. 
  
  
  
  27.         CalculateLib cal = ar.AsyncState as CalculateLib; 
    28. 
  
  
  
  28.   
    29. 
  
  
  
  29.         //int result = cal.EndInvoke(ref resultStr, calculateResult1); 
    30. 
  
  
  
  30.         //if (result > 0) { } 
    31. 
  
  
  
  31.     } 
    32. 
  
  
  
  32. }
    33.

#p#

二、使用委托进行异步编程

对于委托，编译器会为我们生成同步调用方法“invoke”以及异步调用方法“BeginInvoke”和“EndInvoke”。对于异步调用方式，公共语言运行库 (CLR) 将对请求进行排队并立即返回到调用方，由线程池的线程调度目标方法并与提交请求的原始线程并行运行。

异步委托是快速为方法构建异步调用的方式，它基于IAsyncResult设计模式实现的异步调用，即，通过BeginInvoke返回IAsyncResult对象；通过EndInvoke获取结果值。

示例：

上节的CalculateLib类中的同步方法以及所要实用到的委托如下：

 
 
 
    
  
  
  
  1. // 带ref参数的自定义委托 
    2. 
  
  
  
  2. public delegate int AsyncInvokeDel(int num1, int num2, ref string resultStr); 
    3. 
  
  
  
  3. public int Calculate(int num1, int num2, ref string resultStr) 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5.     resultStr = (num1 * num2).ToString(); 
    6. 
  
  
  
  6.     return num1 * num2; 
    7. 
  
  
  
  7. }
    8.

然后，通过委托进行同步或异步调用：

 
 
 
    
  
  
  
  1. AsyncInvokeDel calculateAction = cal.Calculate; 
    2. 
  
  
  
  2. string resultStrAction = string.Empty; 
    3. 
  
  
  
  3. // int result1 = calculateAction.Invoke(123, 456, ref resultStrAction); 
    4. 
  
  
  
  4. IAsyncResult calculateResult1 = calculateAction.BeginInvoke(123, 456, ref resultStrAction, null, null); 
    5. 
  
  
  
  5. int result1 = calculateAction.EndInvoke(ref resultStrAction, calculateResult1);
    6.

#p#

三、多线程操作控件

访问 Windows 窗体控件本质上不是线程安全的。如果有两个或多个线程操作某一控件的状态，则可能会迫使该控件进入一种不一致的状态。还可能出现其他与线程相关的 bug，包括争用情况和死锁。确保以线程安全方式访问控件非常重要。

不过，在有些情况下，您可能需要多线程调用控件的方法。.NET Framework 提供了从任何线程操作控件的方式：

1. 非安全方式访问控件（此方式请永远不要再使用）

多线程访问窗口中的控件，可以在窗口的构造函数中将Form的CheckForIllegalCrossThreadCalls静态属性设置为false。

 
 
 
    
  
  
  
  1. // 获取或设置一个值，该值指示是否捕获对错误线程的调用， 
    2. 
  
  
  
  2. // 这些调用在调试应用程序时访问控件的System.Windows.Forms.Control.Handle属性。 
    3. 
  
  
  
  3. // 如果捕获了对错误线程的调用，则为 true；否则为 false。 
    4. 
  
  
  
  4. public static bool CheckForIllegalCrossThreadCalls { get; set; }
    5.

2. 安全方式访问控件

原理：从一个线程封送调用并跨线程边界将其发送到另一个线程，并将调用插入到创建控件线程的消息队列中,当控件创建线程处理这个消息时,就会在自己的上下文中执行传入的方法。（此过程只有调用线程和创建控件线程，并没有创建新线程）

注意：从一个线程封送调用并跨线程边界将其发送到另一个线程会耗费大量的系统资源，所以应避免重复调用其他线程上的控件。

1) 使用BackgroundWork后台辅助线程控件控件（AsyncOperationManager类和AsyncOperation类帮助器方式）。

2) 结合TaskScheduler.FromCurrentSynchronizationContext() 和Task 实现。

3) 使用Control类上提供的Invoke 和BeginInvoke方法。

因本文主要解说IAsyncResult异步编程模式，所以只详细分析Invoke 和BeginInvoke跨线程访问控件方式。

Control类实现了ISynchronizeInvoke接口，提供了Invoke和BeginInvoke方法来支持其它线程更新GUI界面控件的机制。

 
 
 
    
  
  
  
  1. public interface ISynchronizeInvoke 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     // 获取一个值，该值指示调用线程是否与控件的创建线程相同。 
    4. 
  
  
  
  4.     bool InvokeRequired { get; } 
    5. 
  
  
  
  5.     // 在控件创建的线程上异步执行指定委托。 
    6. 
  
  
  
  6.     AsyncResult BeginInvoke(Delegate method, params object[] args); 
    7. 
  
  
  
  7.     object EndInvoke(IAsyncResult asyncResult); 
    8. 
  
  
  
  8.     // 在控件创建的线程上同步执行指定委托。 
    9. 
  
  
  
  9.     object Invoke(Delegate method, params object[] args); 
    10. 
  
  
  
  10. }
    11.

1) Control类的 Invoke,BeginInvoke 内部实现如下:

a) Invoke （同步调用）先判断控件创建线程与当前线程是否相同，相同则直接调用委托方法；否则使用Win32API的PostMessage 异步执行。

b) BeginInvoke （异步调用）使用Win32API的PostMessage 异步执行.

 
 
 
    
  
  
  
  1. UnsafeNativeMethods.PostMessage(new HandleRef(this, this.Handle) 
    2. 
  
  
  
  2.                   , threadCallbackMessage, IntPtr.Zero, IntPtr.Zero); 
    3. 
  
  
  
  3. [DllImport("user32.dll", CharSet=CharSet.Auto)] 
    4. 
  
  
  
  4. public static extern bool PostMessage(HandleRefhwnd, intmsg, IntPtrwparam, IntPtrlparam);
    5.

PostMessage 是windows api，用来把一个消息发送到一个窗口的消息队列。这个方法是异步的，也就是该方法封送完毕后马上返回，不会等待委托方法的执行结束，调用者线程将不会被阻塞。（对应同步方法的windows api是：SendMessage()）

2) InvokeRequired

获取一个值，该值指示调用线程是否与控件的创建线程相同。内部关键如下：

 
 
 
    
  
  
  
  1. Int windowThreadProcessId = SafeNativeMethods.GetWindowThreadProcessId(ref2, out num); 
    2. 
  
  
  
  2. Int currentThreadId = SafeNativeMethods.GetCurrentThreadId(); 
    3. 
  
  
  
  3. return (windowThreadProcessId != currentThreadId);
    4.

即返回“通过GetWindowThreadProcessId功能函数得到创建指定窗口线程的标识和创建窗口的进程的标识符与当前线程Id进行比较”的结果。

3) 示例(详见示例文件)

在使用的时候，我们使用 this.InvokeRequired 属性来判断是使用Invoke或BeginInvoke 还是直接调用方法。

 
 
 
    
  
  
  
  1. private void InvokeControl(object mainThreadId) 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     if (this.InvokeRequired) 
    4. 
  
  
  
  4.     { 
    5. 
  
  
  
  5.         this.Invoke(new Action(ChangeText), "InvokeRequired = true.改变控件Text值"); 
    6. 
  
  
  
  6.         //this.textBox1.Invoke(new Action(InvokeCount), (int)mainThreadId); 
    7. 
  
  
  
  7.     } 
    8. 
  
  
  
  8.     else
    9. 
  
  
  
  9.     { 
    10. 
  
  
  
  10.         ChangeText("在创建控件的线程上，改变控件Text值"); 
    11. 
  
  
  
  11.     } 
    12. 
  
  
  
  12. } 
    13. 
  
  
  
  13.   
    14. 
  
  
  
  14. private void ChangeText(String str) 
    15. 
  
  
  
  15. { 
    16. 
  
  
  
  16.     this.textBox1.Text += str; 
    17. 
  
  
  
  17. }
    18.

注意，在InvokeControl方法中使用 this.Invoke(Delegate del) 和使用 this.textBox1.Invoke(Delegate del) 效果是一样的。因为在执行Invoke或BeginInvoke时，内部首先调用 FindMarshalingControl() 进行一个循环向上回溯，从当前控件开始回溯父控件，直到找到最顶级的父控件，用它作为封送对象。也就是说 this.textBox1.Invoke(Delegate del) 会追溯到和 this.Invoke(Delegate del) 一样的起点。（子控件的创建线程一定是创建父控件的线程，所以这种追溯不会导致将调用封送到错误的目的线程）

本节到此结束，本节主要讲了异步编程模式之一“异步编程模型（APM）”，是基于IAsyncResult设计模式实现的异步编程方式，并且构建了一个继承自IAsyncResult接口的示例，及展示了这种模式在委托及跨线程访问控件上的经典应用。下一节中，我将为大家介绍基于事件的编程模型……

网页标题：异步编程：异步编程模型(APM)
文章网址：http://www.gawzjz.com/qtweb/news17/162317.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

同城分类信息

边坡防护网厂家　　 　研学实践　　 　户外广告设计　　 　成都网站设计　　 　时嘉做网站　　 　成都保温材料　　 　蜀锦在线　　 　注册域名　　 　成都微商城　　 　网站seo优化　　 　子晨木包装箱　　 　宜宾网站建设　　 　升施印刷　　 　德昌麦琪建站　　 　网站空间　　 　网站改版　　 　自贡电信机房　　 　成都logo设计标志　　 　微信小程序　　 　网上商城管理系统