Asynchronous Programming With Async And Await

Introduction 

 

Await & Async was built on the Task Parallel Library (TPL) which was introduced in the .NET Framework 4.

 

Their purpose is to enable asynchronous programming.

 

When you download some files on your mobile phone, your phone doesn't hang until it finishes downloading those files. You can still play Youtube videos or listen to Spotify. This is possible because the OS executes these tasks asynchronously. 

 

In order to understand asynchronous programming, we need to have an example that includes a series of instructions.

 

Take a real-life example, let's make a pizza. Here is a list of steps involved in this process:

1. Make and knead the pizza dough
2. Prepare toppings: sliced chicken, sliced tomato 
3. Flatten a dough ball, then stretch and round it 
4. Spread with tomato sauce and sprinkle with toppings
5. Slide the pizza onto the pizza stone in the oven
6. Bake the pizza in the 475°F (245°C) oven, for about 10-15 minutes

Now, in order to make a delicious pizza, you don't have to follow the exact sequence of orders.

 

For example, you can make a dough, then preheat the stone for step 5, so that stone will be ready to bake pizza by the time you're done with other actions,  and while the stone is heating you can prepare toppings such as cutting a tomato or taking oregano & chili-flakes out of kitchen cabinet.

What you just did is execute the series of tasks asynchronously. You didn't follow the exact order as specified above.

 

We started to pre-head pizza stone after step 1, then the pizza stove will be running in the background without requiring your attention. Furthermore, we didn't wait until the pizza stone is completely heated. Rather, we moved forward with step 2 which is preparing toppings.

Here, the resource we are utilizing is time, we made some task run in the background. In the same way, in Computer Science we do asynchronous programming to utilizing resources such as Processor, RAM, etc. We are the character who makes the pizza, the same way in programming has Threads are which executes difference processes.

Let's code this out, Shall we? Because who understands theory?

 

We need some basic classes... I am not decorating classes, as our main focus is to understand asynchronous programming. 

   class Dough
   {
       public void AddToppings(Toppings topping)
       {
           Console.WriteLine("Spread with tomato sauce and sprinkle with toppings");
       }
   }

   class Toppings
   {
       public string NameOfTopping { get; set; }
   }

   class PizzaStone {    }

   class BakeThePizza {   }

Now our actions: functions in programming:

     private static Dough MakeDough()
     {
         Console.WriteLine(" 1:  Make and knead the pizza dough, Divide the dough into two balls");
         return new Dough();
     }

     private static Toppings PrepareToppings(Toppings topping)
     {
         Console.WriteLine(" 6:  Preparing a Topping" + topping.NameOfTopping);
         return new Toppings();
     }

     private static void FlattenDoughBall(Dough toast) =>
         Console.WriteLine(" 9:  Flatten dough ball, and stretch out into a round");

     private static void AddToppings(Dough toast, Toppings topping)
     {
         toast.AddToppings(topping);
     }

     private static PizzaStone PreheatPizzaStone()
     {
         Console.WriteLine(" 3:  Heating a stone started:");
         Console.WriteLine("-------------- Waiting for 5 seconds to Preheat the Pizza stone........----------------");
         Task.Delay(5000).Wait();

         Console.WriteLine(" 4:  Heating a stone finished");
         return new PizzaStone();
     }

     private static BakeThePizza BackingPizza(Dough PreparedDough, PizzaStone heatedStone)
     {
         Console.WriteLine($" 11:  Slide {PreparedDough} onto {heatedStone} in oven");
         Console.WriteLine(" 12:  Bake pizza in the 475°F (245°C) oven");

         Console.WriteLine("--------------- Waiting for 10 seconds to taking pizza out and cut into 6 slices........------------");
         Task.Delay(10000).Wait();

         Console.WriteLine(" 13:  Take a plate out");
         Console.WriteLine("---------------- Waiting for 3 seconds to garnish........-------------");
         Task.Delay(3000).Wait();
         Console.WriteLine(" 14:  Serve the hot pizza");
         return new BakeThePizza();
     }

Now the chef who is making a delicious pizza. Our Main method:

        static void Main(string[] args)
        {
            //Step - 1
            Dough dough = MakeDough();
            Console.WriteLine(" 2:  Dough is ready");

            //Step - 5 but started now
            PizzaStone stone = PreheatPizzaStone();

            //Step - 2
            Toppings prepTopping = new Toppings() { NameOfTopping = "Tomato" };
            Console.WriteLine(" 5:  Toppings are preapared");

            //Step - 3
            PrepareToppings(prepTopping);

            //Step - 4
            AddToppings(dough, prepTopping);
            Console.WriteLine(" 8:  Toppings are");

            //Step - 5
            FlattenDoughBall(dough);
            Console.WriteLine(" 10:  Dough has been flattern.");

            //Final  : Eat
            BakeThePizza bakedPizza = BackingPizza(dough, stone);
            Console.WriteLine(" 14:  Pizza is ready");
            Console.WriteLine("Eat, Sleep => Repeat!");
        }

What will happen if we run this program? We have to wait every time there is a Task.Delay used. These tasks take time to prepare.

See the behavior yourself in the following gif:

 

 

Now, what possibly could we use to utilize time which has been wasted in waiting for those processes to finish.

We can work Asynchronously and Its simple to implement it.

First, we need to add await keyword in front of the process which consumes time

Second: Decorating method with an async modifier in its signature.

That signals to the compiler that this method contains an await statement & it contains asynchronous operations. We have 2 methods:

        private static async Task<PizzaStone> PreheatPizzaStone()
        {
            Console.WriteLine(" 3:  Heating a stone started:");
            Console.WriteLine("-------------- Waiting for 5 seconds to Preheat the Pizza stone........----------------");
            await Task.Delay(5000);

            Console.WriteLine(" 4:  Heating a stone finished");
            return new PizzaStone();
        }

        private static async Task<BakeThePizza> BackingPizza(Dough PreparedDough, PizzaStone heatedStone)
        {
            Console.WriteLine($" 11:  Slide pizza dough onto pizza stone in oven");
            Console.WriteLine(" 12:  Bake pizza in the 475°F (245°C) oven");

            Console.WriteLine("--------------- Waiting for 10 seconds to taking pizza out and cut into 6 slices........------------");
            await Task.Delay(10000);

            Console.WriteLine(" 13:  Take a plate out");
            Console.WriteLine("---------------- Waiting for 3 seconds to garnish........-------------");
            Task.Delay(3000).Wait();
            Console.WriteLine(" 14:  Serve the hot pizza");
            return new BakeThePizza();
        }

Now, these methods don't simply return an object, they return asynchronous tasks containing the object.

So you have to change the calling signature as well.

        static async Task Main(string[] args)
        {
            //Step - 1
            Dough dough = MakeDough();
            Console.WriteLine(" 2:  Dough is ready");

            //Step - 5 but started now
            Task<PizzaStone> stone = PreheatPizzaStone();
            //Step - 2
            Toppings prepTopping = new Toppings() { NameOfTopping = "Tomato" };
            Console.WriteLine(" 5:  Toppings are preapared");

            //Step - 3
            PrepareToppings(prepTopping);

            //Step - 4
            AddToppings(dough, prepTopping);
            Console.WriteLine(" 8:  Toppings are");

            //Step - 5
            FlattenDoughBall(dough);
            Console.WriteLine(" 10:  Dough has been flattern.");

            //Final  : Eat
            PizzaStone pizzaStone = await stone;

            Task bakedPizza = BackingPizza(dough, pizzaStone);
            Console.WriteLine(" 14:  Pizza is ready");
            Console.WriteLine("Eat, Sleep => Repeat!");
        }

Notice that now even the main method's signature is decorated with async Task as it contains awaiting task.

You may have noticed await statement for pizzaStone has moved at the end, right before where it needed.

So the compiler starts the tasks and keeps them running in the background then it continues with other tasks & brings back PizzaStone right before when it's needed.

See the output:

 

Sometimes you might have tasks that execute at the end. To execute them asynchronously you put them into await modifier.

Here is a series of await statements at the end of the preceding code that can be improved by using methods of the Task class.

One of those APIs is WhenAll, which returns a Task that completes when all the tasks in its argument list have completed.       

await Task.WhenAll(stone, bakedPizza);

Another way is to use WhenAny, which returns a Task<Task> that completes when any of its arguments complete.

The following code shows how you could use WhenAny to await the first task to finish and then process its result.

After processing the result from the completed task, you remove that completed task from the list of tasks passed to WhenAny. 

var pizzaTasks = new List<Task> { stone, bakedPizza };
while (pizzaTasks.Count > 0)
{
    Task finishedTask = await Task.WhenAny(pizzaTasks);
    if (finishedTask == stone)
    {
        Console.WriteLine("Stone ready");
    }
    else if (finishedTask == bakedPizza)
    {
        Console.WriteLine("Pizza is baked");
    }Console.WriteLine("toast is ready");
    }
    pizzaTasks.Remove(finishedTask);
}

Conclusion 

 

I sincerely hope you enjoyed this article and that you're inspired to apply what you've learned to your own applications.

Thank you, & happy coding!
 
If you have any doubts, connect with me.

• Linkedin 
• Twitter
• GitHub 
• Medium  

References

• Microsoft Docs