Em poucas palavras: Async / Await Best Practices in .NET

Async / Await - Introdução

Máquina de estado (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()
        {
            // 
        }

    }
}

Quando usar o Async / Await

• Trabalho relacionado à E / S : seu código espera algo, como dados de um banco de dados, leitura de um arquivo, chamada de um serviço da web. Nesse caso, você deve usar Async / Await, não a Biblioteca Paralela de Tarefas.
• Trabalho relacionado à CPU : seu código executará cálculos complexos. Nesse caso, você deve usar Async / Await, mas precisa iniciar o trabalho em outro thread usando o Task.Run. Você também pode considerar usar a Biblioteca Paralela de Tarefas .

Assíncrono todo o caminho

Se o método for declarado como assíncrono, certifique-se de que esteja aguardando!

Evitar vazio assíncrono

public async void AsyncVoidMethod()
{
    //!
}

public async Task AsyncTaskMethod()
{
    //!
}

• Exceções lançadas no método assíncrono nulo não podem ser capturadas fora deste método :

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

• Os métodos assíncronos nulos podem causar efeitos colaterais indesejados se o chamador não esperar que eles sejam assíncronos : se o método assíncrono não retornar nada, use a tarefa assíncrona (sem um " <T >" para a tarefa) como tipo de retorno.
• Os métodos assíncronos nulos são muito difíceis de testar : devido a diferenças no tratamento e layout de erros, é difícil escrever testes de unidade que chamam métodos assíncronos nulos. Teste Asynchronous MSTest só funciona para métodos assíncronos que retornam um Task ou Task <T >.

Preferir tarefa de retorno em vez de retorno aguardar

public async Task<string> AsyncTask()

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

   return await GetData();

}

public Task<string> JustTask()

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

   return GetData();

}

Não coloque a tarefa de retorno dentro de try..catch {} ou usando {} blocos

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

Evite usar .Wait()ou .Result- use em vez dissoGetAwaiter().GetResult()

public void GetAwaiterGetResultExample()

{
   // ,    ,     AggregateException  

   string data = GetData().Result;

   // ,   ,      

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

Se o método for assíncrono, adicione o sufixo Async ao seu nome

Os métodos de biblioteca assíncrona devem usar Task.ConfigureAwait (false) para melhorar o desempenho

public async Task ConfigureAwaitExample()

{
   //   ConfigureAwait(false)   .

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

Relatório de andamento da tarefa assíncrona

Cancelar tarefas assíncronas

1. O chamador cria um objeto CancellationTokenSource.
2. O chamador chama a API assíncrona cancelada e passa o CancellationToken do CancellationTokenSource (CancellationTokenSource.Token).
3. O chamador solicita um cancelamento usando o objeto CancellationTokenSource (CancellationTokenSource.Cancel ()).
4. A tarefa confirma o cancelamento e cancela a si mesma, geralmente usando o método CancellationToken.ThrowIfCancellationRequested.

Relatório de andamento e cancelamento - exemplo

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

Aguardando um período de tempo

Aguardando a conclusão de várias tarefas assíncronas