使用异步委托的ContinueWith未捕获异常，如何捕获t.Result访问时的异常？

看来你在异步任务的ContinueWith异常处理上踩坑了——明明t1抛出了异常，访问t.Result的时候却没按预期被捕获对吧？核心问题出在异步lambda搭配ContinueWith的特殊行为上，我给你拆解清楚，再给几个可行的解决方案：

问题根源 #

当你在ContinueWith里用async lambda时，这个委托本身会返回一个Task，所以ContinueWith最终会返回一个Task<Task>（嵌套任务）。外层的任务会在异步lambda开始执行后就标记为“完成”，但内部的异步操作如果抛出异常，会被包裹在内部的Task里，不会自动传播到外层。另外，t1本身已经抛出异常，直接访问t.Result会触发AggregateException，但因为嵌套任务的存在，这个异常没被外层的等待逻辑捕获到。

解决方案1：用await替代ContinueWith（最推荐） #

异步编程里，await是比ContinueWith更友好的写法——它会自动处理任务等待和异常传播，代码可读性也高得多：

class Program {
    static void Main(string[] args) {
        try {
            // Wait()会把异步异常包装成AggregateException，用catch捕获
            Task.Run(async () => await Test()).Wait();
        }
        catch (AggregateException ex) {
            Console.WriteLine($"捕获到异常：{ex.InnerException.Message}");
        }
        Console.ReadKey();
    }
    private static async Task Test() {
        var t1 = Task.Run<int>(() => {
            throw new Exception("1");
            return 1;
        });

        // await会自动处理t1的异常，直接抛出到Test方法中
        var result = await t1;
        var y = result + 1; // 这行代码因为t1异常，永远不会执行到
    }
}

运行这段代码，你就能看到t1的异常被成功捕获了。

解决方案2：处理ContinueWith的嵌套任务 #

如果一定要用ContinueWith，记得对返回的Task<Task>调用Unwrap()——它会把嵌套任务“展开”成一个代表内部异步操作的Task，这样异常就能正常传播到外层：

class Program {
    static void Main(string[] args) {
        try {
            Task.Run(async () => await Test()).Wait();
        }
        catch (AggregateException ex) {
            Console.WriteLine($"捕获到异常：{ex.InnerException.Message}");
        }
        Console.ReadKey();
    }
    private static async Task Test() {
        var t1 = Task.Run<int>(() => {
            throw new Exception("1");
            return 1;
        });

        var tasks = new[] {
            // 用Unwrap()解开嵌套的Task<Task>，让异常能被外层捕获
            t1.ContinueWith(async t => {
                var y = t.Result + 1; // 访问Result触发异常
            }).Unwrap()
        };

        // 等待所有任务完成，异常会在这里被抛出
        await Task.WhenAll(tasks);
    }
}

解决方案3：在ContinueWith内部处理异常 #

如果你想在ContinueWith里直接处理t1的异常，也可以先检查任务状态，避免直接访问t.Result触发未捕获异常：

var tasks = new[] {
    t1.ContinueWith(t => {
        if (t.IsFaulted) {
            // 在这里处理t1的异常
            Console.WriteLine($"t1执行失败：{t.Exception.InnerException.Message}");
            return;
        }
        var y = t.Result + 1;
    })
};

总结 #

异步编程优先用await，它能帮你避开很多ContinueWith带来的坑，比如嵌套任务、异常传播复杂等问题。如果特殊场景必须用ContinueWith，一定要注意异步lambda的嵌套任务问题，记得用Unwrap()来让异常正常传播。

内容的提问来源于stack exchange，提问作者GhfDllT