等待故障任务（具有异常集的任务）时，await将重新抛出存储的异常。如果存储的异常是AggregateException，它将重新抛出第一个并丢弃其余的异常。
我们如何使用await并同时抛出原始的AggregateException，以便我们不会意外丢失错误信息？
请注意，当然可以考虑使用hacky解决方案（例如围绕await尝试捕获，然后调用Task.Wait）。我真的希望找到一个干净的解决方案。这里最好的做法是什么？
我想过使用自定义awaiter，但内置的TaskAwaiter包含许多魔法，我不知道如何完全重现。它调用TPL类型的内部API。我也不想重现所有这些。
如果你想玩它，这是一个简短的repro：
static void Main()
{
Run().Wait();
}
static async Task Run()
{
Task[] tasks = new[] { CreateTask("ex1"), CreateTask("ex2") };
await Task.WhenAll(tasks);
}
static Task CreateTask(string message)
{
return Task.Factory.StartNew(() => { throw new Exception(message); });
}
在Run中只抛出了两个例外中的一个。
请注意，Stack Overflow上的其他问题无法解决此特定问题。建议重复时请小心。
我不同意你的问题标题中暗示await的行为是不受欢迎的。在绝大多数场景中都有意义。在WhenAll情况下，您是否经常需要知道所有错误细节，而不仅仅是一个？
AggregateException的主要困难是异常处理，即你失去了捕获特定类型的能力。
也就是说，您可以使用扩展方法获得所需的行为：
public static async Task WithAggregateException(this Task source)
{
try
{
await source.ConfigureAwait(false);
}
catch
{
// source.Exception may be null if the task was canceled.
if (source.Exception == null)
throw;
// EDI preserves the original exception's stack trace, if any.
ExceptionDispatchInfo.Capture(source.Exception).Throw();
}
}
我知道我迟到但我发现了这个整齐的小技巧，可以做你想要的。由于等待任务可以使用完整的异常集，因此调用此Task的Wait或.Result将抛出一个聚合异常。
static void Main(string[] args)
{
var task = Run();
task.Wait();
}
public static async Task Run()
{
Task[] tasks = new[] { CreateTask("ex1"), CreateTask("ex2") };
var compositeTask = Task.WhenAll(tasks);
try
{
await compositeTask.ContinueWith((antecedant) => { }, TaskContinuationOptions.ExecuteSynchronously);
compositeTask.Wait();
}
catch (AggregateException aex)
{
foreach (var ex in aex.InnerExceptions)
{
Console.WriteLine(ex.Message);
}
}
}
static Task CreateTask(string message)
{
return Task.Factory.StartNew(() => { throw new Exception(message); });
}
Exception Handling (Task Parallel Library)
我可以说更多，但它只是填充。玩它，它确实像他们说的那样工作。你必须要小心。
也许你想要这个
God (Jon Skeet) explains await exception handling
（我个人躲避等待，但这只是我的偏好）
回应评论（评论回复太长）
然后使用线程作为类似参数的起点，因为最佳实践将是这里的源的源。
除非你实现代码将它们传递出去，否则很快就会被吞噬掉（例如，await可能包装的异步模式......你在引发事件时将它们添加到事件args对象中）。如果您有一个场景，您可以启动任意数量的线程并对其执行，则无法控制订单或终止每个线程的点。此外，如果一个错误与另一个错误相关，您将永远不会使用此模式。因此，你强烈暗示其余的执行是完全独立的 - IE你强烈暗示这些线程上的异常已经作为异常处理。如果你想在它们出现的线程（这是bizzarre）中处理这些线程中的异常以外的事情，你应该将它们添加到通过引用传入的锁定集合中 - 你不再将异常视为例外而是作为一块信息 - 使用并发包，将异常包装在您需要的信息中以识别它来自的上下文 - 这将被传递到它中。
不要混淆您的用例。
我不知道我是否被允许总结这个非常有趣的问题中提出的问题的两个最佳解决方案（在我看来），Stephen Cleary先生和adonthy先生的答案。我通过添加参数preserveAggregate稍微改变了API，试图与单个内置配置选项ConfigureAwait保持一致。这些配置是可链接的，例如：
await Task.WhenAll(tasks).ConfigureException(true).ConfigureAwait(false);
这是Stephen Cleary's先生版本（略有修改）：
public static class TaskConfigurationExtensions
{
public static async Task ConfigureException(this Task task, bool preserveAggregate)
{
try
{
await task.ConfigureAwait(false); // Because the context doesn't have to be resumed on to throw.
}
catch
{
if (preserveAggregate) throw task.Exception;
throw;
}
}
public static async Task<T> ConfigureException<T>(this Task<T> task, bool preserveAggregate)
{
try
{
return await task.ConfigureAwait(false);
}
catch
{
if (preserveAggregate) throw task.Exception;
throw;
}
}
}
这里是adonthy's先生版本（也略有修改）：
public static class TaskConfigurationExtensions
{
private static void Empty<T>(T value) { }
public static async Task ConfigureException(this Task task, bool preserveAggregate)
{
if (preserveAggregate)
{
await task
.ContinueWith(Empty, TaskContinuationOptions.ExecuteSynchronously)
.ConfigureAwait(false);
task.Wait();
return;
}
await task.ConfigureAwait(false);
}
public static async Task<T> ConfigureException<T>(this Task<T> task, bool preserveAggregate)
{
if (preserveAggregate)
{
await task
.ContinueWith(Empty, TaskContinuationOptions.ExecuteSynchronously)
.ConfigureAwait(false);
return task.Result;
}
return await task.ConfigureAwait(false);
}
}
据我所知，这两种实现都是等效且优秀的。
我不想放弃这种做法，只能抓住我期望的例外。这引出了以下扩展方法：
public static async Task NoSwallow<TException>(this Task task) where TException : Exception {
try {
await task;
} catch (TException) {
var unexpectedEx = task.Exception
.Flatten()
.InnerExceptions
.FirstOrDefault(ex => !(ex is TException));
if (unexpectedEx != null) {
throw new NotImplementedException(null, unexpectedEx);
} else {
throw task.Exception;
}
}
}
消费代码可能是这样的：
try {
await Task.WhenAll(tasks).NoSwallow<MyException>();
catch (AggregateException ex) {
HandleExceptions(ex);
}
一个骨头异常将具有与同步世界相同的效果，即使它偶然与MyException同时抛出也是如此。使用NotImplementedException进行包装有助于不会丢失原始堆栈跟踪。