C# -Four Patterns in Asynchronous execution

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.....");
       开发者_Python百科     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 ..?

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."

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

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

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();