“fire and forget” 任务里的异常

1. 什么是 “fire and forget”?

在编程里，术语 fire and forget 表示启动一个任务但不等待它完成。在 C# 和 .NET 世界里，通常用 Task 启动，然后不等待（不使用 await）、不保存引用、实际上就忘了它。

// 按钮在后台启动一个任务，但从不 await 它。
button.Click += (s, e) =>
{
    Task.Run(() => LongOperation());
};

听起来很诱人：“让它在后台跑，我继续做我的事”。但这种做法如果任务内部抛出了异常，没人会及时知道 —— 异常会悄悄丢失。

2. Task 中的异常是如何工作的

经典：用 await 来处理错误

与异步任务交互的标准方式是通过 await。如果任务里发生错误，异常会在等待点被抛出：

try
{
    await SomeOperationAsync(); // 如果这里面有 Exception，会进入 catch
}
catch(Exception ex)
{
    Console.WriteLine("哎呀！任务里发生错误: " + ex.Message);
}

也就是说，当你等待任务完成时，不会漏掉异常。

但 “fire and forget” 的任务没人去等！

public void RunWithoutWaiting()
{
    // 任务自顾自地运行。没人等它...
    Task.Run(() => {
        // 某处发生了问题：
        throw new InvalidOperationException("哎呀，完了！");
    });
    // 方法返回，任务悄悄在后台运行。
}

如果这样的任务内部抛出异常，它不会在主线程抛出。应用继续运行，像什么都没发生一样。

重要

在 .NET 中，带有未处理异常的任务会进入 Faulted 状态。但如果你不等待它（没有使用 await、.Result、.Wait() 等），没人会读取这个异常，它也不会在调用方代码中显现。

到底“底层”发生了什么？

对于没人等待的任务，唯一剩下的被注意到的机会是事件 TaskScheduler.UnobservedTaskException。当垃圾回收器（GC）发现一个带未观察到异常的任务时，这个事件会触发。但这不是立即发生的，也不是在你期望的地方发生 —— 不应该依赖它。

3. 演示：Fire-and-forget 错误

// 示例：直接从 Main 启动 fire-and-forget 任务
using System;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        FireAndForgetExample();

        Console.WriteLine("主线程继续工作...");
        // 给任务一点时间完成
        Task.Delay(2000).Wait();
    }

    static void FireAndForgetExample()
    {
        Task.Run(() =>
        {
            Console.WriteLine("Fire-and-forget 任务开始了!");
            Task.Delay(500).Wait();
            throw new InvalidOperationException("fire-and-forget 任务内部的错误!");
        });
    }
}

如果运行这段代码……通常不会有特别的表现。错误会发生，但程序不会知道。有时候能在 IDE 的 Output Window 看到警告，但对用户没有信息。

为什么在真实项目里这很危险？

• 复杂的 bug，很难复现（“有时候不工作——不知道为啥”）。
• 悄无声息的数据或逻辑丢失（比如没有给客户发邮件）。
• 在生产环境中，如果没有恰当的日志记录，就不会有任何错误信号。

4. 在 fire-and-forget 中正确处理错误的方法

在任务内部记录并处理异常

最小的安全做法是在 fire-and-forget 任务内部捕获异常：

Task.Run(() =>
{
    try
    {
        // 你的耗时/有风险的代码
        throw new InvalidOperationException("出了点问题!");
    }
    catch (Exception ex)
    {
        // 记录错误或通知用户
        Console.WriteLine("Fire-and-forget: 捕获到异常: " + ex.Message);
        // 可以写到日志文件，使用告警系统等。
    }
});

异步的 void 方法（以及为什么不建议这样做）

async void DangerousFireAndForget()
{
    // 有风险的东西
    throw new Exception("噗通!");
}

async void 方法本质上是 fire-and-forget：不能等待它们，它们不返回 Task。它们的异常会飞到全局的应用处理器（比如 AppDomain.UnhandledException），常常会导致进程崩溃。只在事件处理器里才考虑使用 async void —— 并且要小心。

使用辅助方法来处理错误

把安全的 fire-and-forget 启动封装到一个 wrapper 非常方便：

// 通用方法：安全地启动 fire-and-forget
public static void RunSafeFireAndForget(Func<Task> taskFactory)
{
    Task.Run(async () =>
    {
        try
        {
            await taskFactory();
        }
        catch (Exception ex)
        {
            // 记录异常
            Console.WriteLine("Fire-and-forget (safe): " + ex);
            // 可以添加发送到监控系统！
        }
    });
}

// 用法：
RunSafeFireAndForget(async () =>
{
    await Task.Delay(1000);
    throw new InvalidOperationException("在 fire-and-forget 里!");
});

真实场景示例：发送 email

// 发送邮件按钮:
private void buttonSend_Click(object sender, EventArgs e)
{
    Task.Run(() => SendEmail());
}

// 发送方法:
private void SendEmail()
{
    try
    {
        // 这里可能是真正的发送逻辑
        throw new Exception("SMTP 服务器不可用!");
    }
    catch (Exception ex)
    {
        // 记录日志
        File.AppendAllText("errors.log", $"发送错误: {ex.Message}\n");
    }
}

5. 那么 UnobservedTaskException 是啥？

作为最后手段，.NET 提供了事件 TaskScheduler.UnobservedTaskException。当任务以错误结束、没人等待它，且任务对象被 GC 回收时该事件会被触发。不要依赖它 —— 这是“最后机会”机制。

TaskScheduler.UnobservedTaskException += (sender, e) =>
{
    Console.WriteLine("全局 UnobservedTaskException: " + e.Exception);
    e.SetObserved(); // 别忘了调用它，否则应用可能会异常终止！
};

详情参见: TaskScheduler.UnobservedTaskException。

6. 有用的细节

方式对比示意

await

如何正确设计 fire-and-forget

• 如果任务的结果或状态很关键——不要用 fire-and-forget。用 await 或保存 Task 以便后续等待。
• Fire-and-forget 只适合真正不重要的后台任务（例如发送遥测）。
• 始终把 fire-and-forget 包装在自己的方法里并捕获/记录异常。
• 对于复杂的后台场景，使用队列和 worker：Hangfire, Quartz.NET。

实战与面试

面试中常问：“如果 fire-and-forget 任务里抛异常会怎样？”或“为什么不能到处用 async void？”正确答案是：你要为后台任务里的错误负责——要么捕获、记录并分析，要么就接受幽灵 bug。

fire-and-forget 与 await 的对比

下一讲我们会讨论并行任务返回多个结果时的错误处理。现在记住：如果你“开枪”了，别忘了确认子弹有没有打到目标！

7. 使用 fire-and-forget 任务时的常见错误

错误 №1：忽略 fire-and-forget 里的异常。
新手常以为异常“会某处冒出来”。没有 try-catch 和日志，它们会丢失，导致不可察觉的 bug。

错误 №2：在事件处理器外使用 async void。
这样的函数会把异常丢给全局处理器（比如 AppDomain.UnhandledException），可能导致程序崩溃。

错误 №3：过度捕获异常。
在任务内部捕获所有异常可能会掩盖本该在调用方处理的问题，增加调试难度。

错误 №4：忽视日志记录。
没有日志，就不可能知道 fire-and-forget 任务的失败情况，尤其是在生产环境里。