Question

在他的PluralSight课程 Asynchronous C＃5 中，Jon Skeet为名为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.");
    }
}

在this question中，Martin Neal使用 yield return 提供了一个看似更优雅的实现

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);
    }
}

对于严格的异步编程仍然有点新鲜，任何人都可以描述Martin Neal实现中可能出现的特定问题，这些问题可以通过Jon Skeet更多参与实现来正确解决

Answer 1

第二种解决方案存在二次时间复杂度问题。循环运行N次，每次WhenAny调用为这些任务添加N个延续。除非您确定任务数量非常小，否则不要使用该代码。

Remove调用也会导致二次时间复杂度。

此外，第二段代码是阻止。您只有在完成任务时才能恢复。 InCompletionOrder会立即为您提供这些任务，并在以后完成。

我认为InCompletionOrder是一种库方法。将它放入实用程序文件中，它不会导致维护问题。它的行为将/永远不会改变。我不认为代码大小是一个问题。

是否有理由更喜欢这些实现中的一个而不是另一个

1 个答案: