En bref: Async / Await Best Practices in .NET

Async / Await - Introduction

Machine d'état (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()
        {
            // 
        }

    }
}

Quand utiliser Async / Await

• Travail lié aux E / S : votre code attendra quelque chose, comme des données d'une base de données, la lecture d'un fichier, l'appel d'un service Web. Dans ce cas, vous devez utiliser Async / Await, pas la bibliothèque parallèle de tâches.
• Travail lié au CPU : votre code effectuera des calculs complexes. Dans ce cas, vous devez utiliser Async / Await, mais vous devez commencer à travailler dans un autre thread à l'aide de Task.Run. Vous pouvez également envisager d'utiliser la bibliothèque parallèle de tâches .

Async complètement

Si la méthode est déclarée asynchrone, assurez-vous qu'elle est en attente!

Évitez l'async void

public async void AsyncVoidMethod()
{
    //!
}

public async Task AsyncTaskMethod()
{
    //!
}

• Les exceptions levées dans la méthode async void ne peuvent pas être interceptées en dehors de cette méthode :

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

• Les méthodes asynchrones vides peuvent provoquer des effets secondaires indésirables si l'appelant ne s'attend pas à ce qu'elles soient asynchrones : si votre méthode asynchrone ne renvoie rien, utilisez async Task (sans « <T >» pour Task) comme type de retour.
• Les méthodes async void sont très difficiles à tester : en raison des différences de gestion des erreurs et de disposition, il est difficile d'écrire des tests unitaires qui appellent des méthodes async void. Test Asynchronous MSTest ne fonctionne que pour les méthodes asynchrones qui renvoient une tâche ou la tâche <T >.

Préférer la tâche de retour au lieu du retour attendre

public async Task<string> AsyncTask()

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

   return await GetData();

}

public Task<string> JustTask()

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

   return GetData();

}

N'encapsulez pas la tâche de retour dans try..catch {} ou en utilisant des blocs {}

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

Évitez d'utiliser .Wait()ou .Result- utilisez plutôtGetAwaiter().GetResult()

public void GetAwaiterGetResultExample()

{
   // ,    ,     AggregateException  

   string data = GetData().Result;

   // ,   ,      

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

Si la méthode est asynchrone, ajoutez le suffixe Async à son nom

Les méthodes de bibliothèque asynchrones doivent utiliser Task.ConfigureAwait (false) pour améliorer les performances

public async Task ConfigureAwaitExample()

{
   //   ConfigureAwait(false)   .

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

Rapport d'avancement des tâches asynchrones

Annuler les tâches asynchrones

1. L'appelant crée un objet CancellationTokenSource.
2. L'appelant appelle l'API asynchrone annulée et transmet le CancellationToken à partir du CancellationTokenSource (CancellationTokenSource.Token).
3. L'appelant demande une annulation à l'aide de l'objet CancellationTokenSource (CancellationTokenSource.Cancel ()).
4. La tâche confirme l'annulation et s'annule elle-même, généralement à l'aide de la méthode CancellationToken.ThrowIfCancellationRequested.

Rapport d'étape et d'annulation - Exemple

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

Attendre un certain temps

Attente de la fin de plusieurs tâches asynchrones