使用async / await的最佳實踐

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()返回一個任務，並添加一個async eventhandler，即一個按鈕（ 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. 使用LongRunningCalculation()封裝Calculator類上的Task.Run() 。

    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調用堆棧。

您要避免的是擁有一個帶有異步簽名的方法，該方法是在可重用組件中使用Task.Run實現的。 這是一個撒謊的API。 我有關於這個主題的博客文章更詳細。

如果您控制有問題的類，我建議使用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層）和業務邏輯之外。