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

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