Le migliori pratiche sull'uso asincrona/attendono

Question

Dire che ho le seguenti definizioni delle classi:

public class Calculator 
{ 
    public CalculatorResult Calculate() 
    { 
     return LongRunningCalculation(); 
    } 

    private CalculatorResult LongRunningCalculation() 
    { 
     return new CalculatorResult(0.00); 
    } 
} 

public class ClassThatUsesACalculator 
{ 
    private readonly Calculator calculator; 

    public ClassThatUsesACalculator() 
    { 
     this.calculator = new Calculator(); 
    } 

    public void DoWork() 
    { 
     for (int i = 0; i < 10; i++) 
     { 
      var result = calculator.Calculate(); 

      DoSomethingWithCalculationResult(result); 

      DoLightWork(); 

      OnProgressChanged(); 
     } 
    } 
} 

public partial class Form : Form 
{ 
    public Form() 
    { 
     InitializeComponent(); 
    } 

    private void Method(object sender, EventArgs e) 
    { 
     DoWork(); 
    } 

    private void DoWork() 
    { 
     var calculator = new ClassThatUsesACalculator(); 
     calculator.ProgressChanged += (s, e) => 
     { 
      // Update progressbar 
     }; 

     calculator.DoWork(); 
    } 
} 

Se vorrei fare il lavoro fatto in DoWork(), sulla forma, in modo asincrono potrei aggiungere un metodo (GetCalculationTask) che restituisce un'attività utilizzando Task.Run() e aggiunge un gestore di eventi asincrono vale a dire un pulsante (MethodOne).

Per favore correggimi se ho torto, ma mi sembra che questa sarebbe l'unica opzione quando le classi ClassThatUsesACalculator e Calculator risiedono in una libreria che non possiedo.

private Task GetCalculationTask(IProgress<CalculatorProgress> progress) 
{ 
    var calculator = new ClassThatUsesACalculator(); 
    calculator.ProgressChanged += (s, e) => 
    { 
     progress.Report(new CalculatorProgress(0)); 
    }; 

    return Task.Run(() => 
    { 
     calculator.DoWork(); 
    }); 
} 

private async void MethodOne(object sender, EventArgs e) 
{ 
    IProgress<CalculatorProgress> progress = new Progress<CalculatorProgress> (UpdateProgressBar); 

    await GetCalculationTask(progress); 
} 

Nel caso faccio proprio la biblioteca penso che ci sono altre due opzioni, una delle quali molto simile al primo. Probabilmente a causa della mancanza della mia comprensione.

Creare un metodo su ClassThatUsesACalculator che incapsula il metodo DoWork() e quindi richiamarlo da un metodo asincrono nel modulo.

o,

1. incapsulare le LongRunningCalculation() sulla classe Calculator con un Task.Run().

   public Task<CalculatorResult> CalculateAsync() 
   { 
       return Task.Run(() => 
       { 
        return LongRunningCalculation(); 
       }); 
   } 
   

2. Creare un metodo asincrono sul ClassThatUsesACalculator le chiamate che attende il metodo appena creato.

   public async Task DoWorkAsync() 
   { 
       for (int i = 0; i < 10; i++) 
       { 
        var result = await calculator.CalculateAsync(); 
   
        DoSomethingWithCalculationResult(result); 
   
        DoLightWork(); 
   
        OnProgressChanged(); 
       } 
   } 
   

3. Creare un metodo asincrono sul modulo (MethodThree)

   private async void MethodThree(object sender, EventArgs e) 
   { 
       IProgress<CalculatorProgress> progress = new Progress<CalculatorProgress>(UpdateProgressBar); 
   
       var calculator = new ClassThatUsesACalculator(); 
       calculator.ProgressChanged += (s, args) => 
       { 
        progress.Report(new CalculatorProgress(0)); 
       }; 
   
       await calculator.DoWorkAsync(); 
   } 
   

Ora, a mio parere, l'ultima opzione sarebbe la migliore come vorrei rimanere più controllo. Ma forse sono lontana e vorrei avere l'opinione di qualcuno o dei suggerimenti su questo argomento, poiché posso solo trovare spiegazioni su come consumare asincrono, ma mai veramente su come costruire metodi che gli altri possano consumare.

Answer 1

Come regola generale, spingere qualsiasi utilizzo Task.Run il più possibile nello stack di chiamate.

Quello che si desidera evitare è un metodo con una firma asincrona implementata utilizzando Task.Run in un componente riutilizzabile. Questa è un'API bugiarda. Ho un blog post on the subject che va più in dettaglio.

Se si controllano le classi in questione, si consiglia di utilizzare IProgress<T> anziché gli eventi per gli aggiornamenti di avanzamento. IProgress<T> funziona bene con il codice sincrono nonché asincroni:

public void DoWork(IProgress<CalculatorProgress> progress = null) 
{ 
    for (int i = 0; i < 10; i++) 
    { 
    var result = calculator.Calculate(); 

    DoSomethingWithCalculationResult(result); 

    DoLightWork(); 

    if (progress != null) 
     progress.Report(new CalculatorProgress(...)); 
    } 
} 

Quindi utilizzando è molto semplice:

private async void MethodTwo(object sender, EventArgs e) 
{ 
    IProgress<CalculatorProgress> progress = new Progress<CalculatorProgress>(UpdateProgressBar); 

    var calculator = new ClassThatUsesACalculator(); 

    await Task.Run(() => calculator.DoWork(progress)); 
} 

che mantiene l'utilizzo Task.Run nel componente che ne ha bisogno - strato UI - e fuori dalla logica del business.