Delegate And Async Programming C# (AsyncCallback And Object State)

//Simple delegate declaration
public delegate int BinaryOp(int x, int y);
//An Add() method that do some simple arithamtic operation
public int Add(int a, int b)
{
    Console.WriteLine("Add() running on thread {0}", Thread.CurrentThread.ManagedThreadId);
    Thread.Sleep(500);
    return (a + b);
}
BinaryOp bp = new BinaryOp(Add);
IAsyncResult iftAr = bp.BeginInvoke(5, 5, null, null);

​​​​​​​//Target of AsyncCallback delegate should match the following pattern
public void AddComplete(IAsyncResult iftAr)

The second and more interesting approach is showing the result by calling EndInovke() inside the AddComplete(). Now you should have a question here. The instance of the BinaryOp delegate is running on the primary thread in the Main(). How can we access it to secondary thread to call the EndInvoke()? The answer is the System.Runtime.Remoting.Messaging.AsyncResult class.

The AsyncResult class

The AddComplete() method of AsyncCallback takes the AsyncResult class object compatible to IAsyncResult as an argument. The static AsyncDelegate property of the AsyncResult class returns a reference to the original asynchronous delegate that was created elsewhere, and which is accessible through the IAsyncResult. Simply just cast the returned object by the AsyncDelegate to BinaryOp.

Update the code in the example; remove the lines of EndInvoke from the Main() and let's call it from the AddComplete() method

//Target of AsyncCallback delegate should match the following pattern
public void AddComplete(IAsyncResult iftAr)
{
    Console.WriteLine("AddComplete() running on thread {0}", Thread.CurrentThread.ManagedThreadId);

    Console.WriteLine("Operation completed.");

    //Getting result
    AsyncResult ar = (AsyncResult)iftAr;
    BinaryOp bp = (BinaryOp)ar.AsyncDelegate;
    int result = bp.EndInvoke(iftAr);

    Console.WriteLine("5 + 5 ={0}", result);
    Console.WriteLine("Message recieved on thread {0}", Thread.CurrentThread.ManagedThreadId);
}

Now the output will be:

Hope you can see the difference in the output of both the approaches here.

Passing and Receiving Custom State Data using the final argument of BeginInvoke()

Now let's address the final argument of BeginInvoke() which has been null up to this point. This parameter allows you to pass additional state information from the primary thread to the secondary thread.

Because the prototype is System.Object you can pass any object as a parameter, as long as the callback knows what type of object to expect.

Now let us demonstrate passing a simple string message form the primary thread in the BeginInvoke() and receiving it in the callback on the secondary thread using the AsyncState property of the IAsyncResult incoming parameter.

Now here's the complete code:

class Program
{
    //Simple delegate declaration
    public delegate int BinaryOp(int x, int y);
    static void Main(string[] args)
    {
        Console.WriteLine("Main() running on thread {0}", Thread.CurrentThread.ManagedThreadId);

        Program p=new Program();
        BinaryOp bp = new BinaryOp(p.Add);
        IAsyncResult iftAr = bp.BeginInvoke(5, 5, new AsyncCallback(p.AddComplete), "This message is from Main() thread "+Thread.CurrentThread.ManagedThreadId;
        while (!iftAr.AsyncWaitHandle.WaitOne(100,true))
        {
            Console.WriteLine("Doing some work in Main()!");
        } 
        Console.Read();
    }

    //An Add() method that do some simple arithamtic operation
    public int Add(int a, int b)
    {
        Console.WriteLine("Add() running on thread {0}", Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(500);
        return (a + b);
    }

    //Target of AsyncCallback delegate should match the following pattern
    public void AddComplete(IAsyncResult iftAr)
    {
        Console.WriteLine("AddComplete() running on thread {0}", Thread.CurrentThread.ManagedThreadId); 
        Console.WriteLine("Operation completed.");

        //Getting result
        AsyncResult ar = (AsyncResult)iftAr;
        BinaryOp bp = (BinaryOp)ar.AsyncDelegate;
        int result = bp.EndInvoke(iftAr); 

        //Recieving the message from Main() thread.
        string msg = (string)iftAr.AsyncState;
        Console.WriteLine("5 + 5 ={0}", result);
        Console.WriteLine("Message recieved on thread {0}: {1}", Thread.CurrentThread.ManagedThreadId, msg);
    } 
}

Output

I hope you enjoyed this.. I'm expecting that the next time you call BeginInvoke() you won't pass NULL values to some useful arguments.

MultiThreading is what your multicore processor is for!

So Cheers...