最佳实践/等待

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层 - 和脱离业务逻辑。