Task.WaitAny() — 检查结果

Question

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

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

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

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

Answer 1

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

这是个误会，因为Cancellation in TPL is co-operative，所以Task一旦启动，就没有办法取消了。 CancellationToken 可以在 Task 启动之前工作或稍后抛出异常，如果请求取消，这意味着启动并采取必要的操作，例如从逻辑中抛出自定义异常

检查以下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> 进行必要的逻辑处理

Answer 2

您可以使用以下示例达到您想要的结果。

List<Task<string>> tasks = new List<Task<string>>();  

// ***Use ToList to execute the query and start the tasks.   
List<Task<string>> goodBadTasks = tasks.ToList();  

// ***Add a loop to process the tasks one at a time until none remain.  
while (goodBadTasks.Count > 0)  
{  
    // Identify the first task that completes.  
    Task<string> firstFinishedTask = await Task.WhenAny(goodBadTasks);  

    // ***Remove the selected task from the list so that you don't  
    // process it more than once.  
    goodBadTasks.Remove(firstFinishedTask);  

    // Await the completed task.  
    string firstFinishedTaskResult = await firstFinishedTask;  
    if(firstFinishedTaskResult.Equals("good")
         // do something

}  

EDIT ：如果您想终止所有任务，您可以使用 CancellationToken。

更多详情请阅读docs。

Answer 3

我正在研究Task.WhenAny()，它将在第一个“已完成”任务时触发。不幸的是，从这个意义上说，一个已完成的任务基本上是任何事情......即使是一个异常也被认为是“完成”。据我所知，没有其他方法可以检查您所谓的“好”值。

虽然我认为您的问题没有令人满意的答案，但我认为您的问题可能有替代解决方案。考虑使用Parallel.ForEach。

        Parallel.ForEach(tasks, (task, state) =>
        {
            if (task.Result != null)
                state.Stop();
        });

state.Stop() 将在发现非空结果时停止执行并行循环。

除了能够在找到“好”值时停止执行，它在许多（但不是所有）场景下都会表现得更好。

Answer 4

使用Task.WhenAny它返回完成的任务。检查它是否为空。如果是，请将其从列表中删除并再次调用 Task.WhenAny。

如果没问题，取消列表中的所有任务（它们都应该有一个CancellationTokenSource.Token。

编辑：

所有任务都应使用相同的CancellationTokenSource.Token。然后你只需要取消一次。 这里有一些代码需要澄清：

private async void button1_Click(object sender, EventArgs e)
{
    CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();

    List<Task<string>> tasks = new List<Task<string>>();
    tasks.Add(Task.Run<string>(() => // run your tasks
       {
           while (true)
           {
               if (cancellationTokenSource.Token.IsCancellationRequested)
               {
                   return null;
               }
               return "Result";  //string or null
           }
       }));
    while (tasks.Count > 0)
    {
        Task<string> resultTask = await Task.WhenAny(tasks);
        string result = await resultTask;
        if (result == null)
        {
            tasks.Remove(resultTask);
        }
        else
        {
            // success
            cancellationTokenSource.Cancel(); // will cancel all tasks
        }
    }
}