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()返回任务并添加异步eventhandler ie对于一个按钮（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()方法的方法，然后从表单上的异步方法调用该方法。

，或者

使用LongRunningCalculation()封装Calculator课程的Task.Run()。

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

在ClassThatUsesACalculator等待新创建方法的调用上创建异步方法。

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

        DoSomethingWithCalculationResult(result);

        DoLightWork();

        OnProgressChanged(); 
    }
}

在表单（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层 - 并且不在业务逻辑中。

使用async / await的最佳实践

1 个答案: