Auf den Punkt gebracht: Async / Await Best Practices in .NET

Async / Await - Einführung

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

    }
}

Wann wird Async / Await verwendet?

• E / A-bezogene Arbeit : Ihr Code erwartet etwas, z. B. Daten aus einer Datenbank, Lesen einer Datei oder Aufrufen eines Webdienstes. In diesem Fall sollten Sie Async / Await verwenden, nicht die Task Parallel Library.
• CPU-bezogene Arbeit : Ihr Code führt komplexe Berechnungen durch. In diesem Fall sollten Sie Async / Await verwenden, aber Sie müssen die Arbeit in einem anderen Thread mit Task.Run beginnen. Sie können auch die Task Parallel Library verwenden .

Async den ganzen Weg

Wenn die Methode als asynchron deklariert ist, stellen Sie sicher, dass darauf gewartet wird!

Vermeiden Sie asynchrone Leere

public async void AsyncVoidMethod()
{
    //!
}

public async Task AsyncTaskMethod()
{
    //!
}

• Ausnahmen, die in der asynchronen Void-Methode ausgelöst werden, können außerhalb dieser Methode nicht abgefangen werden :

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

• Asynchrone void-Methoden können unerwünschte Nebenwirkungen verursachen, wenn der Aufrufer nicht erwartet, dass sie asynchron sind : Wenn Ihre asynchrone Methode nichts zurückgibt, verwenden Sie asynchrone Task (ohne ein „ <T >“ für Task) als Rückgabetyp.
• Async-Void-Methoden sind sehr schwer zu testen : Aufgrund der unterschiedlichen Fehlerbehandlung und des unterschiedlichen Layouts ist es schwierig, Komponententests zu schreiben, die Async-Void-Methoden aufrufen. Der asynchrone MSTest-Test funktioniert nur für asynchrone Methoden, die eine Aufgabe oder Aufgabe <T zurückgeben >.

Lieber Rückkehr Aufgabe statt Rückkehr warten

public async Task<string> AsyncTask()

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

   return await GetData();

}

public Task<string> JustTask()

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

   return GetData();

}

Schließen Sie die Rückgabeaufgabe nicht in try..catch {} oder mit {} Blöcken ein

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

Vermeiden Sie stattdessen die Verwendung von .Wait()oder.ResultGetAwaiter().GetResult()

public void GetAwaiterGetResultExample()

{
   // ,    ,     AggregateException  

   string data = GetData().Result;

   // ,   ,      

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

Wenn die Methode asynchron ist, fügen Sie ihrem Namen das Async-Suffix hinzu

Asynchrone Bibliotheksmethoden sollten Task.ConfigureAwait (false) verwenden, um die Leistung zu verbessern

public async Task ConfigureAwaitExample()

{
   //   ConfigureAwait(false)   .

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

Asynchroner Aufgabenfortschrittsbericht

Asynchrone Aufgaben abbrechen

1. Der Aufrufer erstellt ein CancellationTokenSource-Objekt.
2. Der Aufrufer ruft die abgebrochene asynchrone API auf und übergibt das CancellationToken von der CancellationTokenSource (CancellationTokenSource.Token).
3. Der Aufrufer fordert eine Stornierung mit dem Objekt CancellationTokenSource (CancellationTokenSource.Cancel ()) an.
4. Die Task bestätigt die Stornierung und bricht sich selbst ab, normalerweise mithilfe der CancellationToken.ThrowIfCancellationRequested-Methode.

Fortschritts- und Stornierungsbericht - Beispiel

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

Warten auf eine gewisse Zeit

Warten auf mehrere asynchrone Aufgaben