Calling Synchronous Methods Asynchronously
摺疊目錄
展開目錄
若要檢視英文版的文章,請選取 [原文] 核取方塊。您也可以將滑鼠指標移到文字上,即可在快顯視窗顯示英文原文。
譯文
原文

Calling Synchronous Methods Asynchronously

 

.NET Framework 可讓您以非同步方式呼叫任何方法。 若要這樣做,您使用相同簽章定義委派,做為您要呼叫的方法;Common Language Runtime 則會自動以適當簽章定義此委派的 BeginInvokeEndInvoke 方法。

System_CAPS_note注意事項

在 .NET Compact Framework 中不會支援非同步委派呼叫,尤其是 BeginInvokeEndInvoke 方法

BeginInvoke 方法會起始非同步呼叫。 它有相同參數做為您要非同步執行的方法,再加上兩個額外的選擇性參數。 第一個參數是 AsyncCallback 委派,參考非同步呼叫完成時所呼叫的方法。 第二個參數使用者定義的物件,可將資訊傳遞至回呼方法。 BeginInvoke 會立即傳回且不等候非同步呼叫完成。 BeginInvoke 傳回 IAsyncResult,可用來監視非同步呼叫的進度。

EndInvoke 方法會擷取非同步呼叫的結果。BeginInvoke 之後隨時可以呼叫它。 如果非同步呼叫尚未完成,在完成前 EndInvoke 會封鎖呼叫執行緒。 EndInvoke 的參數包括您要非同步執行之方法的 outref 參數 (Visual Basic 中的 <Out> ByRefByRef),再加上 BeginInvoke 所傳回的 IAsyncResult

System_CAPS_note注意事項

Visual Studio 2005 中的 IntelliSense 功能會顯示 BeginInvokeEndInvoke 的參數。 假如您並非使用 Visual Studio 或類似工具,或您所使用的是 C# 搭配 Visual Studio 2005,請參閱 Asynchronous Programming Model (APM) 以取得針對這些方法所定義的參數說明。

本主題中的程式碼範例將示範四個使用 BeginInvokeEndInvoke 進行非同步呼叫的常用方法。 呼叫 BeginInvoke 之後您可執行以下動作:

  • 執行一些工作,然後呼叫 EndInvoke 進行封鎖,直到呼叫完成。

  • 取得使用 IAsyncResult.AsyncWaitHandle 屬性的 WaitHandle,利用其 WaitOne 方法封鎖執行,直到 WaitHandle 收到信號,接著呼叫 EndInvoke

  • 輪詢 BeginInvoke 所傳回的 IAsyncResult,判斷非同步呼叫完成的時間,然後再呼叫 EndInvoke

  • 將回呼方法的委派傳遞至 BeginInvoke 非同步呼叫完成之時,會在 ThreadPool 執行緒上執行此方法。 回呼方法會呼叫 EndInvoke

System_CAPS_important重要事項

不論您使用哪一種技術,請務必呼叫 EndInvoke 完成非同步呼叫。

以下程式碼範例示範非同步呼叫同一個長時間執行之方法 TestMethod 的各種方式。 TestMethod 方法會顯示主控台訊息,告訴您它已經開始處理、睡眠數秒鐘,然後結束。 TestMethod 具有 out 參數,以示範這類參數加入 BeginInvokeEndInvoke 簽章的方法。 您可以用類似方式處理 ref 參數。

下列程式碼範例顯示 TestMethod 的定義及名為 AsyncMethodCaller 且可用來非同步呼叫 TestMethod 的委派。 若要編譯程式碼範例,您必須包含 TestMethod 的定義和 AsyncMethodCaller 委派。

using System;
using System.Threading; 

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncDemo 
    {
        // The method to be executed asynchronously.
        public string TestMethod(int callDuration, out int threadId) 
        {
            Console.WriteLine("Test method begins.");
            Thread.Sleep(callDuration);
            threadId = Thread.CurrentThread.ManagedThreadId;
            return String.Format("My call time was {0}.", callDuration.ToString());
        }
    }
    // The delegate must have the same signature as the method
    // it will call asynchronously.
    public delegate string AsyncMethodCaller(int callDuration, out int threadId);
}

以非同步方式執行方法最簡單的方式,就是以呼叫委派的 BeginInvoke 方法來開始執行方法,在主執行緒上執行相同的工作,然後呼叫委派的 EndInvoke 方法。 EndInvoke 有可能會封鎖呼叫執行緒,因為它在非同赴呼叫完成之前都不會傳回。 這個技術非常適合運用於檔案或網路作業。

System_CAPS_important重要事項

由於 EndInvoke 可能會進行封鎖,因此請您千萬不要從服役於使用者介面的執行緒中呼叫它。

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain 
    {
        public static void Main() 
        {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.
            IAsyncResult result = caller.BeginInvoke(3000, 
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.",
                Thread.CurrentThread.ManagedThreadId);

            // Call EndInvoke to wait for the asynchronous call to complete,
            // and to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

Main thread 1 does some work.
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
 */

您可以使用取得 BeginInvoke 所傳回之 IAsyncResultAsyncWaitHandle 屬性,取得 WaitHandle 非同步呼叫完成時,WaitHandle 會收到信號,且您可以呼叫 WaitOne 方法來等候它。

如果您使用 WaitHandle,您可以在非同步呼叫完成之前或之後,且在呼叫 EndInvoke 擷取結果之前,執行其他的處理。

System_CAPS_note注意事項

當您呼叫 EndInvoke 時,等候控制代碼不會自動關閉。 如果您釋放所有等候控制代碼的參考,當記憶體回收收回等候控制代碼時,系統資源就會釋放。 若要在您使用完等候控制代碼後立即釋放系統資源,請呼叫 WaitHandle.Close 方法來加以配置。 明確配置可處置的物件之後,記憶體回收會更有效率。

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain 
    {
        static void Main() 
        {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.
            IAsyncResult result = caller.BeginInvoke(3000, 
                out threadId, null, null);

            Thread.Sleep(0);
            Console.WriteLine("Main thread {0} does some work.",
                Thread.CurrentThread.ManagedThreadId);

            // Wait for the WaitHandle to become signaled.
            result.AsyncWaitHandle.WaitOne();

            // Perform additional processing here.
            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            // Close the wait handle.
            result.AsyncWaitHandle.Close();

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

Main thread 1 does some work.
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
 */

您可以使用 BeginInvoke 所傳回之 IAsyncResultIsCompleted 屬性,找出非同步呼叫完成的時間。 從服役於使用者介面的執行緒進行非同步呼叫時,您有可能會執行這項操作。 輪詢完成這個動作,可在非同步呼叫於 ThreadPool 執行緒上執行的同時,讓呼叫執行緒能夠繼續執行。

using System;
using System.Threading;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain 
    {
        static void Main() {
            // The asynchronous method puts the thread id here.
            int threadId;

            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.
            IAsyncResult result = caller.BeginInvoke(3000, 
                out threadId, null, null);

            // Poll while simulating work.
            while(result.IsCompleted == false) {
                Thread.Sleep(250);
                Console.Write(".");
            }

            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("\nThe call executed on thread {0}, with return value \"{1}\".",
                threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

Test method begins.
.............
The call executed on thread 3, with return value "My call time was 3000.".
 */

如果起始非同步呼叫的執行緒不一定非是處理結果的執行緒時,您可以在呼叫完成時執行回呼方法。 回呼方法是在 ThreadPool 執行緒上執行的。

若要使用回呼方法,您必須對 BeginInvoke 傳遞表示回呼方法的 AsyncCallback 委派。 您也可以傳遞物件,包含回呼方法所使用的資訊。 在回呼方法中,您可以將 IAsyncResult 這個回呼方法唯一的參數,轉換成 AsyncResult 物件。 接著可以再使用 AsyncResult.AsyncDelegate 屬性來取得委派,用來起使呼叫,以便您呼叫 EndInvoke

此範例的注意事項如下:

  • TestMethodthreadId 參數是 out 參數 (Visual Basic 中的 <Out> ByRef),因此 TestMethod 絕對不會使用它的輸入值。 虛設變數會傳遞給 BeginInvoke 呼叫。 如果 threadId 參數是 ref 參數 (Visual Basic 中的 ByRef),則變數必須是類別層級的欄位,才能同時傳遞至 BeginInvokeEndInvoke

  • 傳遞至 BeginInvoke 的狀態資訊是格式字串,回呼方法會用它來格式化輸出訊息。 由於狀態資訊傳遞時的型別是 Object,因此必須先轉換成適當型別才能使用。

  • 回呼是在 ThreadPool 執行緒上執行的。 ThreadPool 執行緒為背景執行緒,也就是說主執行緒結束之時,並不會讓應用程式繼續執行,因此此範例的主執行緒必須進入睡眠直到回呼完成為止。

using System;
using System.Threading;
using System.Runtime.Remoting.Messaging;

namespace Examples.AdvancedProgramming.AsynchronousOperations
{
    public class AsyncMain 
    {
        static void Main() 
        {
            // Create an instance of the test class.
            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.
            AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);

            // The threadId parameter of TestMethod is an out parameter, so
            // its input value is never used by TestMethod. Therefore, a dummy
            // variable can be passed to the BeginInvoke call. If the threadId
            // parameter were a ref parameter, it would have to be a class-
            // level field so that it could be passed to both BeginInvoke and 
            // EndInvoke.
            int dummy = 0;

            // Initiate the asynchronous call, passing three seconds (3000 ms)
            // for the callDuration parameter of TestMethod; a dummy variable 
            // for the out parameter (threadId); the callback delegate; and
            // state information that can be retrieved by the callback method.
            // In this case, the state information is a string that can be used
            // to format a console message.
            IAsyncResult result = caller.BeginInvoke(3000,
                out dummy, 
                new AsyncCallback(CallbackMethod),
                "The call executed on thread {0}, with return value \"{1}\".");

            Console.WriteLine("The main thread {0} continues to execute...", 
                Thread.CurrentThread.ManagedThreadId);

            // The callback is made on a ThreadPool thread. ThreadPool threads
            // are background threads, which do not keep the application running
            // if the main thread ends. Comment out the next line to demonstrate
            // this.
            Thread.Sleep(4000);

            Console.WriteLine("The main thread ends.");
        }

        // The callback method must have the same signature as the
        // AsyncCallback delegate.
        static void CallbackMethod(IAsyncResult ar) 
        {
            // Retrieve the delegate.
            AsyncResult result = (AsyncResult) ar;
            AsyncMethodCaller caller = (AsyncMethodCaller) result.AsyncDelegate;

            // Retrieve the format string that was passed as state 
            // information.
            string formatString = (string) ar.AsyncState;

            // Define a variable to receive the value of the out parameter.
            // If the parameter were ref rather than out then it would have to
            // be a class-level field so it could also be passed to BeginInvoke.
            int threadId = 0;

            // Call EndInvoke to retrieve the results.
            string returnValue = caller.EndInvoke(out threadId, ar);

            // Use the format string to format the output message.
            Console.WriteLine(formatString, threadId, returnValue);
        }
    }
}

/* This example produces output similar to the following:

The main thread 1 continues to execute...
Test method begins.
The call executed on thread 3, with return value "My call time was 3000.".
The main thread ends.
 */
顯示:
© 2016 Microsoft