異步編程模型 (APM)是.NET1.0的時候就已經推出的古老異步編程模式，此模式基于IAsyncResult接口實現。

隨著技術的發展，又在“.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對象。

// 表示異步操作的狀態。  
[ComVisible(true)]  
public interface IAsyncResult  
{  
    // 獲取用戶定義的對象，它限定或包含關于異步操作的信息。  
    object AsyncState { get; }  
    // 獲取用于等待異步操作完成的System.Threading.WaitHandle，待異步操作完成時獲得信號。  
    WaitHandle AsyncWaitHandle { get; }  
    // 獲取一個值，該值指示異步操作是否同步完成。  
    bool CompletedSynchronously { get; }  
    // 獲取一個值，該值指示異步操作是否已完成。  
    bool IsCompleted { get; }  
}  
   
// 常用委托聲明（我后面示例是使用了自定義的帶ref參數的委托）  
public delegate void AsyncCallback(IAsyncResult ar) 

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的類，并且實現異步調用。

// 帶ref參數的自定義委托  
public delegate void RefAsyncCallback(ref string resultStr, IAsyncResult ar);  
   
public class CalculateAsyncResult : IAsyncResult  
{  
    private int _calcNum1;  
    private int _calcNum2;  
    private RefAsyncCallback _userCallback;  
   
    public CalculateAsyncResult(int num1, int num2, RefAsyncCallback userCallback, object asyncState)  
    {  
        this._calcNum1 = num1;  
        this._calcNum2 = num2;  
        this._userCallback = userCallback;  
        this._asyncState = asyncState;  
        // 異步執行操作  
        ThreadPool.QueueUserWorkItem((obj) => { AsyncCalculate(obj); }, this);  
    }  
   
    #region IAsyncResult接口  
    private object _asyncState;  
    public object AsyncState { get { return _asyncState; } }  
   
    private ManualResetEvent _asyncWaitHandle;  
    public WaitHandle AsyncWaitHandle  
    {  
        get  
        {  
            if (this._asyncWaitHandle == null)  
            {  
                ManualResetEvent event2 = new ManualResetEvent(false);  
                Interlocked.CompareExchange<ManualResetEvent>(ref this._asyncWaitHandle, event2, null);  
            }  
            return _asyncWaitHandle;  
        }  
    }  
   
    private bool _completedSynchronously;  
    public bool CompletedSynchronously { get { return _completedSynchronously; } }  
   
    private bool _isCompleted;  
    public bool IsCompleted { get { return _isCompleted; } }  
    #endregion  
   
    /// <summary>  
    ///  
    /// 存儲最后結果值  
    /// </summary>  
    public int FinnalyResult { get; set; }  
    /// <summary>  
    /// End方法只應調用一次，超過一次報錯  
    /// </summary>  
    public int EndCallCount = 0;  
    /// <summary>  
    /// ref參數  
    /// </summary>  
    public string ResultStr;  
   
    /// <summary>  
    /// 異步進行耗時計算  
    /// </summary>  
    /// <param name="obj">CalculateAsyncResult實例本身</param>  
    private static void AsyncCalculate(object obj)  
    {  
        CalculateAsyncResult asyncResult = obj as CalculateAsyncResult;  
        Thread.SpinWait(1000);  
        asyncResult.FinnalyResult = asyncResult._calcNum1 * asyncResult._calcNum2;  
        asyncResult.ResultStr = asyncResult.FinnalyResult.ToString();  
   
        // 是否同步完成  
        asyncResult._completedSynchronously = false;  
        asyncResult._isCompleted = true;  
        ((ManualResetEvent)asyncResult.AsyncWaitHandle).Set();  
        if (asyncResult._userCallback != null)  
            asyncResult._userCallback(ref asyncResult.ResultStr, asyncResult);  
    }  
}  
   
public class CalculateLib  
{  
    public IAsyncResult BeginCalculate(int num1, int num2, RefAsyncCallback userCallback, object asyncState)  
    {  
        CalculateAsyncResult result = new CalculateAsyncResult(num1, num2, userCallback, asyncState);  
        return result;  
    }  
   
    public int EndCalculate(ref string resultStr, IAsyncResult ar)  
    {  
        CalculateAsyncResult result = ar as CalculateAsyncResult;  
        if (Interlocked.CompareExchange(ref result.EndCallCount, 1, 0) == 1)  
        {  
            throw new Exception("End方法只能調用一次。");  
        }  
        result.AsyncWaitHandle.WaitOne();  
   
        resultStr = result.ResultStr;  
   
        return result.FinnalyResult;  
    }  
   
    public int Calculate(int num1, int num2, ref string resultStr)  
    {  
        resultStr = (num1 * num2).ToString();  
        return num1 * num2;  
    }  
} 

使用上面通過IAsyncResult設計模式實現的帶ref引用參數的異步操作，我將展示三種阻塞式響應異步調用和一種無阻塞式委托響應異步調用。即：

1. 執行異步調用后，若我們需要控制后續執行代碼在異步操作執行完之后執行，可通過下面三種方式阻止其他工作：

a) IAsyncResult的AsyncWaitHandle屬性，待異步操作完成時獲得信號。

b) 通過IAsyncResult的IsCompleted屬性進行輪詢。通過輪詢還可實現進度條功能。

c) 調用異步操作的 End*** 方法。

2. 執行異步調用后，若我們不需要阻止后續代碼的執行，那么我們可以把異步執行操作后的響應放到回調中進行。

public class Calculate_Test  
{  
    public static void Test()  
    {  
        CalculateLib cal = new CalculateLib();  
   
        // 基于IAsyncResult構造一個異步API  
        IAsyncResult calculateResult = cal.BeginCalculate(123, 456, AfterCallback, cal);  
        // 執行異步調用后，若我們需要控制后續執行代碼在異步操作執行完之后執行，可通過下面三種方式阻止其他工作：  
        // 1、IAsyncResult 的 AsyncWaitHandle 屬性，帶異步操作完成時獲得信號。  
        // 2、通過 IAsyncResult 的 IsCompleted 屬性進行輪詢。通過輪詢還可實現進度條功能。  
        // 3、調用異步操作的 End*** 方法。  
        // ***********************************************************  
        // 1、calculateResult.AsyncWaitHandle.WaitOne();  
        // 2、while (calculateResult.IsCompleted) { Thread.Sleep(1000); }  
        // 3、  
        string resultStr = string.Empty;  
        int result = cal.EndCalculate(ref resultStr, calculateResult);  
    }  
   
    /// <summary>  
    /// 異步操作完成后做出響應  
    /// </summary>  
    private static void AfterCallback(ref string resultStr, IAsyncResult ar)  
    {  
        // 執行異步調用后，若我們不需要阻止后續代碼的執行，那么我們可以把異步執行操作后的響應放到回調中進行。  
        CalculateLib cal = ar.AsyncState as CalculateLib;  
   
        //int result = cal.EndInvoke(ref resultStr, calculateResult1);  
        //if (result > 0) { }  
    }  
} 

#p#

二、使用委托進行異步編程

對于委托，編譯器會為我們生成同步調用方法“invoke”以及異步調用方法“BeginInvoke”和“EndInvoke”。對于異步調用方式，公共語言運行庫 (CLR) 將對請求進行排隊并立即返回到調用方，由線程池的線程調度目標方法并與提交請求的原始線程并行運行。

異步委托是快速為方法構建異步調用的方式，它基于IAsyncResult設計模式實現的異步調用，即，通過BeginInvoke返回IAsyncResult對象；通過EndInvoke獲取結果值。

示例：

上節的CalculateLib類中的同步方法以及所要實用到的委托如下：

// 帶ref參數的自定義委托  
public delegate int AsyncInvokeDel(int num1, int num2, ref string resultStr);  
public int Calculate(int num1, int num2, ref string resultStr)  
{  
    resultStr = (num1 * num2).ToString();  
    return num1 * num2;  
} 

然后，通過委托進行同步或異步調用：

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

#p#

三、多線程操作控件

訪問 Windows 窗體控件本質上不是線程安全的。如果有兩個或多個線程操作某一控件的狀態，則可能會迫使該控件進入一種不一致的狀態。還可能出現其他與線程相關的 bug，包括爭用情況和死鎖。確保以線程安全方式訪問控件非常重要。

不過，在有些情況下，您可能需要多線程調用控件的方法。.NET Framework 提供了從任何線程操作控件的方式：

1. 非安全方式訪問控件（此方式請永遠不要再使用）

多線程訪問窗口中的控件，可以在窗口的構造函數中將Form的CheckForIllegalCrossThreadCalls靜態屬性設置為false。

// 獲取或設置一個值，該值指示是否捕獲對錯誤線程的調用，  
// 這些調用在調試應用程序時訪問控件的System.Windows.Forms.Control.Handle屬性。  
// 如果捕獲了對錯誤線程的調用，則為 true；否則為 false。  
public static bool CheckForIllegalCrossThreadCalls { get; set; } 

2. 安全方式訪問控件

原理：從一個線程封送調用并跨線程邊界將其發送到另一個線程，并將調用插入到創建控件線程的消息隊列中,當控件創建線程處理這個消息時,就會在自己的上下文中執行傳入的方法。（此過程只有調用線程和創建控件線程，并沒有創建新線程）

注意：從一個線程封送調用并跨線程邊界將其發送到另一個線程會耗費大量的系統資源，所以應避免重復調用其他線程上的控件。

1) 使用BackgroundWork后臺輔助線程控件控件（AsyncOperationManager類和AsyncOperation類幫助器方式）。

2) 結合TaskScheduler.FromCurrentSynchronizationContext() 和Task 實現。

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

因本文主要解說IAsyncResult異步編程模式，所以只詳細分析Invoke 和BeginInvoke跨線程訪問控件方式。

Control類實現了ISynchronizeInvoke接口，提供了Invoke和BeginInvoke方法來支持其它線程更新GUI界面控件的機制。

public interface ISynchronizeInvoke  
{  
    // 獲取一個值，該值指示調用線程是否與控件的創建線程相同。  
    bool InvokeRequired { get; }  
    // 在控件創建的線程上異步執行指定委托。  
    AsyncResult BeginInvoke(Delegate method, params object[] args);  
    object EndInvoke(IAsyncResult asyncResult);  
    // 在控件創建的線程上同步執行指定委托。  
    object Invoke(Delegate method, params object[] args);  
} 

1) Control類的 Invoke,BeginInvoke 內部實現如下:

a) Invoke （同步調用）先判斷控件創建線程與當前線程是否相同，相同則直接調用委托方法；否則使用Win32API的PostMessage 異步執行。

b) BeginInvoke （異步調用）使用Win32API的PostMessage 異步執行.

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

PostMessage 是windows api，用來把一個消息發送到一個窗口的消息隊列。這個方法是異步的，也就是該方法封送完畢后馬上返回，不會等待委托方法的執行結束，調用者線程將不會被阻塞。（對應同步方法的windows api是：SendMessage()）

2) InvokeRequired

獲取一個值，該值指示調用線程是否與控件的創建線程相同。內部關鍵如下：

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

即返回“通過GetWindowThreadProcessId功能函數得到創建指定窗口線程的標識和創建窗口的進程的標識符與當前線程Id進行比較”的結果。

3) 示例(詳見示例文件)

在使用的時候，我們使用 this.InvokeRequired 屬性來判斷是使用Invoke或BeginInvoke 還是直接調用方法。

private void InvokeControl(object mainThreadId)  
{  
    if (this.InvokeRequired)  
    {  
        this.Invoke(new Action<String>(ChangeText), "InvokeRequired = true.改變控件Text值");  
        //this.textBox1.Invoke(new Action<int>(InvokeCount), (int)mainThreadId);  
    }  
    else 
    {  
        ChangeText("在創建控件的線程上，改變控件Text值");  
    }  
}  
   
private void ChangeText(String str)  
{  
    this.textBox1.Text += str;  
} 

注意，在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接口的示例，及展示了這種模式在委托及跨線程訪問控件上的經典應用。下一節中，我將為大家介紹基于事件的編程模型……

原文鏈接：http://www.cnblogs.com/heyuquan/archive/2013/03/22/2976420.html