16.3 Asynchronous Delegates

Sometimes it is desirable to call a method asynchronously, so the call returns immediately while the method executes on a separate thread. The runtime provides a standard way that any method can be called asynchronously, taking into account retrieving return values and ref/in parameters supplied to the method. When the C# compiler encounters a delegate, the delegate derived class it generates contains three key methods:

return-type Invoke (parameter-list);
IAsyncResult BeginInvoke (parameter-list, AsyncCallback ac, object state);
return-type EndInvoke (ref/out-only parameter-list, IAsyncCallback ac);

Calling Invoke( ) calls the method synchronously, and the caller has to wait until the delegate finishes executing (a standard delegate invocation in C# calls Invoke( )).

Calling BeginInvoke( ) invokes the delegate with the supplied parameter list, then immediately returns. This asynchronous call is performed as soon as a thread is available in the ThreadPool. Two additional parameters are added to BeginInvoke( ): an AsyncCallback object, to optionally specify a delegate to execute by the ThreadPool thread just before it returns, and an arbitrary object to hold state. The AsyncCallback delegate signature is a void method with a single IAsyncResult parameter, which lets you access information about the call.

Calling EndInvoke( ) retrieves the return value of the called method, along with any ref/out parameters that may have been modified.

In the following example, we call TimeConsumingFunction( ) twice asynchronously, whereby the Main method can continue executing while work is being done by each TimeConsumingFunction. To keep the example simple, these functions happen to execute very fast, but this methodology could be applied to much slower functions such as file I/O functions.

using System;
using System.Threading;
using System.Runtime.Remoting.Messaging;
delegate int Compute (string s);
public class Test {
  static int TimeConsumingFunction (string s) {
    return s.Length;
  static void DisplayFunctionResult (IAsyncResult ar) {
    Compute c = (Compute)((AsyncResult)ar).AsyncDelegate;
    int result = c.EndInvoke(ar);
    string s = (string)ar.AsyncState;
    Console.WriteLine ("{0} is {1} characters long", s, result);
  static void Main ( ) {
    Compute c = new Compute (TimeConsumingFunction);
    AsyncCallback ac = new AsyncCallback (DisplayFunctionResult);
    string s1 = "Christopher";
    string s2 = "Nolan";
    IAsyncResult ar1 = c.BeginInvoke (s1, ac, s1);
    IAsyncResult ar2 = c.BeginInvoke (s2, ac, s2);
    Console.WriteLine ("Ready");
    Console.Read( );

The output is:

Christopher is 11 characters long
Nolan is 5 characters long

    Part II: Programming with the .NET Framework
    Part IV: API Quick Reference