使用任务并行库 Task.WhenAny() 时如何处理异常

Question

当我使用Task.WhenAll() 函数并在任务中引发异常时，会引发新的 AggregateException，我可以捕获它以查看任务中发生的所有异常。但是，当我使用 Task.WhenAny() 时，不会引发异常。相反，我必须检查Task.Exception 属性的值，以查看是否发生异常。这似乎是一种糟糕的代码气味，因为我必须记住每次使用Task.WhenAny() 时都要检查Task.Exception 属性。不应该有更好的方法吗？

这是我的意思的一个例子：

private async void btnMultipleExceptions_Click(object sender, EventArgs e) {
        var task1 = ThrowNotImplementedException();
        var task2 = ThrowDivideByZeroException();

        try {
            Task task = await Task.WhenAny(task1, task2);

            // Even if an exception is thrown in one of the tasks (in our case,
            // task1 will throw first) no exception is thrown from
            // the above await Task.WhenAny(). Instead, the exception is placed on the 
            // Task.Exception property. So I need to check for it every time 
            // I call Task.WhenAny()?
            if (task.Exception != null) {
                Console.WriteLine("Exceptions: " + string.Join(Environment.NewLine,
                    task.Exception.InnerExceptions.Select(x => x.Message).ToArray()));
            } else {
                Console.WriteLine("No Exceptions!");
            }
        } catch(Exception ex) {
            // Try to catch all exceptions???
            AggregateException allEx = ex as AggregateException;

            if (allEx != null) {
                Console.WriteLine("Exceptions: " + string.Join(Environment.NewLine,
                    allEx.InnerExceptions.Select(x => x.Message).ToArray()));
            } else {
                Console.WriteLine("Exceptions: " + ex.Message);
            }
        }
    }

    private async Task ThrowNotImplementedException() {
        await Task.Delay(TimeSpan.FromSeconds(1));
        throw new NotImplementedException();
    }

    private async Task ThrowDivideByZeroException() {
        await Task.Delay(TimeSpan.FromSeconds(2));
        throw new DivideByZeroException();
    }

Answer 1

只需await 从WhenAny 返回的任务。如果它出错了，它会解开异常并抛出它，如果没有，你知道它已经完成了，所以你可以继续。

或者，您可以简单地在Task.WhenAny 上调用Unwrap，然后再调用await。这在语义上与前一个选项相同；唯一的区别在于您是否认为这或多或少清楚。

如果您发现自己非常频繁地解包 WhenAny 的结果，您可以简单地编写自己的实现来为您解包任务，然后使用它们来代替：

public static Task WhenAny(IEnumerable<Task> tasks)
{
    return Task.WhenAny(tasks).Unwrap();
}
public static Task<T> WhenAny<T>(IEnumerable<Task<T>> tasks)
{
    return Task.WhenAny(tasks).Unwrap();
}
//TODO add wrappers for the `params` overloads if you want them too

Answer 2

虽然接受的答案会给你一个例外首先完成的任务。第二个任务中的异常仍然会被抛出，并且在 4.5 之前的 .NET 版本中，如果它未被观察到，它将在线程级别升级，当它被 GC 时。观察和记录非致命任务异常是 Continuations 的绝佳用途（我从您的 WhenAny() 场景中假设，如果您的一项任务失败，这不是致命的情况）。考虑这样的事情：

private static void LogIfErrors(Task source)
{
    if(source.Exception == null) return;
    source.Exception.Handle(ex =>
    {
        Log.Error("#unhandled #task #error", ex);
        return true;
    });
    return;
}

private void DoStuff()
{
    // note that you cannot inline the ContinueWith() statement,
    // because it would change the value of task1 to hold your
    // continuation instead of your parent task

    var task1 = ThrowNotImplementedException();
    task1.ContinueWith(LogIfErrors, TaskContinuationOptions.OnlyOnFaulted);

    var task2 = ThrowDivideByZeroException();
    task2.ContinueWith(LogIfErrors, TaskContinuationOptions.OnlyOnFaulted);

    var firstCompleted = await Tasks.WhenAny(task1, task2).Unwrap();

}

现在，即使您的一个任务长时间运行并且在您的第一个完成任务被WhenAny() 返回很久之后抛出异常，您仍然有机会观察异常并且（在

Answer 3

等待等待

await await Task.WhenAny(...);