C'è un motivo per preferire una di queste implementazioni sopra l'altro

Question

Nel suo corso Pluralsight Asynchronous C# 5, Jon Skeet prevede questa implementazione di un metodo di estensione convenienza chiamato InCOmpletionOrder:

public static IEnumerable<Task<T>> InCompletionOrder<T>(this IEnumerable<Task<T>> source) 
{ 
    var inputs = source.ToList(); 
    var boxes = inputs.Select(x => new TaskCompletionSource<T>()).ToList(); 
    int currentIndex = -1; 

    foreach (var task in inputs) 
    { 
     task.ContinueWith(completed => 
     { 
      var nextBox = boxes[Interlocked.Increment(ref currentIndex)]; 
      PropagateResult(completed, nextBox); 
     }, TaskContinuationOptions.ExecuteSynchronously); 
    } 

    return boxes.Select(box => box.Task); 
} 

private static void PropagateResult<T>(Task<T> completedTask, 
     TaskCompletionSource<T> completionSource) 
{ 
    switch(completedTask.Status) 
    { 
     case TaskStatus.Canceled: 
      completionSource.TrySetCanceled(); 
      break; 
     case TaskStatus.Faulted: 
      completionSource.TrySetException(completedTask.Exception.InnerExceptions); 
      break; 
     case TaskStatus.RanToCompletion: 
      completionSource.TrySetResult(completedTask.Result); 
      break; 
     default: 
      throw new ArgumentException ("Task was not completed."); 
    } 
} 

In this question, Martin Neal fornisce un, apparentemente più elegante, implementazione utilizzando ritorno resa

public static IEnumerable<Task<T>> InCompletionOrder<T>(this IEnumerable<Task<T>> source) 
{ 
    var tasks = source.ToList(); 

    while (tasks.Any()) 
    { 
     var t = Task.WhenAny(tasks); 
     yield return t.Result; 
     tasks.Remove(t.Result); 
    } 
} 

Essere ancora un po 'nuova per l'impianto di perforazione il nostro di programmazione asincrona, chiunque può descrivere le preoccupazioni specifiche che potrebbero sorgere con l'implementazione di Martin Neal che sono correttamente risolte dall'implementazione più coinvolta di Jon Skeet

Answer 1

La seconda soluzione ha un problema di complessità quadratica del tempo. Il ciclo esegue N volte e ogni chiamata WhenAny aggiunge N continuazioni a tali attività. Non usare quel codice tranne se si è sicuri che il numero di attività è molto piccolo.

La chiamata Remove causa anche una complessità temporale quadratica.

Inoltre, il secondo pezzo di codice sta bloccando. Recuperai le attività appena completate. InCompletionOrder ti dà queste attività immediatamente e si completano più tardi.

Considerare InCompletionOrder come metodo di libreria. Inseriscilo in un file di utilità e non causerà problemi di manutenzione. Il suo comportamento non potrà mai cambiare. Non vedo la dimensione del codice come un problema qui.