Asynchronous Programming in. Net 5 Cole Durdan Department of Computer Science University of Wisconsin-Platteville

durdanc@uwplatt.edu

Figure 1: Synchronous vs. Asynchronous Comparison

If you are familiar with the term you might commonly associate it with the use of multi-threading. Actually, asynchronous programming does not necessarily mean multi-threaded code. An asynchronous event is an event that occurs independently from the main program flow. An asynchronous method is executed in a manner that does not block the calling function, allowing that function to continue functioning. This can be difficult to comprehend at first because a thread can only do one thing at a time. Writing asynchronous code that only uses one thread means that multiple processes are occurring on one thread at the same time. Control of the thread between the processes needs to be handled in the most efficient manner.
Writing a multi-threaded program can be difficult to write and it introduces many problems that you will have to face. If you are going to write a multi-threaded program you need to be aware of basic threading concepts such as the risk of starvation, locks, deadlocks, and race conditions. This is why it is very important to understand when you should be using multiple threads.
Writing this asynchronous code can be very simple too. The programming languages C# and VB.NET use two new keywords the framework introduced, “async” and “await”. With these new keywords you are able to write a program like you are used to synchronously, and with a few minor modifications you can turn it into an asynchronous program. The main application of using asynchronous code is to keep the thread that the user interface (UI) is on from being blocked.
Imagine your program has some background tasks working and the UI is frozen because they have control of the main thread. Your user could think that the program has crashed and is nonresponsive when in fact it is still working. By implementing the two new keywords on your program you could fix this problem in a matter of minutes.
When to Use Single Thread or Multi-Thread

Parallel programing is important to advance the speed of future programs. In the past, when you wanted a program to execute faster you could just wait six months and a new processor would come out that would be twice as fast as its predecessor. This was due to more transistors and a higher clock speed, but somewhere around the year of 2004 a physical limit to clock speed had been reached. Newer processors no longer have faster clock speeds. Now, the only way to speed up applications from here is to take advantage of multi core CPUs.

represent ongoing asynchronous operations. TAP is the new standard for writing asynchronous code in .NET. The reason TAP makes asynchronous programming so simple is the ability to write code as if it were synchronous. In fact, code can be written synchronously first and easily transformed into asynchronous code by using the new keywords “async” and “await”. TAP differs from the previous EAP and APM methods in the fact that asynchronous operations are handled by one method. Event handlers from the EAP model and End methods from the APM model are no longer needed to handle the asynchronous procedure.
System.Threading.Tasks
This namespace contains the types that are used in the new asynchronous programing model. Task is an implementation to IAsyncResult, which is an interface which represents the status of an asynchronous operation. Previously, the IAsyncResult interface was used by the APM for its design pattern with the Begin and End methods. The two most prominent types in this namespace are type Task and Task. With TAP all asynchronous methods are going to return one of these two types. What the Task class represents is an ongoing operation. Therefore, in comparison to synchronous code a void function is going to be replaced by a function of type Task. A value returning function is going to return type Task where TResult is the original type of value. For example, a value returning function of type int will instead return Task. A Task object has the ability to be waited on and cancelled. Also, creating and scheduling Tasks on separate threads can be easily done with the help of the System.Threading.Task.TaskFactory class.
Task Parallel Library
The new TAP is built on top of the Task Parallel Library (TPL) which was introduced in .NET 4. The TPL is a set of public types and APIs from the System.Threading.Tasks namespace. The TPL was created to greatly simplify adding parallelism and concurrency to applications. The TPL is used by the new .NET framework to handle the partitioning of work, scheduling of threads on the ThreadPool, cancellation support, state management, and other low-level details. When you use the two new keywords you are having a lot of work done for you. The framework now has the compiler dealing with all the scheduling tasks of asynchronous programs for you and thus greatly simplifying your code.
Keywords
Microsoft has created a naming convention to go along with TAP. When writing an asynchronous method the convention is that the method name will end with the word async.
Ex. MethodNameAsync.
Technically, you do not need to do this as it serves no functional purpose but rather just stands as a conventional guideline. The following two keywords, async and await, are however needed to write an asynchronous method with TAP.
Async
Each declaration of an asynchronous method needs to be marked with either the modifier Async or async. This keyword will sit before the return type of the method. A method marked with async can be awaited by methods that call it.
Ex. Async Task MethodNameAsync()
Await
The marked async method will then be allowed to use the await operator to mark points of suspension. The await operator tells the compiler that it cannot pass this part of the code until the task it awaits is completed. When await operators are reached the control will be given back to the caller of the method. An async method usually contains one or more await operators but a compiler error does not occur at their absence. An absence of await operators in an async method will simply result in a compiler warning.
Flow of Control Explained
If you are unfamiliar with asynchronous programming first implementing TAP can be confusing. It is difficult to understand what will have control of the thread until you start experimenting with code and seeing it in action. To help you understand what is actually happening when a method with the new keywords is called I am going to walk you through an example and explain what happens at each step. Refer to Figure 2 while reading the following steps.
Step 1
The method AccessTheWebAsync() gets called from an event handler of a StartButton being clicked.
Step 2
A new HTTP client is created and the method GetStringAsync() is called with Microsoft’s website as the parameter. What this method does is send a GET request to the specified Uri and return the response body as a string.
Step 3
A blocking activity occurs in the method and GetStringAsync() returns a Task of string representing an ongoing process of the call to the method. This task could be seen as a promise to deliver a string. The method was most likely blocked by having to wait for the website to download. So, in order to keep the thread active it returned the task.
Step 4
The method AccessTheWebAsync() carries on and calls the method DoIndependentWork(). This will happen synchronously while the getStringTask is still waiting for its string.
Step 5
The method DoIndependentWork() writes some results to a text box and then returns control back to the method AccessTheWebAsync().
Step 6
Here the method AccessTheWebAsync() cannot go any further without the string result from the getStringTask. So the await operator is used which hands control of the thread back to the calling function. A Task of integer is returned to the caller. This task represents the ongoing procedure of returning an integer the size of the response body of Microsoft’s page.
It is noteworthy to say here that if getStringTask is complete before the await operator is called here the method AccessTheWebAsync() would carry on like a synchronous method instead of yielding control back to the calling function.

Figure 2: Example of Asynchronous Method

Step 7
GetStringAsync() completes and instead of returning a result the string is stored in the Task getStringTask. When using TAP the compiler creates a type of event handler that is set up in the background that will trigger this. So if the program is sitting idle when this happens AccessTheWebAsync() will regain control and set the variable urlContents to the string stored in getStringTask.
Step 8
The length of urlContents will then be stored in the Task object that was set when calling AccessTheWebAsync(). Then, whenever the event handler calls await on that task it will either hand control back to the calling UI or extract the int value representing the size of the contents of Microsoft’s website.
It may take you a couple of times to read through these steps to understand what is going on. This example uses multiple await operators and can be confusing at first. The main thing to understand from this is that when an await operator is reached control is then handed back to the calling function. This is done to ultimately give back the control of the thread to the UI so the UI does not freeze up as it is waiting for long operations to be handled. Specifically, during step six when the await is reached in AccessTheWebAsync() control is handed back to the event handler of the Start Button being clicked. This event handler method (StartButton_Click) is waiting for the integer representing the size of the contents of Microsoft’s homepage. When this number is needed the Task can be awaited returning control back to the UI. The UI will then again be responsive and not frozen while these asynchronous operations are waiting to finish. When the tasks finish in the background event handlers that the compiler made will fire off and the rest of the code after the “await” operators will be finished.
The reason most people get confused here is because they don’t understand when control will be handed back to the await operator to extract the value from the task and finish the rest of the asynchronous method. The way this happens is that when the code is compiled an event handler very similar to the ones used in EAP is created. When the task is finished the event is raised so when the thread goes idle the control will be handed back to the asynchronous method to complete. This is how TAP achieves such a simple way to write asynchronous code. The new framework handles all of the difficult work for you.
There are limitations to having the framework do all of this work for you, of course. You are limited to customization of how events are scheduled. There may be times when you have a unique program that needs to handle a certain condition in a certain way. Reading and learning more about the Task class and Task Parallel Library can be beneficial to understand more about how these operations are ordered.
Conclusion
The use of asynchronous programming is a valuable tool when optimizing programs for performance. Especially if that program has a user interface that you would like to keep responsive. Having an interface that does not constantly freeze up is an important issue and keeps users happy. With Microsoft’s new framework writing asynchronous code has never been easier. That asynchronous code can either be on a single thread or multiple threads thanks to the implementation of the Task class. You can also be less wary when choosing to use multi-threading. Now all of the frustrating work can be done by the compiler thanks to the use of the Task Parallel Library. Asynchronous programs on a single thread avoid the risk of starvation, locks, deadlocks, and race conditions. You now know when it is appropriate to write single threaded parallel code as well. Creating asynchronous code on a single thread is a fairly new idea. It greatly increases the process of creating asynchronous code and is applicable to many common types of programs. These techniques can be very useful when writing applications that make web or database requests. This type of asynchronous programming is great to use with ASP.NET as well. Websites very commonly use all of the cases where only a single thread is needed. With the use of asynchronous programming you will be able to create responsive and efficient programs.

References
[1] Microsoft. Asynchronous Programming with Async and Await (C# and Visual Basic). Retrieved from http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx

[2] Brandon Bray 3 Apr 2012 10:17 AM. Async in 4.5: Worth the Await. Retrieved From http://blogs.msdn.com/b/dotnet/archive/2012/04/03/async-in-4-5-worth-the-await.aspx

[3] Rick Anderson June 6, 2012. Using Asynchronous Methods in ASP.NET 4.5 Retrieved From http://www.asp.net/web-forms/tutorials/aspnet-45/using-asynchronous-methods-in-aspnet-45

[4] DotNetPearls. C# Async, Await. Retrieved From http://www.dotnetperls.com/async

[5] Assil, 14 May 2013. Asynchronous Programming in C# 5.0 using async and await. Retrieved From http://www.codeproject.com/Tips/591586/Asynchronous-Programming-in-Csharp-5-0-using-async