下面的代码是否捕获了 TPL 中原始任务、延续任务和子任务的异常？

Question

我正在使用 TPL 和 async/await 在 webclient 之上为我的应用程序构建异步 API。很少有地方（通常是我需要运行一堆异步任务并最终等待所有这些任务的地方），我遵循代码 sn-p。我只是想确保我得到它是正确的，即使使用 TPL 和 async/await 编写异步代码相对容易 调试/故障排除仍然具有挑战性（交互式调试和客户站点的故障排除问题） - 所以想把它做好。

我的目标： 能够捕获原始任务、后续任务以及子任务产生的异常，以便我处理（如果需要）。我不希望任何例外都被遗忘。

我使用的基本原则： 1. .net 框架确保将异常附加到任务 2. try/catch 块可以应用于 async/await 以提供同步代码的错觉/可读性（参考：http://channel9.msdn.com/Events/TechDays/Techdays-2014-the-Netherlands/Async-programming-deep-dive、http://blogs.msdn.com/b/ericlippert/archive/2010/11/19/asynchrony-in-c-5-part-seven-exceptions.aspx、http://msdn.microsoft.com/en-us/library/dd537614.aspx 等）

问题：我希望获得批准，即我希望的目标（我可以从原始任务、延续任务和子任务中捕获异常）已经实现，并且我可以对示例：

例如，是否会出现这样一种情况，其中一个组合任务（例如，解包的代理任务）根本不会被激活（waitforactivation 状态），因此 waitall 可能只是等待任务启动？我的理解是，这些情况永远不会发生，因为延续任务总是执行，并返回一个已由代理使用 wnwrap 跟踪的任务。只要我在所有层和 api 中遵循类似的模式，该模式就应该捕获链式任务中的所有聚合异常。

注意： 本质上是在寻找建议，例如，如果原始任务状态未完成，则避免在继续任务中创建虚拟任务，或者使用附加到父级以便我只能等待父级等. 查看所有可能性，以便我可以选择最佳选项，因为这种模式在我的应用程序中严重依赖于错误处理。

static void SyncAPIMethod(string[] args)
        {
            try
            {
                List<Task> composedTasks = new List<Task>();
                //the underlying async method follow the same pattern
                //either they chain the async tasks or, uses async/await 
                //wherever possible as its easy to read and write the code
                var task = FooAsync();
                composedTasks.Add(task);
                var taskContinuation = task.ContinueWith(t =>
                    {
                        //Intentionally not using TaskContinuationOptions, so that the 
                        //continuation task always runs - so that i can capture exception
                        //in case something is wrong in the continuation
                        List<Task> childTasks = new List<Task>();
                        if (t.Status == TaskStatus.RanToCompletion)
                        {

                            for (int i = 1; i <= 5; i++)
                            {
                                var childTask = FooAsync();
                                childTasks.Add(childTask);
                            }

                        }
                        //in case of faulted, it just returns dummy task whose status is set to 
                        //'RanToCompletion'
                        Task wa = Task.WhenAll(childTasks);
                        return wa;
                    });
                composedTasks.Add(taskContinuation);
                //the unwrapped task should capture the 'aggregated' exception from childtasks
                var unwrappedProxyTask = taskContinuation.Unwrap();
                composedTasks.Add(unwrappedProxyTask);
                //waiting on all tasks, so the exception will be thrown if any of the tasks fail
                Task.WaitAll(composedTasks.ToArray());
            }
            catch (AggregateException ag)
            {
                foreach(Exception ex in ag.Flatten().InnerExceptions)
                {
                    Console.WriteLine(ex);
                    //handle it
                }
            }
        }

Answer 1

来自cmets：

IMO，这段代码本可以更简单、更优雅 使用异步/等待。我不明白你坚持的原因 ContinueWith 和 Unwrap，以及为什么同时添加内部和外部 （解包）任务到composedTasks。

我的意思是像下面这样。我认为它与原始代码的作用相同，但没有composedTasks、ContinueWith 和Unwrap 形式的不必要冗余。如果你使用async/await，你几乎不需要这些。

static void Main(string[] args)
{
    Func<Task> doAsync = async () =>
    {
        await FooAsync().ConfigureAwait(false);

        List<Task> childTasks = new List<Task>();
        for (int i = 1; i <= 5; i++)
        {
            var childTask = FooAsync();
            childTasks.Add(childTask);
        }

        await Task.WhenAll(childTasks);
    };

    try
    {
        doAsync().Wait();
    }
    catch (AggregateException ag)
    {
        foreach (Exception ex in ag.Flatten().InnerExceptions)
        {
            Console.WriteLine(ex);
            //handle it
        }
    }
}

static async Task FooAsync()
{
    // simulate some CPU-bound work
    Thread.Sleep(1000); 
    // we could have avoided blocking like this:        
    // await Task.Run(() => Thread.Sleep(1000)).ConfigureAwait(false);

    // introduce asynchrony
    // FooAsync returns an incomplete Task to the caller here
    await Task.Delay(1000).ConfigureAwait(false);
}

更新以解决评论：

在某些用例中，我在“创建子任务”后继续 调用更多“独立”任务。

基本上，任何异步任务工作流都存在三种常见场景：顺序组合、并行组合或这两者的任意组合（混合组合）：

• 顺序组合：

  await task1;
  await task2;
  await task3;
  

• 平行组合：

  await Task.WhenAll(task1, task2, task3);
  
  // or
  
  await Task.WhenAny(task1, task2, task3);
  

• 混合成分：

  var func4 = new Func<Task>(async () => { await task2; await task3; });
  await Task.WhenAll(task1, func4());
  

如果上述任何任务执行 CPU 密集型工作，您可以为此使用 Task.Run，例如：

    var task1 = Task.Run(() => CalcPi(numOfPiDigits));

其中CalcPi 是进行实际计算的同步方法。