要查看英语原文,请勾选“英语”复选框。也可将鼠标指针移到文本上,在弹出窗口中显示英语原文。
翻译
英语

Calling Synchronous Methods Asynchronously

 

使用 .NET Framework 可以以异步方式调用任何方法。 要实现此操作,请定义一个委托,此委托具有与你要调用的方法相同的签名;公共语言运行时会自动使用适当的签名为此委托定义 BeginInvokeEndInvoke 方法。

System_CAPS_note说明

.NET Compact Framework 不支持异步委托调用,也就是 BeginInvokeEndInvoke 方法。

BeginInvoke 方法启动异步调用。 该方法具有与你要异步执行的方法相同的参数,另加两个可选参数。 第一个参数是一个 AsyncCallback 委托,此委托引用在异步调用完成时要调用的方法。 第二个参数是一个用户定义的对象,该对象将信息传递到回调方法。 BeginInvoke 将立即返回,而不会等待异步调用完成。 BeginInvoke 返回可用于监视异步调用的进度的 IAsyncResult

EndInvoke 方法用于检索异步调用的结果。 它可以在调用 BeginInvoke 之后的任意时间调用。 如果异步调用尚未完成,那么 EndInvoke 将阻止调用线程,直到完成异步调用。 EndInvoke 的参数包括您需要异步执行的方法的 outref 参数(在 Visual Basic 中为 <Out> ByRefByRef)以及由 IAsyncResult 返回的 BeginInvoke

System_CAPS_note说明

Visual Studio 2005 中的 IntelliSense 功能可显示 BeginInvokeEndInvoke 的参数。 如果你未使用 Visual Studio 或类似的工具,或者如果使用的是包含 Visual Studio 2005 的 C#,请参阅 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 的定义和可用于异步调用 TestMethod 的名称为 AsyncMethodCaller 的委托。 要编译此代码示例,必须包括 TestMethodAsyncMethodCaller 委托的定义。

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

有关示例的注释:

  • threadIdTestMethod 参数为 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.
 */
显示: