C# 中对 Task 中的异常进行捕获

news2025/10/25 12:46:06

以下是在 C# 中对 Task 中的异常进行捕获的几种常见方法：

方法一：使用 `try-catch` 语句

你可以使用 try-catch 语句来捕获 Task 中的异常，尤其是当你使用 await 关键字等待任务完成时。

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        try
        {
            await Task.Run(() =>
            {
                // 模拟异常抛出
                throw new Exception("An error occurred in the task.");
            });
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Caught exception: {ex.Message}");
        }
    }
}

在上述代码中，使用 await 等待 Task.Run 中异步执行的代码。当 Task.Run 中的代码抛出异常时，异常会被 catch 块捕获并处理。

方法二：使用 `ContinueWith` 并处理 `Task.Exception`

对于不使用 await 的情况，可以使用 ContinueWith 方法来处理任务完成后的情况，包括异常。

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Task.Run(() =>
        {
            // 模拟异常抛出
            throw new Exception("An error occurred in the task.");
        }).ContinueWith(task =>
        {
            if (task.IsFaulted)
            {
                // 处理异常
                foreach (var ex in task.Exception.InnerExceptions)
                {
                    Console.WriteLine($"Caught exception: {ex.Message}");
                }
            }
        });

        // 等待任务完成，这里只是为了防止程序提前退出，在实际应用中可能有不同的等待方式
        Console.ReadLine();
    }
}

在这个例子中，创建一个 Task 并使用 ContinueWith 来添加后续操作。如果任务发生故障（即抛出异常），task.IsFaulted 将为 true，并且可以通过 task.Exception.InnerExceptions 来访问异常信息。需要注意的是，Task.Exception 是一个 AggregateException，因为一个 Task 可能会抛出多个异常，所以它包含了一个内部异常列表。

方法三：使用 `async-await` 与 `Task.WhenAll` 或 `Task.WhenAny` 时的异常处理

当使用 Task.WhenAll 或 Task.WhenAny 组合多个任务时，也可以使用 try-catch 来捕获异常。

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Task task1 = Task.Run(() =>
        {
            throw new Exception("Error in task 1");
        });

        Task task2 = Task.Run(() =>
        {
            // 正常执行
        });

        try
        {
            await Task.WhenAll(task1, task2);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Caught exception: {ex.Message}");
        }
    }
}

在这个例子中，Task.WhenAll 会等待 task1 和 task2 都完成。如果 task1 抛出异常，该异常将被 catch 块捕获。对于 Task.WhenAny，异常处理的逻辑类似，但它只会等待第一个任务完成，所以你可能需要额外的逻辑来确保在异常发生后处理其他任务。

方法四：使用 `UnobservedTaskException` 事件（不推荐）

在一些情况下，可以使用 TaskScheduler.UnobservedTaskException 事件来处理未观察到的异常，但这种方式在.NET 4.5 及以上版本中已经不推荐使用，因为异常可能会导致应用程序崩溃。

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        TaskScheduler.UnobservedTaskException += (sender, e) =>
        {
            foreach (var ex in e.Exception.InnerExceptions)
            {
                Console.WriteLine($"Unobserved exception: {ex.Message}");
            }
            // 标记为已观察，避免程序崩溃
            e.SetObserved();
        };

        Task.Run(() =>
        {
            throw new Exception("This is an unobserved exception.");
        });

        // 给任务一些时间抛出异常
        System.Threading.Thread.Sleep(1000);
    }
}

总结

推荐使用 try-catch 与 await：对于使用 async-await 模式的异步编程，这是最简洁和直观的方式，能够直接捕获在任务执行过程中抛出的异常。
使用 ContinueWith 进行链式处理：对于不使用 await 的情况，使用 ContinueWith 可以方便地在任务完成后检查是否发生故障并处理异常。
处理多个任务的异常：使用 Task.WhenAll 或 Task.WhenAny 时，仍然可以使用 try-catch 来捕获组合任务中可能出现的异常。