C# Asynchronous Programming - Async and Await

public async void CallProcess()  
{  
} 

public static Task LongProcess()  
{  
return Task.Run(() =>  
{  
System.Threading.Thread.Sleep(5000);  
});  
}

await LongProcess();  

If you're relatively new to the concept of asynchronous programming then this dry definition is not enough to understand those concepts. So, let's go through one small example and try to understand those concepts.

Let's create a Windows application and write the following code for it. Here we have created the LongTask() function that will wait for five minutes. Have a look at the function signature; we have declared this function with the async keyword. In other words, we can call it asynchronously.

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 finish");    
        }
  
        private void Form1_Load(object sender, EventArgs e)    
        {    
        }     
  
        private async void button1_Click(object sender, EventArgs e)    
        {    
             CallProcess();    
             this.listBox1.Items.Add("Program finish");  
        }  
    }   
} 

Here is the sample output.

The return type of an asynchronous function is Task. In other words, when it finishes its execution it will complete a Task. Each and every asynchronous method can return three types of values.

Void: Means nothing to return

Task: It will perform one operation, a little similar to void but the difference is there.

Task<T>: Will return a task with a T type parameter. (I hope you are familiar with the concept of T)

Let's clarify a few more concepts here:

• The Main method cannot be defined as asynchronous.
• It (the Main method) cannot be invoked by the await keyword.
• If any asynchronous method is not invoked by the await keyword then by nature it will behave like the synchronous method.
• Function properties should not be defined as asynchronous.
• The await keyword may not be inside a "lock" section.
• A try/catch block should not call any asynchronous methods from the catch or finally block.
• A class constructor or destructor should not define an asynchronous method nor should it be called asynchronously.

Conclusion

In this article we have discussed the basics of asynchronous techniques, I hope you have understood the concepts. In the next article, we will understand various return types of asynchronous methods. Keep reading.

To better uunderstand this article please read next parts also.

• C# Asynchronous Programming - Return Type of Asynchronous Method
• Tasks in C# Asynchronous Programming