关于async Task 和 async void 的区别以及为什么在async void代码块中执行，出现异常会导致程序崩溃

本文链接：https://blog.csdn.net/LiAShuo/article/details/144735463

一：async Task与async void方法的区别是什么，为什么async void方法为什么会导致应用程序崩溃:

1：async Task 和 async void 的区别 ·
- async Task
  - 返回一个 Task 对象。
  - 可用于
    await，支持异步链式调用。
  - 通常用于异步操作，需要等待其完成。 ·
- async void
  - 没有返回值，通常用于事件处理程序。
  - 无法被 await，不适合异步调用链。
2：错误处理
- async Task
  - 异常会封装在返回的
    Task 对象中。调用者可以通过 await 或 Task.ContinueWith 来捕获和处理异常。
- async void
  - 异常会直接传递到应用程序的 SynchronizationContext 或默认的 TaskScheduler。
  - 如果未捕获，可能导致应用程序崩溃。
3：为什么 async void 不允许异常处理？
- 没有返回 Task
  - 异常只能通过调用堆栈进行传播，而不是通过返回值链式处理。
  - 无法用标准的 try-catch 捕获 async void 方法中的异常。
- 线程上下文问题
  - 异常会在运行时被视为未处理异常，直接终止应用程序运行。
  - async void 通常用于事件处理，在事件处理的上下文中没有捕获异常的机制。

示例代码：

class Program
{
    static async Task Main(string[] args)
    {
        try
        {
            await ExampleTask(); // 正常捕获异常
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Caught in Main: {ex.Message}");
        }

        ExampleVoid(); // 异常未捕获，导致程序崩溃
    }

    static async Task ExampleTask()
    {
        await Task.Delay(1000);
        throw new Exception("Task Exception");
    }

    static async void ExampleVoid()
    {
        await Task.Delay(1000);
        throw new Exception("Void Exception");
    }
}

二：SynchronizationContext 和 TaskScheduler 的定义与作用

SynchronizationContext
- 定义:
  SynchronizationContext 是一个抽象类，用于管理线程间的任务调度。
  它定义了在特定上下文（例如 UI 线程或其他自定义线程上下文）中调度任务的方法。
- 主要用途:
  - 用来保证代码在特定的上下文中运行。例如，在 UI 应用程序中，它可以确保某些代码始终运行在主线程。
  - 管理异步操作的回调逻辑，使其与上下文保持一致。
TaskScheduler
- 定义:
  - TaskScheduler 是负责调度 Task 对象的执行组件。
  - 它决定 Task 如何被分派到线程池或特定线程中运行。
- 主要用途:
  - 管理任务的执行策略（如优先级、线程分配等）。
  - 默认情况下，TaskScheduler 使用 .NET 的全局线程池来执行任务。
- 典型场景:
  - 默认任务调度: 使用 TaskScheduler.Default 分派任务到线程池中。
  - 自定义任务调度: 为特殊任务提供定制的调度策略，例如限制任务的并发数
- 区别与联系
  - SynchronizationContext: 关注线程间的上下文切换，保证代码运行在特定的线程或上下文中。
  - TaskScheduler: 关注任务的执行和调度，决定任务在哪个线程或线程池中运行。
  - 两者可以结合使用。例如，在 UI 应用程序中，SynchronizationContext 确保任务回调运行在 UI 线程，而 TaskScheduler 决定如何调度任务到线程池或其他线程。

总结：

SynchronizationContext: 决定 await 后的代码在哪个上下文中执行。
TaskScheduler: 决定任务在哪个线程或线程池中调度执行。
异常处理失败可能导致崩溃的原因：
在 async void 方法中，异常直接传递给 SynchronizationContext 或默认 TaskScheduler，如果未处理，会被视为未处理异常，导致崩溃。

二：关于async Task 方法和async void 对异常的处理方式

1. async Task 的异常处理

行为:
如果 async Task 方法抛出未处理的异常，异常会包装在返回的 Task 对象中，而不会立即传递到 SynchronizationContext 或默认的 TaskScheduler。调用代码可以通过以下两种方式处理这些异常：
await 捕获:
异常会在调用 await 的地方抛出，可以用 try-catch 捕获。
Task.ContinueWith 或 Task.Exception: 异常会存储在 Task 对象的 Exception 属性中，可以通过任务的后续操作处理。

async Task TestAsync()
{
    throw new Exception("Test exception");
}

async Task MainAsync()
{
    try
    {
        await TestAsync();
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Caught exception: {ex.Message}");
    }
}

2. async void 的异常处理

行为:
在 async void 方法中，未捕获的异常会直接传递到当前的 SynchronizationContext 或默认的 TaskScheduler，导致未处理异常。
这通常会终止应用程序（如崩溃或显示未处理异常消息）。

async void TestVoidAsync()
{
    throw new Exception("Void exception");
}

void MainVoid()
{
    try
    {
        TestVoidAsync();
    }
    catch (Exception ex)
    {
        // 无法捕获异常
        Console.WriteLine($"Caught exception: {ex.Message}");
    }
}

3. 为什么 async Task 不直接传递异常给 SynchronizationContext 或 TaskScheduler?

设计目的:
async Task 是异步任务的一部分，旨在提供更灵活的异常处理机制。它的异常会被捕获并存储在 Task 对象中，允许调用方根据需要处理这些异常，而不是立即将其视为未处理异常。
异常传递的场景:
只有当调用代码完全忽略返回的 Task，并且 Task 的异常未被显式处理时，最终异常会通过 TaskScheduler.UnobservedTaskException 事件报告。这种情况通常发生在开发者没有处理任务的返回值时。

4. 未观察到的异常 (UnobservedTaskException)

行为:
如果一个 Task 的异常未被观察（没有 await 或调用 .Wait() 或访问 .Exception），异常会延迟传递到默认的 TaskScheduler，并触发 TaskScheduler.UnobservedTaskException 事件。

async Task TestAsync()
{
    throw new Exception("Unobserved exception");
}

void Main()
{
    TestAsync(); // 没有等待或处理
    GC.Collect();
    GC.WaitForPendingFinalizers();
}

如果未处理，最终会触发 TaskScheduler.UnobservedTaskException。

总结

在 async Task 中，异常会存储在 Task 对象中，只有在任务未被观察时才会传递到 SynchronizationContext 或默认的 TaskScheduler。
在 async void 中，未处理异常直接传递到 SynchronizationContext 或默认 TaskScheduler，会被视为未处理异常，导致程序崩溃。