In a Nutshell: Async / Await Best Practices in .NET

Async / Await - Introduction

State Machine (IAsyncStateMachine)

using System.Diagnostics;

namespace AsyncAwait
{
    public class AsyncAwait
    {

        public async Task AsyncAwaitExample()
        {
            int myVariable = 0;

            await DummyAsyncMethod();
            Debug.WriteLine("Continuation - After First Await");
            myVariable = 1;

            await DummyAsyncMethod();
            Debug.WriteLine("Continuation - After Second Await");
            myVariable = 2;

        }

        public async Task DummyAsyncMethod()
        {
            // 
        }

    }
}

When to Use Async / Await

• I / O related work : Your code will expect something, such as data from a database, reading a file, calling a web service. In this case, you should use Async / Await, not the Task Parallel Library.
• CPU related work : your code will perform complex calculations. In this case, you should use Async / Await, but you need to start work in another thread using Task.Run. You may also consider using Task Parallel Library .

Async all the way

If the method is declared as async, make sure there is await!

Avoid async void

public async void AsyncVoidMethod()
{
    //!
}

public async Task AsyncTaskMethod()
{
    //!
}

• Exceptions thrown in the async void method cannot be caught outside this method :

public async void AsyncVoidMethodThrowsException()
{
    throw new Exception("Hmmm, something went wrong!");
}

public void ThisWillNotCatchTheException()
{
    try
    {
        AsyncVoidMethodThrowsException();
    }
    catch(Exception ex)
    {
        //     
        Debug.WriteLine(ex.Message);
    }
}

public async Task AsyncTaskMethodThrowsException()
{
    throw new Exception("Hmmm, something went wrong!");
}

public async Task ThisWillCatchTheException()
{
    try
    {
        await AsyncTaskMethodThrowsException();
    }
    catch (Exception ex)
    {
        //    
        Debug.WriteLine(ex.Message);
    }
}

• Async void methods can cause unwanted side effects if the caller does not expect them to be asynchronous : if your asynchronous method returns nothing, use async Task (without a “ <T >” for Task) as the return type.
• Async void methods are very difficult to test : due to differences in error handling and layout, it is difficult to write unit tests that call async void methods. Asynchronous MSTest test only works for asynchronous methods that return a Task or Task <T >.

Prefer return Task instead of return await

public async Task<string> AsyncTask()

{
   //  !
   //...  -  
   //await -   ,  await  

   return await GetData();

}

public Task<string> JustTask()

{
   //!
   //...  -  
   // Task

   return GetData();

}

Do not wrap the return Task inside try..catch {} or using {} blocks

public Task<string> ReturnTaskExceptionNotCaught()

{
   try
   {
       // ...

       return GetData();

   }
   catch (Exception ex)

   {
       //     

       Debug.WriteLine(ex.Message);
       throw;
   }

}

public Task<string> ReturnTaskUsingProblem()

{
   using (var resource = GetResource())
   {

       // ...  ,     , ,    

       return GetData(resource);
   }
}

Avoid using .Wait()or .Result- use insteadGetAwaiter().GetResult()

public void GetAwaiterGetResultExample()

{
   // ,    ,     AggregateException  

   string data = GetData().Result;

   // ,   ,      

   data = GetData().GetAwaiter().GetResult();
}

If the method is asynchronous, add the Async suffix to its name

Asynchronous library methods should use Task.ConfigureAwait (false) to improve performance

public async Task ConfigureAwaitExample()

{
   //   ConfigureAwait(false)   .

   var data = await GetData().ConfigureAwait(false);
}

Asynchronous task progress report

Cancel Asynchronous Tasks

1. The caller creates a CancellationTokenSource object.
2. The caller calls the canceled asynchronous API and passes the CancellationToken from the CancellationTokenSource (CancellationTokenSource.Token).
3. The caller requests a cancellation using the CancellationTokenSource (CancellationTokenSource.Cancel ()) object.
4. The task confirms the cancellation and cancels itself, usually using the CancellationToken.ThrowIfCancellationRequested method.

Progress and Cancellation Report - Example

using System;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
namespace TestAsyncAwait
{
   public partial class AsyncProgressCancelExampleForm : Form
   {
       public AsyncProgressCancelExampleForm()
       {
           InitializeComponent();
       }

       CancellationTokenSource _cts = new CancellationTokenSource();

       private async void btnRunAsync_Click(object sender, EventArgs e)

       {

           //   .

            <int>   ,          ,   ,    , ETA  . .

           var progressIndicator = new Progress<int>(ReportProgress);

           try

           {
               //   ,         

               await AsyncMethod(progressIndicator, _cts.Token);

           }

           catch (OperationCanceledException ex)

           {
               // 

               lblProgress.Text = "Cancelled";
           }
       }

       private void btnCancel_Click(object sender, EventArgs e)

       {
          // 
           _cts.Cancel();

       }

       private void ReportProgress(int value)

       {
           //    

           lblProgress.Text = value.ToString();

       }

       private async Task AsyncMethod(IProgress<int> progress, CancellationToken ct)

       {

           for (int i = 0; i < 100; i++)

           {
              //   ,     

               await Task.Delay(1000);

               //   

               if (ct != null)

               {

                   ct.ThrowIfCancellationRequested();

               }

               //   

               if (progress != null)

               {

                   progress.Report(i);
               }
           }
       }
   }
}

Waiting for a period of time

Waiting for several asynchronous tasks to complete