当我们的程序顺序执行的时候，如果我们调用了一个很耗时的方法，那么应用程序会使当前的线程处于阻塞状态，直到方法的调用完成再继续执行。这样的方法调用被认为是同步的。如果我们调用了一个远程的方法，那么这个方法的调用可能花费的时间会更长。如果我们不想立即取得方法所返回的结果，或者我们根本就不让方法返回结果的话，这种等待是没有必要的。
如果我们想调用一个这样的方法，当调用之后就立即返回，假如在调用期间发生了异常，我们可以在稍后的时间重起该方法的动作。那我们就可以利用异步委托来把我们的方法做成异步的调用。
每个委托都有三个方法：Invoke、BeginInvoke、EndInvoke。
第一个方法是委托指定函数的同步调用，另外两个是异步调用。
如果我们自己写了个委托
public delegate string MyDelegate(string name);
那么C#就会自动为我们提供了下面两个方法：
IAsyncResult BeginInvoke(string name,AsyncResult callback,Object o)
以及
string EndInvoke(IAsyncResult result);
以上内容摘自http://www.cnblogs.com/wenwuxianren/archive/2008/04/17/1158504.html和
http://www.cnblogs.com/everx/archive/2007/02/01/519218.html
下面是MSDN上的官方解释
异步委托提供以异步方式调用同步方法的能力。当同步调用一个委托时，“Invoke”方法直接对当前线程调用目标方法。如果编译器支持异步委托，则它将生成“Invoke”方法以及“BeginInvoke”和“EndInvoke”方法。如果调用“BeginInvoke”方法，则公共语言运行库 (CLR) 将对请求进行排队并立即返回到调用方。将对来自线程池的线程调用该目标方法。提交请求的原始线程自由地继续与目标方法并行执行，该目标方法是对线程池线程运行的。如果在对“BeginInvoke”方法的调用中指定了回调方法，则当目标方法返回时将调用该回调方法。在回调方法中，“EndInvoke”方法获取返回值和所有输入/输出参数。如果在调用“BeginInvoke”时未指定任何回调方法，则可以从调用“BeginInvoke”的线程中调用“EndInvoke”。
.NET Framework 允许您异步调用任何方法。为此，应定义与您要调用的方法具有相同签名的委托；公共语言运行库会自动使用适当的签名为该委托定义 BeginInvoke 和 EndInvoke 方法。
BeginInvoke 方法可启动异步调用。它与您需要异步执行的方法具有相同的参数，另外它还有两个可选参数。第一个参数是一个 AsyncCallback 委托，该委托引用在异步调用完成时要调用的方法。第二个参数是一个用户定义的对象，该对象可向回调方法传递信息。BeginInvoke 立即返回，不等待异步调用完成。BeginInvoke 会返回 IAsyncResult，这个结果可用于监视异步调用进度。
EndInvoke 方法检索异步调用的结果。调用 BeginInvoke 后可随时调用 EndInvoke 方法；如果异步调用尚未完成，EndInvoke 将一直阻止调用线程，直到异步调用完成后才允许调用线程执行。EndInvoke 的参数包括您需要异步执行的方法的 out 和 ref 参数（在 Visual Basic 中为 <Out> ByRef 和 ByRef）以及由 BeginInvoke 返回的 IAsyncResult。
接下来，MSDN提供了两个例子：
第一个例子是：
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace AsyncDemo
{
class Program
{
public class AsyncDemo
{
// 这个方法将被异步调用
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());
}
}
// 异步调用方法的委托，这个委托必须与TestMethod有同样的签名
public delegate string AsyncMethodCaller(int callDuration, out int threadId);
public static void Main()
{
// 异步调用方法将把它的thread id放在这里
int threadId;
// 构建一个测试实例
AsyncDemo ad = new AsyncDemo();
// 构建委托
AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);
// 开始执行异步委托
IAsyncResult result = caller.BeginInvoke(3000,
out threadId, null, null);
Thread.Sleep(0);
Console.WriteLine("Main thread {0} does some work.",
Thread.CurrentThread.ManagedThreadId);
// EndInvoke一直阻塞，一直到异步调用完成之后才返回
// 并且取到了异步调用的返回值
string returnValue = caller.EndInvoke(out threadId, result);
Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
threadId, returnValue);
}
}
}
第二个例子是：
using System;
using System.Threading;
using System.Runtime.Remoting.Messaging;
using System.Collections.Generic;
using System.Text;
namespace DelegationTest
{
// 构造一个异步调用方法来分解因式
class PrimeFactorFinder
{
public static bool Factorize(
int number,
ref int primefactor1,
ref int primefactor2)
{
primefactor1 = 1;
primefactor2 = number;
// Factorize using a low-tech approach.
for (int i = 2; i < number; i++)
{
if (0 == (number % i))
{
primefactor1 = i;
primefactor2 = number / i;
break;
}
}
if (1 == primefactor1)
return false;
else
return true;
}
}
// 构建一个异步委托来匹配异步调用方法
public delegate bool AsyncFactorCaller(
int number,
ref int primefactor1,
ref int primefactor2);
public class DemonstrateAsyncPattern
{
// The waiter object used to keep the main application thread
// from terminating before the callback method completes.
ManualResetEvent waiter;
// Define the method that receives a callback when the results are available.
public void FactorizedResults(IAsyncResult result)
{
int factor1 = 0;
int factor2 = 0;
// Extract the delegate from the
// System.Runtime.Remoting.Messaging.AsyncResult.
AsyncFactorCaller factorDelegate = (AsyncFactorCaller)((AsyncResult)result).AsyncDelegate;
int number = (int)result.AsyncState;
// Obtain the result.
bool answer = factorDelegate.EndInvoke(ref factor1, ref factor2, result);
// Output the results.
Console.WriteLine("On CallBack: Factors of {0} : {1} {2} - {3}",
number, factor1, factor2, answer);
waiter.Set();
}
// 下面的方法演示了在异步调用中利用回调函数的方法（异步调用执行完成之后执行回调方法）
public void FactorizeNumberUsingCallback()
{
AsyncFactorCaller factorDelegate = new AsyncFactorCaller(PrimeFactorFinder.Factorize);
int number = 1000589023;
int temp = 0;
// Waiter will keep the main application thread from
// ending before the callback completes because
// the main thread blocks until the waiter is signaled
// in the callback.
waiter = new ManualResetEvent(false);
// Define the AsyncCallback delegate.
AsyncCallback callBack = new AsyncCallback(this.FactorizedResults);
// Asynchronously invoke the Factorize method.
IAsyncResult result = factorDelegate.BeginInvoke(
number,
ref temp,
ref temp,
callBack,
number);
// Do some other useful work while
// waiting for the asynchronous operation to complete.
// When no more work can be done, wait.
waiter.WaitOne();
}
// 下面的方法演示了异步调用时使用轮询方法而非回调方法（会比回调方法效率低一些）
public void FactorizeNumberAndWait()
{
AsyncFactorCaller factorDelegate = new AsyncFactorCaller(PrimeFactorFinder.Factorize);
int number = 1000589023;
int temp = 0;
// Asynchronously invoke the Factorize method.
IAsyncResult result = factorDelegate.BeginInvoke(
number,
ref temp,
ref temp,
null,
null);
while (!result.IsCompleted)
{
// Do any work you can do before waiting.
result.AsyncWaitHandle.WaitOne(10000, false);
}
// The asynchronous operation has completed.
int factor1 = 0;
int factor2 = 0;
// Obtain the result.
bool answer = factorDelegate.EndInvoke(ref factor1, ref factor2, result);
// Output the results.
Console.WriteLine("Sequential : Factors of {0} : {1} {2} - {3}",
number, factor1, factor2, answer);
}
public static void Main()
{
DemonstrateAsyncPattern demonstrator = new DemonstrateAsyncPattern();
demonstrator.FactorizeNumberUsingCallback();
demonstrator.FactorizeNumberAndWait();
}
}
}
2486
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
