最佳實踐/等待

Question

說我有下面的類定義：

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

如果我想要做的DoWork()所做的工作，在表格上，以異步方式我可以添加一個方法（GetCalculationTask）它使用Task.Run()返回一個任務並添加一個異步事件處理程序，即對於按鈕（MethodOne）。

請糾正我，如果我錯了，但在我看來，這將是唯一的選擇，當ClassThatUsesACalculator和Calculator類駐留在我沒有的庫。

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

在我擁有圖書館的情況下，我認爲還有兩個選項，其中一個非常類似於第一個選項。可能是由於缺乏我自己的理解。

在ClassThatUsesACalculator上創建一個封裝DoWork()方法的方法，然後從窗體上的異步方法調用該方法。

，或者

1. 在Calculator類與Task.Run()封裝LongRunningCalculation()。

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

2. 上ClassThatUsesACalculator創建一個異步方法，正等待新創建的方法調用。

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

3. 創建窗體上的異步方法（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(); 
   } 
   

現在，在我看來，最後的選擇是最好的，因爲我會保持更多的控制。但是，我可能會離開，並且希望別人的意見或指示，因爲我只能找到關於如何使用異步的解釋，但從來沒有真正如何構建方法供其他人使用。

Answer 1

作爲一般規則，儘量使用任何Task.Run用法儘可能遠的調用堆棧。

想要什麼避免有一個異步簽名方法，該方法在可重用組件中使用Task.Run實現。這是一個說謊的API。我有一個更詳細的blog post on the subject。

如果您控制有問題的類，我建議使用IProgress<T>而不是事件進行更新。 IProgress<T>作品只是同步碼罰款以及異步：

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

然後使用它是非常簡單：

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

這令在需要它的分量Task.Run用法 - UI層 - 和脫離業務邏輯。