Working with Delegates -Part II

In the previous session we have discussed about delegates and its basic features. Now I would like to introduce some of the interesting features of Delegates.
Multicast delegates

As we have discussed in the earlier session, delegates represents functional pointers. When a delegate represents multiple methods, it is multi cast delegates.
Multicast delegates should represent void methods. By adding += I am making this delegate to multicast. The moment I add this += it becomes an array !. This would hold as many numbers of methods as you specify.

// Normal delegate
Calculator c = new Calculator();
BusinessControl bc = new BusinessControl();
CalculatorHandler ch = new CalculatorHandler(c.Add);
//call add method - > this technique is called IOC           
// multi cast delegate
Calculator c = new Calculator();
BusinessControl bc = new BusinessControl();
CalculatorHandler ch = new CalculatorHandler(c.Add);
ch += new CalculatorHandler(c.Add);
ch += new CalculatorHandler(c.Multiply);

Here is how it works. When you invoke the delegate, 'Add' method will be called first followed by 'Multiply' in a single thread and the compiler will come back to you once it is done with all methods specified in the multicast delegate.
Note that you will get a response back only after completing both the tasks ie. Add and Multiply. This is the reason it is suggested that Multicast delegates should represent only void methods.
Hope this might have given you an idea of multicast delegates.  Let us look at what is Synchronized and Asynchronized communications and how delegates support these features.
Synchronized Communication

In our previous example, when we call Add() method of calculator class, using oCalc.Add(), we are making a synchronized communication. Meaning, we are waiting for Calculator object to complete its Add method.  To test this, add a Thread.Sleep(10000) in the add method. When we call this method, the current thread will be in sleep mode for 10000 milliseconds. In other words, we are forced to wait until the compiler is done with the Add method.

int Add(int a, int b)
    Console.WriteLine((a + b).ToString());
    return (a + b);

It is not possible to call any other method untill 10000 ms is completed. This is called synchronous communication.
Practical implementation: Think of a complex stored-procedure that takes 10000 ms to execute. We cannot proceed with next step until the procedure is completed and the compiler gets back to the code.

Asynchronous Communication
Asynchronous methods will not wait for the completion of current thread, and hence we can proceed with next.
This is something like we delegate the work to a third person to do the task on our behalf.

Having said this, how about getting a notification from that person once he completes the tasks?  Sounds good isn't it? We will discuss about this later.
To try asynchronous methods, we are adding Thread.Sleep(10000) to both Add() and Multiple() methods of Calculator class. This is nothing but to demonstrate the waiting period. Please refer to the below sections.

Synchronize Call - Normal

Calculator c = new Calculator();
BusinessControl bc = new BusinessControl();
CalculatorHandler ch = new CalculatorHandler(c.Add);
You will notice that, until it is completed we won't be able to do any other task and the entire application would be locked. Try typing something in the textbox during this invocation.
Converting to Asynchronize Call

c = new Calculator();
CalculatorHandler ch = new CalculatorHandler(c.Add);
ch.BeginInvoke(100, 25, null, null);

ch = new CalculatorHandler(c.Multiply);           
ch.BeginInvoke(25, 4, null, null);
Now type something in a textbox.
What is Begin Invoke

The moment you call BeginInvoke, you are creating a fork.  Meaning, each delegate will be executed in different threads through BeginInvoke. 
The current thread will be splitted into three. One will represent the main thread from which the delegates are called, one will go for the C.ADD method and the other one will be used for the C.MULTIPLY method.
What is End Invoke
EndInvoke is nothing but just opposite action of BeginInvoke. This will create a Join ie, it will wait for all other threads to complete and combine them all together into one single thread and proceed with the Main thread.
Getting results from Asynchronous call - Long running processes

Here I would like to introduce a new member IAsynchResult interface. It takes responsibility to get the work done by the delegate and bring the result back to your location.  IAsynchResult.IsCompleted returns true when the asynchronous job is completed; until that time it is false and you can continue with your work. Hence we can use this to assess whether the long running process is completed.

void button4_Click(object sender, EventArgs e)
    Int32 intResult;
    Calculator c = new Calculator();
    CalculatorHandler ch = new CalculatorHandler(c.Add);
    IAsyncResult ar1 = ch.BeginInvoke(100, 25, null, null);
int Counter = 0;
    while (!ar1.IsCompleted)
        // Do other stuffs
    // Now we know that call is completed as IsCompleted has returned true
    textBox1.Text = Counter.ToString() + " times i was doing my other work";
    intResult = (int)ch.EndInvoke(ar1);
Now what about Out parameters?
So how are we supposed to deal with out parameters of our method?  Let us take a look at the Add method which takes a parameter int as Out. Here's how it goes,
Int Add(Int,int,out int).   
Then use,
BeginInvoke(int,int,null,null) and the EndInvoke will be EndInvoke(out int).
Call Back Mechanism - Completion Notification

The idea is to make the calculator come back and say I have finished my work and this is the result. This mechanism is called Callback.
So far, the last two parameters of BeginInvoke have been passed as null. What was that all about? Is that the one that makes delegates responsive? 

Yes, we will discuss this in next part. Mark your suggestions and comments