为什么子任务的许多异常中只传播其中之一？

我正在努力更好地掌握 TPL 中异常和错误处理的基本原理（并且在 .NET 4.5 异步/等待任务中运气更好）

The slightly modified from my earlier question "How to better understand the code/statements from "Async - Handling multiple Exceptions" article?" C# console app code running 2 detached inner nested attached (dependent) child (Update: sorry, started one question but ended by another!) tasks:

class Program
{  
   static void Main(string[] args)
   {  Tst();
      Console.ReadLine();
   }
   async static Task  Tst()
   {
       try
       {
           await Task.Factory.StartNew
             (() =>
                {
                   Task.Factory.StartNew
                       (   () => { 
                                    Console.WriteLine("From 1st child");
                                    throw new NullReferenceException(); 
                                  }
                            , TaskCreationOptions.AttachedToParent
                        );
               Task.Factory.StartNew
                       (  () =>
                               { 
                                   Console.WriteLine("From 2nd child");
                                   throw new ArgumentException(); 
                               }
      ,TaskCreationOptions.AttachedToParent
                       );
                }
             );
    }
    catch (AggregateException ex)
    {
        Console.WriteLine("** {0} **", ex.GetType().Name);
        foreach (var exc in ex.Flatten().InnerExceptions)
        {
             Console.WriteLine(exc.GetType().Name);
        }
    }
    catch (Exception ex)
    {
       Console.WriteLine("## {0} ##", ex.GetType().Name);
    }
 } 

产生在以下之间交替（非确定性）的输出：

From 1st child
From 2nd child
** AggregateException **
ArgumentException

and

From 1t child
From 2nd child
** AggregateException **
NullReferenceException

似乎总是传播/捕获的子任务之一中总是有且只有一个异常。

为什么只传播/捕获一个异常？
我会更好地理解是否总是捕获子任务中的任何异常或所有异常

在这种情况下，是否有可能同时捕获两个异常或不捕获任何异常？

您不应该将父/子任务与async。它们并不是设计来一起使用的。

svick 已经回答了这个问题作为一部分他对你其他问题的（正确）答案。您可以这样想：

• 每个内StartNew得到一个异常，该异常被包装到AggregateException并放置在返回的Task.
• 外层StartNew两者兼得AggregateException来自其子任务，并将其包装到另一个任务中AggregateException其返回时Task.
• 当你await a Task，引发第一个内部异常。其他任何人都将被忽略。

您可以通过保存来观察此行为Tasks 并在异常引发后检查它们await:

async static Task Test()
{
    Task containingTask, nullRefTask, argTask;
    try
    {
        containingTask = Task.Factory.StartNew(() =>
        {
            nullRefTask = Task.Factory.StartNew(() =>
            {
                throw new NullReferenceException();
            }, TaskCreationOptions.AttachedToParent);
            argTask = Task.Factory.StartNew(() =>
            {
                throw new ArgumentException();
            }, TaskCreationOptions.AttachedToParent);
        });
        await containingTask;
    }
    catch (AggregateException ex)
    {
        Console.WriteLine("** {0} **", ex.GetType().Name);
    }
}

如果你设置一个断点WriteLine，您可以看到两个子任务的异常都被放置在父任务上。这await运算符仅传播其中之一，因此这就是您只捕获其中之一的原因。