Question

我有一个ASP.NET MVC应用程序需要检查3个远程API服务器上是否存在某些内容。应用程序将ID传递给每个API，它返回true或false。代码看起来像这样。

public class PingController
{
    public async Task<bool> IsFound(int id)
    {
        var servers = new ['a.com', b.com', 'c.com'];
        var result = await foundAtServers(id, servers);
        return result;
    }

    private async Task<bool> foundAtServers(int id, string[] servers)
    {
        var tasks = from server in servers
                    select checkServer(id, server);

        return await.Task.WhenAll(tasks.ToArray());
    }

    private async Task<bool> checkServer(id, server)
    {
         var request = new HttpRequestMessage(HttpMethod.Get, server+"/api/exists"+id);
         var client = new HttpClient();

         var task = await client.SendAsync(request);
         var response = await task.Content.ReadAsStringAsync();

         return bool.Parse(response);
    }
}

此代码目前以异步方式检查所有3个API，但会等到所有HttpClient调用都完成后才能返回MVC操作。

只要一个API返回true，我想立即在Action上返回true，而不是等待其他任务完成。

C＃Task类有.WaitAll和.WaitAny，但这些也不起作用。由于我需要取消其他HttpClient请求，我认为我需要使用CancellationToken，但我不知道如何使用此结构。

干杯。

Answer 1

如果您想立即返回，可以使用Task.WhenAny代替Task.WhenAll。此不会取消正在进行的任务，但它会让您尽快返回：

private async Task<bool> FoundAtServersAsync(int id, string[] servers)
{
    var tasks = (from server in servers
                 select checkServer(id, server)).ToList();

    while (tasks.Count > 0)
    {
        var finishedTask = await Task.WhenAny(tasks);
        if (finishedTask.Result)
        {
            return finishedTask.Result;
        }

        tasks.Remove(finishedTask);
    }
    return false;
}

这将丢弃其他任务。这意味着如果在其中一个内部抛出任何异常，它将被吞下。

修改：

如果您关心实际取消其他任务，请考虑将CancellationToken传递给overload of SendAsync which takes one，并在收到值后调用CancellationTokenSource.Cancel。请注意，这意味着您还需要处理他们将要抛出的OperationCanceledException。

如果它们无关紧要，我只需将它们丢弃，如上所述。

Answer 2

通过使用以下方法获取一系列任务并根据完成时间对它们进行排序，可以更轻松地解决此问题。

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

有了这个，你可以写：

public static async Task<bool> WhenAny(this IEnumerable<Task<bool>> tasks)
{
    foreach (var task in tasks.Order())
        if (await task)
            return true;
    return false;
}

Answer 3

您可以等待第一项任务完成 - 如果成功，立即返回true。否则，等待下一个完成，依此类推。

private async Task<bool> foundAtServers(int id, string[] servers)
{
    var tasks = servers.Select(server => checkServer(id, server))
                       .ToList();

    while(tasks.Any())
    {
        var task = await Task.WhenAny(tasks);

        if(task.Result)
            return true;

        tasks.Remove(task);
    }

    return false;
}

如果一个完成的线程满足条件

3 个答案: