当最后一次等待时不必要的异步/等待？

Question

我最近一直在处理async await （阅读所有可能的文章，包括 Stephen 和 Jon 的最后两章），但我得出了结论，我不知道它是否 100% 正确。 - 因此我的问题。

由于async只允许出现 await 一词，我将把async放在一边。

AFAIU， await 是关于继续的。 与其编写功能性（持续性）代码，不如编写同步代码。 （我喜欢将其称为可回调的代码）

因此，当编译器到达await - 它将代码拆分为 2 个部分，并在第一部分完成后注册要执行的第二部分（我不知道为什么不使用callback这个词 - 这正是所做的） . （同时工作 - 线程又回来做其他事情了）。

但是看看这段代码：

public async  Task ProcessAsync()
        {
           Task<string> workTask = SimulateWork();
           string st= await workTask;
           //do something with st
        }

 public    Task <string> SimulateWork()
        {
            return ...
        }

当线程到达await workTask; 它将方法分为 2 个部分。 所以在SimulateWork完成后 - 方法的延续：AKA : //do something with st - 被执行。

一切都好

但是如果方法是：

public async  Task ProcessAsync()
        {
           Task<string> workTask = SimulateWork();
           await workTask; //i don't care about the result , and I don't have any further commands 
        }

在这里-我不需要继续，这意味着-我不需要await分割的方法，手段-我不需要异步/ AWAIT在这里了！ 我仍然会有相同的结果/行为！

所以我可以这样做：

   public void ProcessAsync()
            {
               SimulateWork();
            }

题：

• 我的诊断是否 100% 正确？

Answer 1

因此，您认为下面的await是多余的，正如问题的标题所暗示的那样：

public async Task ProcessAsync()
{
    Task<string> workTask = SimulateWork();
    await workTask; //i don't care about the result , and I don't have any further 
}

首先，我假设在"when await is last" 下，您的意思是"when the await is only await " 。 一定是这样，否则以下内容将无法编译：

public async Task ProcessAsync()
{
    await Task.Delay(1000);
    Task<string> workTask = SimulateWork();
    return workTask; 
}

现在，如果它是唯一的await ，您确实可以像这样优化它：

public Task ProcessAsync()
{
    Task<string> workTask = SimulateWork();
    return workTask; 
}

然而，它会给你完全不同的异常传播行为，这可能会产生一些意想不到的副作用。 问题是，现在异常可能会被抛出到调用者的堆栈上，这取决于SimulateWork是如何在内部实现的。 我张贴了这种行为的详细解释。 这通常不会发生在async Task / Task<>方法中，其中异常存储在返回的Task对象中。 对于async void方法，它仍然可能发生，但那是另一回事了。

因此，如果您的调用者代码已准备好应对异常传播中的此类差异，那么在可能的情况下跳过async/await并简单地返回一个Task可能是个好主意。

另一件事是，如果您想发出即发即弃的调用。 通常，您仍然希望以某种方式跟踪已触发任务的状态，至少出于处理任务异常的原因。 我无法想象我真的不在乎任务是否永远不会完成的情况，即使它所做的只是记录。

因此，对于一劳永逸，我通常使用辅助async void方法将挂起的任务存储在某处以供以后观察，例如：

readonly object _syncLock = new Object();
readonly HashSet<Task> _pendingTasks = new HashSet<Task>();

async void QueueTaskAsync(Task task)
{
    // keep failed/cancelled tasks in the list
    // they will be observed outside
    lock (_syncLock)
        _pendingTasks.Add(task);

    try
    {
        await task;
    }
    catch
    {
        // is it not task's exception?
        if (!task.IsCanceled && !task.IsFaulted)
            throw; // re-throw

        // swallow, but do not remove the faulted/cancelled task from _pendingTasks 
        // the error will be observed later, when we process _pendingTasks,
        // e.g.: await Task.WhenAll(_pendingTasks.ToArray())
        return;
    }

    // remove the successfully completed task from the list
    lock (_syncLock)
        _pendingTasks.Remove(task);
}

你会这样称呼它：

public Task ProcessAsync()
{
    QueueTaskAsync(SimulateWork());
}

目标是在当前线程的同步上下文中立即抛出致命异常（例如，内存不足），而任务结果/错误处理被推迟到适当的时候。

还有的是利用工作的一个有趣的讨论，发射后不管这里。

Answer 2

你很接近。 这意味着你可以这样写：

public Task ProcessAsync()
{
    // some sync code
    return SimulateWork();
}

这样你就不会“支付”将方法标记为async的开销，但你仍然保持等待整个操作的能力。