4

我有一个 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 Action 才能返回。

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

C# Task 类有 .WaitAll 和 .WaitAny，但它们也不起作用。由于我需要取消另一个 HttpClient 请求，我认为我需要使用 CancellationToken 但我不知道如何将它与这个结构一起使用。

干杯。

4

3 回答 3

2

如果要立即返回，可以使用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的重载传递给SendAsynctake oneCancellationTokenSource.Cancel ，并在收到值后调用。请注意，这意味着您还需要处理OperationCanceledException他们将抛出的问题。

如果它们无关紧要，我会像上面那样简单地丢弃它们。

于 2015-06-01T15:52:53.517 回答
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;
}
于 2015-06-01T15:55:26.367 回答
1

您可以等待第一个任务完成 - 如果它成功，立即返回 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;
}
于 2015-06-01T15:53:15.653 回答