C# -Four Patterns in Asynchronous execution

Question

I heard that there are four patterns in asynchronous execution.

There are four patterns in async delegate execution: Polling, Waiting for Completion, Completion Notification, and "Fire and Forget"

When I have the following code :

class AsynchronousDemo
{
    public static int numberofFeets = 0;
    public delegate long StatisticalData();

    static void Main()
    {
        StatisticalData data = ClimbSmallHill;
        IAsyncResult ar = data.BeginInvoke(null, null);
        while (!ar.IsCompleted)
        {
            Console.WriteLine("...Climbing yet to be completed.....");
            Thread.Sleep(200);

        }
        Console.WriteLine("..Climbing is completed...");
        Console.WriteLine("... Time Taken for  climbing ....{0}", 
        data.EndInvoke(ar).ToString()+"..Seconds");
        Console.ReadKey(true);

    }


    static long ClimbSmallHill()
    {
        var sw = Stopwatch.StartNew();
        while (numberofFeets <= 10000)
        {
            numberofFeets = numberofFeets + 100;
            Thread.Sleep(10);
        }
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }
}

1) What is the pattern the above code implemented ?

2) Can you explain the code ,how can i implement the rest ..?

Bob · Accepted Answer · 2009-11-23T19:19:53.200

99

What you have there is the Polling pattern. In this pattern you continually ask "Are we there yet?" The while loop is doing the blocking. The Thread.Sleep prevents the process from eating up CPU cycles.

Wait for Completion is the "I'll call you" approach.

IAsyncResult ar = data.BeginInvoke(null, null);
//wait until processing is done with WaitOne
//you can do other actions before this if needed
ar.AsyncWaitHandle.WaitOne(); 
Console.WriteLine("..Climbing is completed...");

So as soon as WaitOne is called you are blocking until climbing is complete. You can perform other tasks before blocking.

With Completion Notification you are saying "You call me, I won't call you."

IAsyncResult ar = data.BeginInvoke(Callback, null);

//Automatically gets called after climbing is complete because we specified this
//in the call to BeginInvoke
public static void Callback(IAsyncResult result) {
    Console.WriteLine("..Climbing is completed...");
}

There is no blocking here because Callback is going to be notified.

And fire and forget would be

data.BeginInvoke(null, null);
//don't care about result

There is also no blocking here because you don't care when climbing is finished. As the name suggests, you forget about it. You are saying "Don't call me, I won't call you, but still, don't call me."

edited Nov 23 '09 at 19:19

answered Nov 23 '09 at 18:20

Bob

97,670
29
122
130

1

If you don't mind can you please compare those patterns in terms of time consumption? – user215675 Nov 23 '09 at 18:39
1

What do you mean in terms of time consumption? – Bob Nov 23 '09 at 18:45
I have updated my answer. Just to be clear, nothing is going to block other threads. The only thread that will be blocked is the one that wants a result (which is also the one that started the request). – Bob Nov 23 '09 at 19:12
1

Great answer, one small thing is that (according to questions about EndInvoke on SO) you're meant to always call EndInvoke. This of course completely removes the point of it being asynchronous if you always have to block, particularly with the Fire and forget pattern. – Chris S Mar 16 '10 at 14:35
7

Don't call me, I won't call you, but still, don't call me (it's not you, it's me. I think we should start seeing other Threads) – JJS Feb 15 '16 at 22:06
In 2nd approach Wait for Completion, how is WaitOne() doing "i'll call you"? is it doing a slow polling internally? – Mudit Jain Jul 28 '17 at 16:52

score 4 · Answer 2 · edited Jul 23 '14 at 00:50

4

while (!ar.IsCompleted)
{
    Console.WriteLine("...Climbing yet to be completed.....");
    Thread.Sleep(200);
}

That's classic polling. - Check, sleep, check again,

edited Jul 23 '14 at 00:50

Noctis

11,507
3
43
82

answered Nov 23 '09 at 18:20

Chris Cudmore

29,793
12
57
94

McKay · Answer 3 · 2009-11-23T18:26:31.123

This code is Polling:

while (!ar.IsCompleted)

That's the key, you keep checking whether or not it's completed.

THis code doesn't really support all four, but some code does.

Process fileProcess = new Process();
// Fill the start info
bool started = fileProcess.Start();

The "Start" method is Asynchronous. It spawns a new process.

We could do each of the ways you request with this code:

// Fire and forget
// We don't do anything, because we've started the process, and we don't care about it

// Completion Notification
fileProcess.Exited += new EventHandler(fileProcess_Exited);

// Polling
while (fileProcess.HasExited)
{

}

// Wait for completion
fileProcess.WaitForExit();

C# -Four Patterns in Asynchronous execution

3 Answers3

Linked