ARTICLE

Event-Based Asynchronous Pattern(EAP)

Posted by Nitya Sharma Articles | Multithreading in C# December 18, 2011
Sometime application need to perform long running tasks and yet it should be responsive. Or we need to execute multiple task simultaneously to boost the performance of the application.
Reader Level:
Download Files:
 

Introduction

Sometime application need to perform long running tasks and yet it should be responsive. Or we need to execute multiple task simultaneously to boost the performance of the application. In window application <strong>BackgroundWorker</strong> provide straightforward solution. <strong>System.Threading</strong> class provides all tools we need to develop good multi-threaded application. Here I will implement Event-Base Asynchronous pattern in the class which will support Asynchronous version of method.

Event-Based Asynchronous Pattern(EAP)

The class that supports EAP will have Asynchronous version of method. Class will have more one or more methods named <em>MethodName</em>Async. It will also may have MethodNameCompleted event which will be raised when the asynchronous method complete processing. There can be corresponding cancel method <em> MethodName </em> Cancel to cancel the process in middle. This is an standard pattern which hide the complexity of asynchronous execution of any method. EAP will allow us to :

         

  • Perform time-consuming task; downloads and database operations   "background", without interrupting our application.
  • Execute multiple operations simultaneously, receiving notification when each completes. It also allow same operation to run multiple time simultaneously.
  • Wait for resources to become available without hanging the application.
  • Communicate with Asynchronous operation using ever
  • MethodNameCompleted is a type of MethodNameCompletedEventHandler

        event, that except MethodNameCompletedEventArgs which is inherits AsyncCompletedEventArgs


Implementing EAP in a class

Class will have Synchronous(<strong>Method1</strong>) method and two overloaded Asynchronous(<strong>Method1Async</strong>) methods. Why two overloaded Asynchronous methods? If we need to call method multiple times for different values and there is only one aysnc method Method1Async( string message ), we can't call method second time until first asynchronous call completes. Otherwise it will throw InvalidOperationException. To avoid this situation we will create overloaded method which will except one more parameter calls Method1Async(string message, object userState). This method can be call multiple time with unique userState method and every call run asynchronously and independent to each other.

Create Completed Event Handler Delegate

First we have to create public Method1CompletedEventHandler delegate <strong>outside of the class</strong> in same name space. This will except Method1CompletedEventArgs as one event argument paramete

public delegate void Method1CompletedEventHandler( object sender, Method1CompletedEventArgs e );

public class Method1CompletedEventArgs : AsyncCompletedEventArgs

{

public Method1CompletedEventArgs(Exception ex, bool canceled, object userState)

: base(ex, canceled, userState)

{

}


 
As Method1CompletedEventArgs is inherited from AsynchCompletedEventArgs , constructor must have three minimum parameters
 


  • Error (Exception): Any exception occurred during the operation.
  • Canceled (boolean): Whether the operation canceled before it complete.
  • userState (object): Any user object ( may be sum result expected from the method ).

 
It can have many other parameter as per requirement.

Creating Class

public class MyAsyncDemo

{

 

//delegate will execute main worker method asynchronously

private delegate void WorkerEventHandler(string message, AsyncOperation asyncOp);

 

//This delegate raise the event post completing the async operation.

private SendOrPostCallback onCompletedDelegate;

 

//To allow async method to call multiple time, We need to store tasks in the list

//so we can send back the proper value back to main thread

private HybridDictionary tasks = new HybridDictionary();

 

//Event will we captured by the main thread.

public event Method1CompletedEventHandler Method1Completed;

 

public MyAsyncDemo()

{

onCompletedDelegate = new SendOrPostCallback(CompletedDelegateFunc);

}

 

/// <summary>

/// This function will be called by SendOrPostCallback to raise Method1Completed Event

/// </summary>

/// <param name="operationState">Method1CompletedEventArgs object</param>

private void CompletedDelegateFunc(object operationState)

{

Method1CompletedEventArgs e = operationState as Method1CompletedEventArgs ;

 

if (Method1Completed != null)

{

Method1Completed(this, e);

}

}

 

/// <summary>

/// Synchrnous version of the method

/// </summary>

/// <param name="message">just simple message to display</param>

public void Method1(string message)

{

for (int i = 0; i < 10; i++)

{

Thread.Sleep(3000);

Console.WriteLine(message + " " + i.ToString());

//Do some time consuming process

}

 

}

 

/// <summary>

/// Asynchoronous version of the method

/// </summary>

/// <param name="message">just simple message to display</param>

/// <param name="userState">Unique value to maintain the task</param>

public void Method1Async(string message, object userState)

{

AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(userState);

 

//Multiple threads will access the task dictionary, so it must be locked to serialze access

lock (tasks.SyncRoot)

{

if (tasks.Contains(userState))

{

throw new ArgumentException("User state parameter must be unique", "userState");

}

 

tasks[userState] = asyncOp;

}

 

WorkerEventHandler worker = new WorkerEventHandler(Method1Worker);

 

//Execute process Asynchronously

worker.BeginInvoke(message, asyncOp, null, null);

 

}

 

/// <summary>

/// This method does the actual work

/// </summary>

/// <param name="message"></param>

/// <param name="asyncOp"></param>

private void Method1Worker(string message, AsyncOperation asyncOp)

{

for (int i = 0; i < 10; i++)

{

Thread.Sleep(3000);

Console.WriteLine(message + " " + i.ToString());

//Do some time consuming process

}

 

lock (tasks.SyncRoot)

{

tasks.Remove(asyncOp.UserSuppliedState);

}

 

Method1CompletedEventArgs e = new Method1CompletedEventArgs(null, false, asyncOp.UserSuppliedState);

asyncOp.PostOperationCompleted(onCompletedDelegate, e);

}

}


Each time Method1Async will be called with unique userState value, method creates an object of AsyncOperation class. AsyncOperation use to track the lifetime of asynchronous operation. It provides a way to track and report the progress of the task. To indicated asynchronous task has completed or canceled or error occurred , AsyncOperation provide a method PostOperationCompleted method which we use to raise Method1Completed event.

When u run the code it will show result as below.; Result will be vary machine to machine. But you see, all methods are being executed simultaneously.


Output


Clipboard02.gif


Wrapping Up

Executing long running operation asynchronously not only improve the performance of the operation, it also make the UI responsive. User don't need to sit idle until the operation completed. This is not the only way to implement asynchronous mechanism. There are several ways to accomplish to this. EAP is very use full If you are waiting for all operation completion need to be notified. You can implement Method1ProgressChangedEventHandler similar way which can report the progress. It is very helpful for download or upload operations. Instead of raising event, you can create method by passing call back method which will execute when operation completes.

COMMENT USING

Trending up