2 Ways to Implement Asynchronous Technique in C#

Introduction

A few days ago, in our organization, we were trying to implement asynchronous programming (obviously in C# with Visual Studio 2010). First of all, Visual Studio 2010 targets the .NET Framework 4.0, and asynchronous programming is the concept of C# 5.0 that demands the .NET Framework 4.5 to compile and run.

The problem starts here. We are using Visual Studio 2010. The highest version of the .NET Framework that it supports is 4.0, and we are very much interested in implementing the asynchronous style in applications. Our project and source version control and other related software are licensed for Visual Studio 2010. So, what is the solution? We need to use Visual Studio 2012 (at least) to use .NET Framework 4.5, and then we are able to use the features of C# 5.0. (Ok, you are suggesting the use of the async CPT in VS2010). Believe me, I have tried the async CPT in VS2010, but it is not fully supported. (Let's not create a debate with this topic, proceed with our explanation). In this article, we will see how to implement an asynchronous style in C# applications. (Yes, even in .NET 4.0).

Implement By Delegate

This will be our first approach to implementing the asynchronous style. Let's implement a small example to understand it.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Asynchronous
{
    class Program
    {
        delegate void delHugeTask();        
        static void Main(string[] args)
        {
            // Create object to delegate
            delHugeTask objHugeTask = new delHugeTask(HugeTask);            
            // Call the delegate asynchronously
            objHugeTask.BeginInvoke(new AsyncCallback(callbackFunction), objHugeTask);            
            Console.WriteLine("Main Task finished. Waiting for Huge Task");
            Console.ReadLine();
        }
        // Callback function to return result from Huge Task function
        public static void callbackFunction(IAsyncResult obj)
        {
        }
        public static void HugeTask()
        {
            System.Threading.Thread.Sleep(5000);
            Console.WriteLine("Huge Task Finished");
        }
    }
}

This example is quite simple to understand. We have created one function called "HugeTask()" that has only two lines of code but is huge in nature. (Ha. Ha..., Yah, we are making a delay intentionally.) We will now call this function asynchronously. In other words, our program will not wait for the function.

When we invoke any method using a delegate, we basically use an Invoke method to call the function, but it's synchronous in nature. At first, the calling function will execute, and after that control will get to the calling position (from where invoke() has been used). In this example, however, we are interested in calling HugeTask() asynchronously. In other words, the program will call HugeTask(), but the control will not wait for it to finish. It will proceed to execute the next line.

Here we have used the BeginInvoke() method to do this trick. Here is the sample output.

We see that the first Main() function is finishing its task before the "HugeTask()" function. In other words, it's calling the "HugeTask()" function but not waiting for it finish it.

Using C# 5.0, async and await keyword

This is the proper way to implement the asynchronous style in C# applications. Let's update your Visual Studio and try it. I hope most of you are already aware of this feature and have also implemented it (at least in test). Have a look at the following code.

using System;
using System.ComponentModel;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        public static Task LongProcess()
        {
            return Task.Run(() =>
            {
                System.Threading.Thread.Sleep(5000);
            });
        }
        public async void CallProcess()
        {
            await LongProcess();
            this.listBox1.Items.Add("Long Process finished");
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            // Any initialization code you want to add here
        }
        private void button1_Click(object sender, EventArgs e)
        {
            this.label1.Text = "Return Void";
            CallProcess();
            this.listBox1.Items.Add("Program Finished");
        }
    }
}

This is one Windows application, and we have implemented an asynchronous nature in it. The "LongProcess()" will run for 5 seconds, and at the end of the execution, it will return Task. (If you are not familiar with Task, I suggest you refer to the MSDN for it or wait a few days, very soon, I will start a series on the topic of asynchronous programming in C#) . Let's get to our explanation. "CallProcess()" will call "LongProcess()" with an asynchronous style. In other words, "CallProcess()" will call "LongProcess()," but it will not wait for "LongProcess()" to finish. Program control will return to the Main calling location. (Here, it is a button's click event.)

 Output

Conclusion

In this article, we have implemented an asynchronous style in two ways. If you are brand new to the concept of asynchronous, then I suggest you go through the basic idea of it.

Follow my next series to learn asynchronous concepts in C# 5.