c# - Task.WaitAny() — 检查结果

Question

我在数组中有一系列任务。如果 Task 是“Good”，它会返回一个字符串。如果它是“坏”:它返回一个空值。

我希望能够并行运行所有任务，一旦第一个返回“好”，然后取消其他任务并获得“好”结果。

我现在正在这样做，但问题是所有任务都需要运行，然后我循环遍历它们以寻找第一个好的结果。

List<Task<string>> tasks = new List<Task<string>>();
Task.WaitAll(tasks.ToArray());

Answer 1

I want to be able to run all the Tasks in parallel, and once the first one comes back that is "Good", then cancel the others and get the "Good" result.

这是误解，因为Cancellation in TPL is co-operative ，因此一旦任务启动，就无法取消它。 CancellationToken可以在任务启动之前或之后抛出异常，如果请求取消，这意味着启动并采取必要的行动，比如从逻辑中抛出自定义异常

检查以下 query ，它列出了许多有趣的答案，但没有一个被取消。以下也是一个可能的选择:

public static class TaskExtension<T>
{
  public static async Task<T> FirstSuccess(IEnumerable<Task<T>> tasks, T goodResult)

    {
        // Create a List<Task<T>>
        var taskList = new List<Task<T>>(tasks);
        // Placeholder for the First Completed Task
        Task<T> firstCompleted = default(Task<T>);
        // Looping till the Tasks are available in the List
        while (taskList.Count > 0)
        {
            // Fetch first completed Task
            var currentCompleted = await Task.WhenAny(taskList);

            // Compare Condition
            if (currentCompleted.Status == TaskStatus.RanToCompletion
                && currentCompleted.Result.Equals(goodResult))
            {
                // Assign Task and Clear List
                firstCompleted = currentCompleted;
                break;
            }
            else
               // Remove the Current Task
               taskList.Remove(currentCompleted);
        }
        return (firstCompleted != default(Task<T>)) ? firstCompleted.Result : default(T);
    }
}

用法:

var t1 = new Task<string>(()=>"bad");

var t2 = new Task<string>(()=>"bad");

var t3 = new Task<string>(()=>"good");

var t4 = new Task<string>(()=>"good");

var taskArray = new []{t1,t2,t3,t4};

foreach(var tt in taskArray)
  tt.Start();

var finalTask = TaskExtension<string>.FirstSuccess(taskArray,"good");

Console.WriteLine(finalTask.Result);

您甚至可以返回 Task<Task<T>> , 而不是 Task<T>进行必要的逻辑处理