Delegates and Multithreading Using Asynchronous Delegates

As we will see delegates can be used to run multiple threads.  The following examples go through 5 different scenarios from basic synchronous delegates right the way through to Asynchronous delegates with callbacks.

In this example project there is one class.

In this class we have 7 methods.  5 delegate example methods.   

2 methods to be run as delegates

We have our main method which will run each of the delegate example methods as we uncomment them.

And a delegate definition called MyOperation in our namespace BUT outside of the class as below

The method that will be run here will be the SynchronousDelegate but of course we will run the others by uncommenting them as we run through this article.
Synchronous Delegates

First let’s have a very quick review of synchronous delegates so we can understand by what we mean by the term synchronous.

Here is our first example delegate method

Followed by our add method

You’ll notice that we have the following using statement

Because in both methods we use the following line to identify and print out the thread we are working with

And the line

In our add method to make the method wait for a while.

The add method is put into our new delegate object b which is of the type MyOperation.

And the method invoked by calling b and assigning the return to answer.  As our method is invoked synchronously the line from the method is printed first as we have to wait for the add method to finish BEFORE we get the next few lines printed from the main method.

So when the routine is run we get the following output with a sleight pause after the line from the Add method.  Notice also that the identity of the thread is 1 from both methods.  That is because they are working synchronously ‘One after the other’ on the SAME thread.  Work is blocked until the preceding work is finished.

SynchronousDelegate output

Asynchronous Delegates Part 2

Looking at the following piece of code you will see it does pretty much the same as the previous example only this time we have added a while loop

This while loop checks the value of our IAsynchResult object iftAR’s property IsCompleted and no prizes for guessing……. This is a Boolean value that tells us if the method has finished by returning true when this is the case.

This means the loop will continue until the method has returned so we can then go and collect the result.  Meanwhile until that is the case ‘Doing more work in Main()!");’will be printed to the consol as shown in the output below.

Asynchronous Delegates2 Example Output

Asynchronous Callback Delegate Part 1

So now we have seen asynchronous delegates in action and understood how the work and what they do lets take a step further and look at asynchronous delegates that can make a callback rather than wait to be asked if it is ready.

Let’s look at the following code

This is the code that is going to call the following method in an asynchronous manner.

This time when we call the BeginInvoke method on our delegate b we pass across the addComplete method as parameter to a new AsynchCallback object.  This is now acting as a delegate and as any delegate can only take a method that matches its own pattern which in this case is one that takes a type IAsynchResult as a sole parameter and has no return.

Now we don’t have to poll the delegate to check if it is finished, instead it will run the method we have passed to the BeginInvoke method which in this case is addComplete.  You can see this when you run the program, the addComplete method is invoked on the same thread as the add method.

You may also notice that the EndInvoke method is now not called in Main  and it is not catching the IAsynchResult. The reason for this is that the delegate is not visible in the method addComplete.  However the elegant thing about this is that the object being passed in is actually an object of type AsynchResult.  From this we can get hold of the actual delegate created elsewhere in Main in this case with the following line

Now we have a reference to the original delegate and we can call the EndInvoke method here giving us the result of add

ASynchronousCallbackDelegate1 Example

Asynchronous Callback Delegate Part 2

And for our final piece of code an example of using an object passed into the

The BeginInvoke method of the delegate.

Here’s the method:

ASynchronousCallbackDelegate2 Example

So there you go…… Hopefully this article has helped you understand the differences between synchronous and asynchronous delegates and given you a start on how to use asynchronous delegates and asynchronous delegates with call backs.

Just uncomment the line in main to run the specific method you want to try out.

Have fun!!!!!!!!!!