C# .NET Delegates : Asynchronous Invocation (BeginInvoke Method)

BeginInvoke is callable on single-cast delegates alone. A single-cast delegate is a multicast delegate that contains a single function pointer. BeginInvoke adds the operation to a queue, where it is then serviced by a separate thread from a Common Language Runtime (CLR) managed thread pool. Therefore, functions on the invocation list run on a different thread from the caller of the delegate. The thread pool for asynchronous execution has a maximum of 25 threads per processor.

This is the syntax of the BeginInvoke method:

• IAsyncResult BeginInvoke(arguments, AsyncCallback callback, object AsynState)

BeginInvoke begins with the parameters of the delegate signature. If the delegate signature names four arguments, those are the first four parameters of BeginInvoke. The next parameter is the completion routine. This routine is called back when the asynchronous call has completed. The final parameter is a state object. The completion routine and state objects are optional and either can be set to null. The return is an IAsyncResult object, which maintains the state of the object. IAsyncResult has four properties, which are listed in the table.

Table: IAsyncResult Properties
Property	Description
AsyncState	The state object that has information on the asynchronous operation.
AsyncWaitHandle	Use the WaitHandle to block until the asynchronous operation is completed.
CompleteSynchronously	Indicates that the operation completed synchronously.
IsCompleted	Indicates that the asynchronous operation has completed.

The following code highlights the IAsyncResult and delegate state object:

using System;
using System.Threading;

namespace Examples.Delegates
{
    public delegate void DelegateClass();

    public class Starter
    {

        public static void Main()
        {
            DelegateClass del = MethodA;
            DelegateStateBag state = new DelegateStateBag();
            IAsyncResult ar = del.BeginInvoke(Callback, state);
            if (ar.IsCompleted == true)
            {
                Console.WriteLine("MethodA completed");
            }
            else
            {
                Console.WriteLine("MethodA not completed");
            }
            ar.AsyncWaitHandle.WaitOne();

            // doing something else

            Thread.Sleep(10000);
            lock (state)
            {

                Console.WriteLine("Back in Main");
                Console.WriteLine(state.message);
            }

            Console.ReadKey();
        }

        public static void Callback(IAsyncResult ar)
        {
            DelegateStateBag state =
                (DelegateStateBag)ar.AsyncState;
            lock (state)
            {
                Console.WriteLine("Callback running");
                ((DelegateStateBag)ar.AsyncState).message =
                "State object modified in callback.";
            }
        }

        public static void MethodA()
        {
            Console.WriteLine("MethodA running...");
            Thread.Sleep(20000);
            Console.WriteLine("MethodA finished...");
        }
    }

    class DelegateStateBag
    {
        public string message;
    }
}

This is the result of the application:

MethodA not completed
MethodA running...
Callback running
Back in Main
State object modified in callback.


Interestingly, the not completed message is received before MethodA has even started. This confirms that BeginInvoke does not directly invoke the function in the delegate. Rather, it adds a request to the thread pool queue, which is eventually handled. There is a Thread .Sleep statement near the end of the Main method. If removed, a race condition would exist between Main and the completion routine called Callback. What is the source of the race condition? Note the WaitHandle.WaitOne command in Main, which blocks Main until the asynchronous operation is complete. As the completion routine, Callback also waits for the asynchronous operation to finish. When the asynchronous operation finishes, the Main and Callback routines both resume, and the race begins. Callback needs to update the state object before Main displays the contents of the state object. The Thread.Sleep statement is a primitive way of removing the race condition and allowing the Callback routine to lock the shared state object first.

---

Possibly related posts: (automatically generated)

• Asynchronous Programming Part 1 – Delegates