Asynchronous Programming With C#

private void LoadData() {  
    // Create connection  
    SqlConnection conn = new SqlConnection(@ "network address= .; integrated   
    security = true; database = EmployeeDb ");  
    // Create command  
    string sql = @ "select EmpId,Name  
    from dbo.EmployeeDetails where EmpID <= 500 ";  
    // Data binding code goes here  
    try {  
        // Open connection  
        conn.Open();  
        // Execute query via ExecuteReader  
        SqlDataReader rdr = cmd.ExecuteReader();  
        while (rdr.Read()) {  
            txtReader.AppendText("\nEmpID: ");  
            txtReader.AppendText(rdr.GetValue(1) + "\t\t" + rdr.GetValue(0));  
            txtReader.AppendText("\n");  
        }  
    } catch (SqlException ex) {  
        MessageBox.Show(ex.Message + ex.StackTrace, "Exception Details");  
    } finally {  
        conn.Close();  
    }  
}

Figure 1-4 Task Based Pattern

C# 5.0 async and await based Asynchronous Pattern

• Two new keywords, async and await, were introduced in C# 5.0 and .NET 4.5. These are implemented at the compiler level and built on top of the "System.Threading.Tasks.Task" feature of .NET 4.0.

• To work with async and await, you must have Visual Studio 2012

async void LoadEmployee_Click(object sender, RoutedEventArgs e) {  
    // ...  
    await viewer.LoadEmplployeeAsync();  
    // ...  
}

Problem with older Asynchrnous Patterns

With earlier patterns, the programmer needed to do all the plumbing and collaboration between a pair of methods (BeginMethod and EndMethod) or a method and an event (MethodAsync and MethodCompleted) to make them functional; see Figure 1-2 APM Pattern. This approach was a tedious job not only in terms of syntax but also from sequence of statements inside the method body.

C# 5.0 async/await offers a completely different and easy way to do asynchronous programming. With this feature it's no longer the responsibility of the programmer to do the syntax related tedious work, rather this is now done by the keywords (C# 5.0 async / await) provided by the programming language.

As a result, asynchronous code is easy to implement and retain its logical structure. Hence now it is as easy as writing your normal method without concern of any extra plumbing and so on. As shown in other asynchronous patterns in which you need to deal with a pair of methods or a combination of methods and events and so on.

Business Scenario

Consider a real-world business case, a WPF UI binding data to the data grid by fetching a large number of rows from a database. While data is being fetched and bound to a grid, the rest of the UI should continue to be responsive. Any attempt at interaction with other UI controls must not be blocked and data loading and binding must continue in parallel.. Refer to "Figure 1-1 Synchronous Behavior" below.

Figure 1-5 Asynchronous Behavior

Let's Code

If you look at the code below, it looks like normal code as shown at the very beginning of this article. The differences worth noting are highlighted in yellow in the code block below.

Private async void LoadCustomersAsync() {  
    using(EmployeeDbEntities ent = new EmployeeDbEntities()) {  
        IdbConnection conn = (ent.Connection as EntityConnection).StoreConnection;  
        conn.Open();  
        using(DbCommand cmd = (DbCommand) conn.CreateCommand()) {  
            var query = from p in ent.EmployeeDetails  
            where p.Name.Contains("FN") && p.SurName.Contains("SN") && (p.Name + p.SurName).Length > 3  
            select p;  
            //Convert linq query to SQL statement for CommandText  
            string str = ((ObjectQuery) query).ToTraceString();  
            cmd.CommandText = str;  
            // Invoke Async flavor of ExecuteReader  
            var task = await cmd.ExecuteReaderAsync();  
            //translate retieved data to entity customer   
            var cust1 = await Task.Run(  
                () => ent.Translate < EmployeeDetails > (task).ToList < EmployeeDetails > ());  
            employeesDataGrid.ItemsSource = cust1;  
        }  
    }  
}

As you noticed, the flow looks very natural and no extra plumbing appears in the code. Except async/await, task and of course the asynchronous flavor of the main function that is retrieving data from the database; in our case, ExecuteReaderAsync() is the method.

This code will allow you to perform UI interaction; when data is being fetched and grid binding is taking place, refer to the Figure 1-6 async/await in action.

Figure 1-6 async/await in action (as you can see in image 36K + rows pulled)

Legacy Operations

Microsoft suggests that with the release of .NET 4.5, the following commonly used methods should be considered as legacy operations. When possible and if you are usng .NET 4.5 then you must use async and await to do asynchronous programming in your application.

Figure 1-7 Legacy Operations

What if you don't have Visual Studio 2012

Since Visual Studio 2012 is still not adopted by many development teams in various organizations and many developers still use Visual Studio 2010. So, can they use async and await syntax there?

Microsoft released an async CTP that is supposed to work well with Visual Studio 2010 (without SP1) and allow the developers to use the same syntax.

Search for "async CTP" in Bing or Google.

Figure 1-8 Async CTP download page

Side-by-Side Comparison of various ways techniques

Figure 1-9 Side-by-Side comparison on various techniques