等待单个任务从 List<Task<..>> 中更干净地失败，可能使用 LINQ？

Question

在我的应用程序中，我有一个 List<Task<Boolean>>，我 Task.Wait[..] 用于确定它们是否成功完成 (Result = true)。虽然如果在我等待期间 Task 完成并且 returns 一个虚假值我想取消所有其他 Task 我正在等待并基于此做一些事情。

我创建了两个 "ugly" 方法来执行此操作

// Create a CancellationToken and List<Task<..>> to work with
CancellationToken myCToken = new CancellationToken();
List<Task<Boolean>> myTaskList = new List<Task<Boolean>>();

//-- Method 1 --
    // Wait for one of the Tasks to complete and get its result
Boolean finishedTaskResult = myTaskList[Task.WaitAny(myTaskList.ToArray(), myCToken)].Result;

    // Continue waiting for Tasks to complete until there are none left or one returns false
    while (myTaskList.Count > 0 && finishedTaskResult)
    {
        // Wait for the next Task to complete
        finishedTaskResult = myTaskList[Task.WaitAny(myTaskList.ToArray(), myCToken)].Result;
        if (!finishedTaskResult) break;
    }
    // Act on finishTaskResult here

// -- Method 2 -- 
    // Create a label to 
    WaitForOneCompletion:
    int completedTaskIndex = Task.WaitAny(myTaskList.ToArray(), myCToken);

    if (myTaskList[completedTaskIndex].Result)
    {
        myTaskList.RemoveAt(completedTaskIndex);
        goto WaitForOneCompletion;
    }
    else
        ;// One task has failed to completed, handle appropriately

我想知道是否有更简洁的方法来执行此操作，可能是使用 LINQ？

Answer 1

您可以使用以下方法获取一系列任务并创建一个新的任务序列来表示初始任务但按它们全部完成的顺序返回：

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

    var taskSources = new BlockingCollection<TaskCompletionSource<T>>();

    var taskSourceList = new List<TaskCompletionSource<T>>(taskList.Count);
    foreach (var task in taskList)
    {
        var newSource = new TaskCompletionSource<T>();
        taskSources.Add(newSource);
        taskSourceList.Add(newSource);

        task.ContinueWith(t =>
        {
            var source = taskSources.Take();

            if (t.IsCanceled)
                source.TrySetCanceled();
            else if (t.IsFaulted)
                source.TrySetException(t.Exception.InnerExceptions);
            else if (t.IsCompleted)
                source.TrySetResult(t.Result);
        }, CancellationToken.None, TaskContinuationOptions.PreferFairness, TaskScheduler.Default);
    }

    return taskSourceList.Select(tcs => tcs.Task);
}

既然您可以根据任务的完成情况对任务进行排序，您就可以基本上完全按照您的要求编写代码了：

foreach(var task in myTaskList.Order())
    if(!await task)
        cancellationTokenSource.Cancel();

Answer 2

使用 Task.WhenAny 实现，您可以像扩展重载一样创建也接收过滤器。

此方法 returns 一个 Task 将在任何提供的任务完成且结果通过过滤器时完成。

像这样：

static class TasksExtensions
{
    public static Task<Task<T>> WhenAny<T>(this IList<Task<T>> tasks, Func<T, bool> filter)
    {
        CompleteOnInvokePromiseFilter<T> action = new CompleteOnInvokePromiseFilter<T>(filter);

        bool flag = false;
        for (int i = 0; i < tasks.Count; i++)
        {
            Task<T> completingTask = tasks[i];

            if (!flag)
            {
                if (action.IsCompleted) flag = true;
                else if (completingTask.IsCompleted)
                {
                    action.Invoke(completingTask);
                    flag = true;
                }
                else completingTask.ContinueWith(t =>
                {
                    action.Invoke(t);
                });
            }
        }

        return action.Task;
    }
}

class CompleteOnInvokePromiseFilter<T>
{
    private int firstTaskAlreadyCompleted;
    private TaskCompletionSource<Task<T>> source;
    private Func<T, bool> filter;

    public CompleteOnInvokePromiseFilter(Func<T, bool> filter)
    {
        this.filter = filter;
        source = new TaskCompletionSource<Task<T>>();
    }

    public void Invoke(Task<T> completingTask)
    {
        if (completingTask.Status == TaskStatus.RanToCompletion && 
            filter(completingTask.Result) && 
            Interlocked.CompareExchange(ref firstTaskAlreadyCompleted, 1, 0) == 0)
        {
            source.TrySetResult(completingTask);
        }
    }

    public Task<Task<T>> Task { get { return source.Task; } }

    public bool IsCompleted { get { return source.Task.IsCompleted; } }
}

您可以像这样使用此扩展方法：

List<Task<int>> tasks = new List<Task<int>>();    
...Initialize Tasks...

var task = await tasks.WhenAny(x => x % 2 == 0);

//In your case would be something like tasks.WhenAny(b => b);

Answer 3

Jon Skeet, Stephen Toub, and myself“按完成排序”方法都有变体。

但是，我发现通常人们不需要这种复杂性，如果他们的注意力有所不同的话。

在这种情况下，您有一组任务，并希望在其中一个 returns false 时立即取消它们。与其从控制器的角度考虑（“调用代码如何做到这一点”），不如从任务的角度考虑（“每个任务如何 这样做").

如果您引入更高级别的异步操作“完成工作然后在必要时取消”，您会发现您的调用代码清理得很好：

public async Task DoWorkAndCancel(Func<CancellationToken, Task<bool>> work,
    CancellationTokenSource cts)
{
  if (!await work(cts.Token))
    cts.Cancel();
}

List<Func<CancellationToken, Task<bool>>> allWork = ...;
var cts = new CancellationTokenSource();
var tasks = allWork.Select(x => DoWorkAndCancel(x, cts));
await Task.WhenAll(tasks);

等待单个任务从 List<Task<..>> 中更干净地失败，可能使用 LINQ？

Waiting for a single task to fail out of a List<Task<..>> more cleanly, possibly with LINQ?

c#

linq

task-parallel-library