如何在任务完成时处理任务 - 但每个任务需要不同的方法来处理任务的结果

Question

我正在使用 async/await 来调用一些外部 API。它们都返回一个字符串值，但格式不同，需要自己处理。 我想在任务完成时处理返回的值。我不想等到一切都完成，因此我正在使用 Task.WhenAny()。如何在任务完成时处理任务，并且在完成每个任务时仍然使用正确的“处理”方法？

我在第一次发帖后做了一些更改，这是我最新的：

public async Task<List<string>> Get()
{
    var task1 = Method1Async();
    var task2 = Method1Async();
    var tasks = new List<Task<string>> {task1, task2};
    var results = new List<string>();
    while (tasks.Count > 0)
    {
        var justCompletedTask = await Task.WhenAny(tasks);//will not throw
        tasks.Remove(justCompletedTask);
        try
        {
           var result = await justCompletedTask;
           results.Add(result);
        }
        catch(Exception)
        { 
          //deal with it
        }
    }

    return results;
}

private async Task<string> Method1Async()
{
    //this may throw - something like forbidden or any other exception
    var task = _httpClient.GetStringAsync("api1's url here");
    var result = await Method1ResultProcessorAsync(task);
    return result;
}

private async Task<string> Method1ResultProcessorAsync(Task<string> task)
{
    //process task's result -if it successuflly completed and return that
    return await task; //for now
}

private async Task<string> Method2Async()
{
    //this may throw - something like forbidden or any other exception
    var task = _httpClient.GetStringAsync("api2's url here");
    var result = await Method2ResultProcessorAsync(task);
    return await task;
}

private async Task<string> Method2ResultProcessorAsync(Task<string> task)
{
    //This processing logic is entirely different from Method1ResultProcessor
    //process task's result -if it successfully completed and return that 
    return await task; //for now
}

我有两个问题：

1. 这是解决问题的正确方法吗？
2. 这里如何更好地处理异常？这是非常重要的，所以一个人的失败不应该让整个事情失败。只要任何一种方法成功，就可以了。但是如果都失败了，我想把Get方法扔掉。

Answer 1

由于您的处理器方法已经接受Task，您可以直接调用它们，它们将异步等待相应的结果：

public Task<string[]> Get()
{
    var task1 = Method1ResultProcessorAsync(Method1Async());
    var task2 = Method2ResultProcessorAsync(Method2Async());

    return Task.WhenAll(task1, task2);
}

按照您描述的方式处理异常会使事情变得更加复杂，但您可以使用类似的方法：

public async Task<List<string>> Get()
{
    var task1 = Method1ResultProcessorAsync(Method1Async());
    var task2 = Method2ResultProcessorAsync(Method2Async());

    var tasks = new[] { task1, task2 };

    try
    {
        await Task.WhenAll(tasks);
    }
    catch {}

    var results = tasks.Where(t => t.Status == TaskStatus.RanToCompletion)
                       .Select(t => t.Result)
                       .ToList();

    if (results.Any())
        return results;

    // or maybe another exception,
    // since await handles AggregateException in a weird way
    throw new AggregateException(tasks.Select(t => t.Exception));
}

Answer 2

1. 这是描述Method1Async() 和Method2Async() 的另一种方式。这是ContinueWith的演示。回答您在标题中提出的问题 - 您确实可以为每个任务使用不同的方法，该方法将在任务完成后调用。

   var task1 = _httpClient.GetStringAsync("api1's url here").ContinueWith(t => Method1ResultProcessorAsync(t));
   var task2 = _httpClient.GetStringAsync("api2's url here").ContinueWith(t => Method2ResultProcessorAsync(t));
   

2. 您正确处理了异常。回答“但如果都失败了，我想用Get方法抛出。”：只需检查results.Count == 0是否在return之前，如果是0则throw。