Как обрабатывать исключения при использовании Task Parallel Library Task.WhenAny()

Question

Когда я использую функцию Task.WhenAll(), и исключение отправляется в Задачу, генерируется новое исключение AggregateException, я могу поймать его, чтобы увидеть все исключения, которые произошли в Задания. Однако, когда я использую Task.WhenAny(), исключение не выбрасывается. Вместо этого я должен проверить свойство Task.Exception на значение, чтобы увидеть, произошло ли исключение. Это похоже на плохой запах кода, поскольку я должен был бы не забыть проверить свойство Task.Exception каждый раз, когда я использую Task.WhenAny(). Разве не должно быть лучшего способа?

Вот пример того, что я имею в виду:

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. Если он ошибочен, он разворачивает исключение и бросает его, если это не так, вы знаете, что это уже сделано, чтобы продолжить.

В качестве альтернативы, вы можете просто позвонить Unwrap по телефону Task.WhenAny, а затем 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

Хотя принятый ответ даст вам исключение из Задачи, которая была заполнена сначала. Исключение в 2-й задаче все равно будет выбрано, а в версиях .NET до 4.5 оно будет эскалировано на уровне нити, когда оно получит GC'd, если оно будет незаметно. Наблюдение и регистрация нефатальных исключений задач - превосходное использование для 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(), вы все еще есть шанс наблюдать и исключение и (в < = .NET 4.0) не позволяют убить объединенный поток.