2 Ways to Implement Asynchronous Technique in C#

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");
        }
    }
}

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.