Introduction to Async and Await Keywords in C# 5.0

Prior to the introduction of Task Parallel Library (TPL) in .net framework 4.0, writing an asynchronous program was quite a tedious task. One had to write too many lines of code in order to accomplish a simple multi-threaded operation; for example creating wait handles, writing callbacks, complex error handling, etc. In .net framework 4.0, TPL provided developers more abstraction on Asynchronous programming but still the syntax of the asynchronous code was not as simple as a synchronous code to understand. C# 5.0 CTP is now packed with the Async and Await keywords, which allows developers to write asynchronous code but with a structure similar to a synchronous code.

Async and Await keywords

The async keyword can be used as a modifier to a method or anonymous method to tell the C# compiler that the respective method holds an asynchronous operation in it.

The await keyword  is used while invoking the async method, to tell the compiler that the remaining code in that particular method should be executed after the asynchronous operation is completed.

What do You Accomplish with Async and Await Keywords?

This section will list out the things that can be accomplished using async and await keywords in C # 5.0 language.

How to Use?

public async void GetStringAsync()

        public async void button1_OnClick(object sender, ClickEventArgs e)

        {

            string value = await new WebClient().DownloadStringTaskAsync(new Uri("http://www.codeguru.com"));

            //Continuation....

 }

Sample Code

Create a console application targeting .net framework 4.5. In the Program.cs file add the code below.

namespace AsyncAndAwaitSamples
{
    class Program
    {
        static void Main(string[] args)
        {
            Program program = new Program();
            program.PrintSumAsync();
 
            ClassA classA = new ClassA();
            classA.DoSomeOtherOperation();
        }
 
        public async void PrintSumAsync()
        {
            int value1 = await GetValueAsync();
            int value2 = await GetValueAsync();
 
            Console.WriteLine("Sum of two random numbers is: {0}", value1 + value2);
        }
 
        private async Task<int> GetValueAsync()
        {
            int random = ComputeValue();
            return random;
        }
 
 
        private int ComputeValue()
        {
            return new Random().Next(1, 1000);
        }
    }
}

Control Flow and Explanation of the Code

When the program is run first the Main method is executed, which makes a call to the async method PrintSumAsync(). In the PrintSumAsync method, once the first GetValueAsync method is called, the main thread returns back to the caller function, which is the Main method where the rest of its code is executed. Later when the GetValueAsync operation completes then the next call to GetValueAsync executes with an await for the asynchronous operation to complete and finally the sum is printed out.

Though the above code is purely asynchronous the structure is pretty much sequential and reduces the code complexity, which is easier to understand. The above example also demonstrates using multiple await statements in a single async method.

In the end, .net framework 4.5 C# compiler is the one that takes the responsibility for emitting the complex IL required for an asynchronous operation from your plain C# code, which uses sync and await keywords.

Happy reading!