等待抽象的异步任务

Question

我对@9​​87654322@ 的用法非常陌生。我正在尝试在 UI 中有条件地抽象异步和await。我有一个抽象基类：

public abstract class Base
{
    public abstract bool IsRunning { get; }
    public abstract Task<bool> Run();
}

并从中衍生出一些实例，第一个是同步的：

internal class Derived1 : Base
{
    private readonly Base baseCase;
    private Task<bool> task;
    public Derived1(Base baseCase)
    {
        this.baseCase = baseCase;
    }
    public override bool IsRunning
    {
        get { return false; }
    }
    public override Task<bool> Run()
    {
        task = new Task<bool>(() => 
        {
            bool ok = DoSomething();
            return ok;
        });
        return task;
    }
}

以及异步实现的派生类：

internal class Derived2 : Base
{
    private readonly Base baseCase;
    private Task<bool> task;
    public Derived2(Base baseCase)
    {
        this.baseCase = baseCase;
    }
    public override bool IsRunning
    {
        get { return task != null && task.Status == TaskStatus.Running; }
    }
    public override Task<bool> Run()
    {
        task = new Task<bool>(() => 
        {
            bool ok = DoSomething();
            return ok;
        });
        return task;
    }
}

然后在 UI 中，我想在asynchronous 任务上执行await（如果用户在运行时配置中指定），如下所示：

internal class CaseMenuHandler
{
    private async void OnRun(object sender, EventArgs args)
    {
        foreach (var case in Cases)
        {
            Base baseCaseRunner = GetCaseRunner(case);
            try
            {
                bool ok = true;
                if( something_holds ) {
                    ok = await baseCaseRunner.Run();
                }
                else {
                    ok = baseCaseRunner.Run().Result;
                }
            }
            catch (Exception e)
            {
                LogError(...);
            }
        }
    }

希望这很清楚。我可以执行上述操作，特别是在 if 块内有条件地等待吗？理想情况下，我想让Base 类只返回bool 而不是Task<bool> 用于Run 方法，并且只有Derived2 类覆盖返回Task<bool>，但我不清楚怎么做。也许我应该在Derived2 的Run 方法中返回task.Result？如果有更好的方法，包括抽象或任何​​其他更正，请告诉我。欣赏任何想法。

编辑#1

Derived1 中同步实现的Run 方法形式已在下面的回复中阐明。我不允许更改DoSomething 方法的签名，因此，我在Derived2（异步实现）中的Run 方法现在看起来如下（感谢@Stripling 的cmets）：

    public override async Task<bool> Run()
    {
        task = new Task<bool>(() => 
        {
            bool ok = DoSomething();
            return ok;
        });
        task.Start();
        return await task;
    }

编辑#2：

当我尝试上述方法时（也尝试在task 定义之后调用task.Start()，我收到以下错误：

Cross-thread operation not valid: Application accessed domain object from a thread other than a legal thread.

Answer 1

我可以执行上述操作，特别是在 if 块内有条件地等待吗？

你可以，但你不应该这样做。如果你做对了，以阻塞方式专门调用同步任务没有太大的优势：作为一般规则，你可以只await返回的任务，如果它代表一个同步任务，那么await将以很少的开销同步解决。

当我说“如果你做正确的事情”时，这是正确的方法：

// synchronous
public override Task<bool> Run()
{
    var result = DoSomething();
    return Task.FromResult(result);
}


// asynchronous
public override async Task<bool> Run()
{
    var result = await DoSomethingAsync();
    return result;
}

awaiting 上面第一个例子的结果不会做任何线程切换或类似的事情。 awaiting 第二个可能的结果，取决于DoSomethingAsync() 的实现。没有特别需要抽象层：您始终可以检查 Task 是否已完成，而 awaiting 已完成的任务将始终立即返回一个值。

Answer 2

我看不出你的同步版本是怎么同步的，你还是用Task.Run(，我早就料到了

internal class Derived1 : Base
{
    private readonly Base baseCase;
    private Task<bool> task;
    public Derived1(Base baseCase)
    {
        this.baseCase = baseCase;
    }
    public override bool IsRunning
    {
        get { return false; }    

    }

    public override Task<bool> Run()
    { 
        bool ok = DoSomething(); 
        return Task.FromResult(ok);
    }
}

如果你这样做而不是你正在这样做，你的其他代码就会变成

private async void OnRun(object sender, EventArgs args)
{
    foreach (var case in Cases)
    {
        Base baseCaseRunner = GetCaseRunner(case);
        try
        {
            bool ok = true;
            ok = await baseCaseRunner.Run();
        }
        catch (Exception e)
        {
            LogError(...);
        }
    }
}

异步版本异步运行，同步版本同步运行。

您的“异步版本”也不是真正的异步，请参阅 Stripling's answer 了解执行该方法的正确方法。

Answer 3

然后在 UI 中，我想等待异步任务（如果用户在运行时配置中指定）

首先，我不得不说这是一个非常糟糕的主意。有些东西应该是可配置的，有些则不应该。操作的异步性不应该是可配置的。时期。这是一个可怕的设计，我要做的第一件事就是坚决反对像这样荒谬的“要求”。从字面上看，它与是否抛出异常的可配置标志具有相同的意义。

也就是说，它可以完成。这很痛苦，难以维护，而且在一天结束时完全没用。但是，嘿，我假设你会为此获得报酬，所以这一切都很好，嗯？

如果您出于政治原因必须这样做（绝​​对没有有效的技术原因），那么我建议您使用Boolean Argument Hack from my article on brownfield async。仅阻塞 (Result) 的一个问题是，如果 Run 使用 await（对于 reasons described on my blog）它不起作用。

boolean 参数 hack 只是添加一个布尔参数，指示该方法是否预计同步完成。

public abstract class Base
{
  public abstract Task<bool> RunAsync(bool sync);
}

这里的语义是如果sync是true，那么从RunAsync返回的任务必须已经完成了。

您的实现如下所示：

internal class Derived1 : Base
{
  public override async Task<bool> RunAsync(bool sync)
  {
    IsRunning = true;
    try
    {
      if (sync)
        return DoSomething();
      return await Task.Run(() => DoSomething());
    }
    finally
    {
      IsRunning = false;
    }
  }
}

它被称为：

private async void OnRun(object sender, EventArgs args)
{
  foreach (var case in Cases)
  {
    Base baseCaseRunner = GetCaseRunner(case);
    try
    {
      bool sync = !something_holds;
      bool ok = await baseCaseRunner.RunAsync(sync);
    }
    catch (Exception e)
    {
      LogError(...);
    }
  }
}

请注意，它始终可以与await 一起调用，但如果sync 是true，OnRun 实际上将是同步。这是由于“等待快速路径”——await first checks whether the task is already complete, and if it is, it continues synchronously（如我的异步介绍博客文章中所述）这一事实。

Answer 4

使用Task.FromResult 返回一个包含同步计算结果的任务，然后等待。

bool ok = DoSomething();
return Task.FromResult(ok);

作为旁注，我不会将同步代码放在通常用于异步的方法中（或者在其他类/位置中是同步的），反之亦然。我会为同步和异步实现使用不同的接口/基类。

interface IRunnable
{
    bool IsRunning;
    bool Run();
}

interface IRunnableAsync
{
    bool IsRunning;
    Task<bool> RunAsync();
}