未使用 await 调用时在异步方法中捕获异常

Question

目标：

我对我在 .Net Core 库中看到的异常行为感到困惑。这个问题的目的是了解为什么它正在做我所看到的。

执行摘要

我认为当调用async 方法时，其中的代码会同步执行，直到它遇到第一个等待。如果是这样的话，如果在那个“同步代码”期间抛出了异常，为什么它没有传播到调用方法呢？ （就像普通的同步方法一样。）

示例代码：

在 .Net Core 控制台应用程序中给出以下代码：

static void Main(string[] args)
{
    Console.WriteLine("Hello World!");

    try
    {
        NonAwaitedMethod();
    }
    catch (Exception e)
    {
        Console.WriteLine("Exception Caught");
    }

    Console.ReadKey();
}

public static async Task NonAwaitedMethod()
{
    Task startupDone = new Task(() => { });
    var runTask = DoStuff(() =>
    {
        startupDone.Start();
    });
    var didStartup = startupDone.Wait(1000);
    if (!didStartup)
    {
        throw new ApplicationException("Fail One");
    }

    await runTask;
}

public static async Task DoStuff(Action action)
{
    // Simulate starting up blocking
    var blocking = 100000;
    await Task.Delay(500 + blocking);
    action();
    // Do the rest of the stuff...
    await Task.Delay(3000);
}

}

场景：

1. 按原样运行时，此代码将引发异常，但是，除非您在其上设置断点，否则您不会知道它。 Visual Studio 调试器和控制台都将给出存在问题的任何指示（除了输出屏幕中的一行注释）。

2. 将NonAwaitedMethod 的返回类型从Task 交换为void。这将导致 Visual Studio 调试器现在中断异常。它也将在控制台中打印出来。但值得注意的是，在Main 中找到的catch 语句中NOT 捕获了异常。

3. 将NonAwaitedMethod 的返回类型保留为void，但去掉async。还将最后一行从 await runTask; 更改为 runTask.Wait(); （这基本上会删除任何异步内容。）运行时，异常会在 Main 方法的 catch 语句中捕获。

所以，总结一下：

| Scenario   | Caught By Debugger | Caught by Catch |  
|------------|--------------------|-----------------|  
| async Task | No                 | No              |  
| async void | Yes                | No              |  
| void       | N/A                | Yes             |  

问题：

我认为因为异常是在await 完成之前引发的，所以它将同步执行直到并通过引发异常。

因此我的问题是：为什么场景 1 或 2 都没有被 catch 语句捕获？

另外，为什么从Task 切换到void 返回类型会导致异常被调试器捕获？ （即使我没有使用该返回类型。）

Answer 1

在等待完成之前抛出异常，它将同步执行

认为这是相当正确的，但这并不意味着您可以捕获异常。

因为您的代码有 async 关键字，它会将方法转换为异步状态机，即由特殊类型封装/包装。当任务为awaited（async void 除外）或未被观察到时，异步状态机抛出的任何异常都将被捕获并重新抛出，这可以在TaskScheduler.UnobservedTaskException 事件中捕获。

如果从NonAwaitedMethod 方法中删除async 关键字，则可以捕获异常。

观察这种行为的一个好方法是使用这个：

try
{
    NonAwaitedMethod();

    // You will still see this message in your console despite exception
    // being thrown from the above method synchronously, because the method
    // has been encapsulated into an async state machine by compiler.
    Console.WriteLine("Method Called");
}
catch (Exception e)
{
    Console.WriteLine("Exception Caught");
}

所以你的代码编译类似于：

try
{
    var stateMachine = new AsyncStateMachine(() =>
    {
        try
        {
            NonAwaitedMethod();
        }
        catch (Exception ex)
        {
            stateMachine.Exception = ex;
        }
    });

    // This does not throw exception
    stateMachine.Run();
}
catch (Exception e)
{
    Console.WriteLine("Exception Caught");
}

为什么从 Task 切换到 void 返回类型会导致异常被捕获

如果方法返回Task，则异常被任务捕获。

如果方法是void，则异常会从任意线程池线程中重新抛出。任何从线程池线程抛出的未处理异常都会导致应用程序崩溃，因此调试器（或者可能是 JIT 调试器）可能正在监视此类异常。

如果您想触发并忘记但正确处理异常，您可以使用ContinueWith 为任务创建延续：

NonAwaitedMethod()
    .ContinueWith(task => task.Exception, TaskContinuationOptions.OnlyOnFaulted);

请注意，您必须访问task.Exception 属性才能观察到异常，否则，任务调度程序仍然会收到UnobservedTaskException 事件。

或者如果需要在Main 中捕获和处理异常，正确的方法是使用async Main methods。

Answer 2

如果在“同步代码”期间抛出异常，为什么它没有传播到调用方法？ （就像普通的同步方法一样。）

好问题。事实上，async/await 的早期预览版确实 有这种行为。但是语言团队认为这种行为太令人困惑了。

当你有这样的代码时很容易理解：

if (test)
  throw new Exception();
await Task.Delay(TaskSpan.FromSeconds(5));

但是像这样的代码呢：

await Task.Delay(1);
if (test)
  throw new Exception();
await Task.Delay(TaskSpan.FromSeconds(5));

请记住，await 同步操作如果它的 awaitable 已经完成。那么在等待从Task.Delay 返回的任务时，是否已经过了 1 毫秒？或者更现实的例子，当HttpClient 返回一个本地缓存的响应（同步）时会发生什么？更一般地说，在方法的同步部分直接抛出异常往往会导致代码根据竞争条件改变其语义。

因此，决定单方面更改所有async 方法的工作方式，以便将所有 抛出的异常置于返回的任务上。作为一个很好的副作用，这使它们的语义与枚举器块一致；如果您有一个使用yield return 的方法，则在枚举器实现之前不会看到任何异常，而不是在调用该方法时。

关于你的场景：

1. 是的，异常被忽略。因为Main 中的代码通过忽略任务来执行“一劳永逸”。而“一劳永逸”的意思是“我不在乎例外”。如果您确实关心异常，请不要使用“一劳永逸”；取而代之的是await 某个时候的任务。 The task is how async methods report their completion to their callers, and doing an await is how calling code retrieves the results of the task (and observe exceptions)。
2. 是的，async void 是一个奇怪的怪癖（和should be avoided in general）。它被放入语言中以支持异步事件处理程序，因此它具有类似于事件处理程序的语义。具体来说，任何逃避async void 方法的异常都会在方法开始时的顶级上下文中引发。这就是异常也适用于 UI 事件处理程序的方式。对于控制台应用程序，线程池线程会引发异常。普通的async 方法返回一个“句柄”，它代表异步操作并且可以保存异常。无法捕获来自 async void 方法的异常，因为这些方法没有“句柄”。
3. 当然可以。在这种情况下，该方法是同步的，异常会像往常一样沿堆栈向上传播。

顺便说一句，never, ever use the Task constructor。如果要在线程池上运行代码，请使用Task.Run。如果您想要一个异步委托类型，请使用Func<Task>。

Answer 3

async 关键字表示编译器应该将该方法转换为异步状态机，这对于异常的处理是不可配置的。如果您希望立即抛出 NonAwaitedMethod 方法的同步部分异常，除了从方法中删除 async 关键字之外别无选择。通过将 async 部分移动到 async local function 中，您可以两全其美：

public static Task NonAwaitedMethod()
{
    Task startupDone = new Task(() => { });
    var runTask = DoStuff(() =>
    {
        startupDone.Start();
    });
    var didStartup = startupDone.Wait(1000);
    if (!didStartup)
    {
        throw new ApplicationException("Fail One");
    }

    return ImlpAsync(); async Task ImlpAsync()
    {
        await runTask;
    };
}

除了使用命名函数，您还可以使用匿名函数：

return ((Func<Task>)(async () =>
{
    await runTask;
}))();