En pocas palabras: mejores prácticas asíncronas / esperadas en .NET

Async / Await - Introducción

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()
        {
            // 
        }

    }
}

Cuándo usar Async / Await

• Trabajo relacionado con E / S : su código esperará algo, como datos de una base de datos, leer un archivo, llamar a un servicio web. En este caso, debe usar Async / Await, no la Biblioteca de tareas paralelas.
• Trabajo relacionado con la CPU : su código realizará cálculos complejos. En este caso, debe usar Async / Await, pero debe comenzar a trabajar en otro hilo usando Task.Run. También puede considerar el uso de la Biblioteca paralela de tareas .

Asíncrono todo el camino

Si el método se declara asíncrono, ¡asegúrese de que esté esperando!

Evitar vacío asíncrono

public async void AsyncVoidMethod()
{
    //!
}

public async Task AsyncTaskMethod()
{
    //!
}

• Las excepciones lanzadas en el método vacío asíncrono no se pueden detectar fuera de este 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);
    }
}

• Los métodos anulados asíncronos pueden causar efectos secundarios no deseados si la persona que llama no espera que sean asíncronos : si su método asincrónico no devuelve nada, use la Tarea asincrónica (sin una " <T >" para la Tarea) como el tipo de retorno.
• Los métodos de vacío asíncrono son muy difíciles de probar : debido a las diferencias en el manejo y diseño de errores, es difícil escribir pruebas unitarias que llamen métodos de vacío asíncrono. Prueba asíncrona MSTest sólo funciona para métodos asincrónicos que devuelven una tarea o tareas <T >.

Prefiere la tarea de devolución en lugar de esperar

public async Task<string> AsyncTask()

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

   return await GetData();

}

public Task<string> JustTask()

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

   return GetData();

}

No envuelva la tarea de retorno dentro de try..catch {} o usando bloques {}

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()o .Result- use en su lugarGetAwaiter().GetResult()

public void GetAwaiterGetResultExample()

{
   // ,    ,     AggregateException  

   string data = GetData().Result;

   // ,   ,      

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

Si el método es asíncrono, agregue el sufijo asíncrono a su nombre

Los métodos de biblioteca asincrónica deben usar Task.ConfigureAwait (false) para mejorar el rendimiento

public async Task ConfigureAwaitExample()

{
   //   ConfigureAwait(false)   .

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

Informe de progreso de tarea asincrónica

Cancelar tareas asincrónicas

1. La persona que llama crea un objeto CancellationTokenSource.
2. La persona que llama llama a la API asincrónica cancelada y pasa CancellationToken desde CancellationTokenSource (CancellationTokenSource.Token).
3. La persona que llama solicita una cancelación utilizando el objeto CancellationTokenSource (CancellationTokenSource.Cancel ()).
4. La tarea confirma la cancelación y se cancela a sí misma, generalmente utilizando el método CancellationToken.ThrowIfCancellationRequested.

Informe de progreso y cancelación - Ejemplo

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

Esperando por un período de tiempo

Esperando a que se completen varias tareas asincrónicas