Asynchronous Programming Using Delegates

Gul Md Ershad
Nov 04, 2015

28.5k
0
3
- facebook
- twitter
- linkedIn
- Reddit
- WhatsApp
- Email
- Print
- Other Artcile

Introduction

Delegates are also used in threading specially for the Callback operation. It enables to call a synchronous method in an asynchronous manner. It is basically used in cases like to report information back after the completion of operation, a thread needs a pointer to be able to execute the Callback, etc.

The relationship between Thread and Delegate is in depth. Thread can't call method so, a function pointer is needed and here Delegate acts as function pointer. Threads can be easily started using Delegate or anonymous method or Lambda expression.

The following is the basic relationship of Delegate with Thread or Task:

Start a Task with Delegate

public void StartThreadWithDelegate()
{
    Task task = new Task(delegate { ShowInformation(); });
    task.Start();
}

private void ShowInformation()
{
    Console.WriteLine("Thread Executed");
}

Output

Thread Executed

Thread with Anonymous method

public void ThreadWithAnonymousMethod()
{
new Thread(delegate()
{
ShowInformation();
}).Start();
new Thread(delegate()
{
ShowInformation();
}).Start();
}

Thread with Lambda Expression

public void ThreadWithLambdaExpression()
{
new Thread(() =>ShowInformation()).Start();
new Thread(() =>ShowInformation()).Start();
}

Above explanation is the basics related for writing Thread using with Delegate. But, my main motto is to explain the different patterns to implement or execute a part of code asynchronously with the help of Delegate.

The following are the different ways or techniques to execute code asynchronously with the help of Delegate:

Callback
Polling
EndInvoke
WaitHandler

I will explain above mode of asynchronous execution with the help of Delegate one by one in detail.

Callback

Callback is a way in which a piece or a part of a code is being passed as an argument to other code and expects call back or return back after some time. Here, Thread starts Async operation but doesn't wait for the completion of operation.

Include namespace:

using System.Runtime.Remoting.Messaging;

The following is the complete code example:

public class CallBackOperation
{
public delegate int MyCallBackOperationDelegate(int number, int numberOfTimes);
public static int MyMenthod(int number, int numberOfTimes)
{
for (int counter = 0; counter < 1000; counter++)
{
number = number + counter;
}
return number;
}
public static void MyCallBackOperation(IAsyncResult asyncResult)
{
AsyncResult myasyncResult = asyncResult as AsyncResult;
MyCallBackOperationDelegate myCallBackOperationDelegate = (MyCallBackOperationDelegate)myasyncResult.AsyncDelegate;
var result = myCallBackOperationDelegate.EndInvoke(asyncResult);
Console.WriteLine("Result : {0}", result);
}
}

static void Main(string[] args)
{
Console.WriteLine("Started Executing Callback Operation...");
var myCallBackOperationDelegate = new CallBackOperation.MyCallBackOperationDelegate(CallBackOperation.MyMenthod);
Console.WriteLine("After BeginInvoke Operation");
IAsyncResult asyncResult = myCallBackOperationDelegate.BeginInvoke(5,10, CallBackOperation.MyCallBackOperation, myCallBackOperationDelegate);
Console.WriteLine("Still Executing");
Console.ReadKey();
}

Here, my long calculating method has been passed to MyCallBackOperationDelegate Deleage and this method starts executing after doing "BeginInvoke" operation. It doesn't stops another operation.

Output

Started Executing Callback Operation...

After BeginInvoke Operation

Still Executing

Result: 499505

Polling

Polling is a famous term which means periodically checking for a certain condition. In this technique it continuously asks "Are you still there?" It checks whether Task has been completed or or not. If operation of task is being completed then "EndInvoke" method is being called.

The following is the code example:

public class Polling
{
public delegate int MyPollingDelegate(int number, int numberOfTimes);
public static int MyCalculation(int number, int numberOfTimes)
{
for (int i = 0; i < numberOfTimes; i++)
{
number = number + i;
}
return number;
}
public static void ExecutePollingTechnique()
{
Console.WriteLine("BeginInvoke Operation Started...");
var myPollingDelegate = new MyPollingDelegate(MyCalculation);
IAsyncResult asyncResult = myPollingDelegate.BeginInvoke(10, 100, null, null);
Console.WriteLine("After BeginInvoke Operation...");
while (!asyncResult.IsCompleted)
{
Console.WriteLine("Still in progress...");
Console.WriteLine("I am working other operation...");
}
Console.WriteLine("Asynchronous Programming");
long myPollingResult = myPollingDelegate.EndInvoke(asyncResult);
Console.WriteLine("Resutl : {0}", myPollingResult);
}
}

Now, execute the method:

static void Main(string[] args)
{
Polling.ExecutePollingTechnique();
Console.ReadKey();
}

Output

BeginInvoke Operation Started...

After BeginInvoke Operation...

Still in progress...