多个异步调用，如何以有意义的方式处理响应

Question

我正在对几个不同的 URL 进行多次异步调用，两个 url 应该返回相同的结果，但我想比较两者的结果或检查响应中的某些值。我不确定如何在状态代码之外的响应中比较或查找特定值，有没有简单的方法可以做到这一点？还想注意响应，如果失败了，我希望稍后能够在我的代码中跟踪它，以便不再使用该 url，我不确定我将如何处理这个

代码：

private async Task<ClientModel> getClientInfoAsync(string clientID)
    {
        
        ClientModel c = null;
       
        try
        {
            
            var client = new HttpClient();
            //Start requests for all of them
            var requests = urls.Select
                (
                url => client.GetAsync(getURL(url, "Client", clientID))
                ).ToList();
            //Wait for all the requests to finish
            await Task.WhenAll(requests);

            //Get the responses
            var responses = requests.Select
                (
                    task => task.Result
                );
           
            foreach (var r in responses)
            {
                
                // Extract the message body
                var s = await r.Content.ReadAsStringAsync();                    
                          
                if (r.IsSuccessStatusCode)
                {
                    c = r.Content.ReadAsAsync<ClientModel>().Result;                        
                    SetLastSuccessfulCommunicationDetails();  //after this call HERE I THINK IS WHERE I WOULD COMPARE RESPONSES AND GO FROM THERE                     

                }
                
            }
           
        }
        catch (Exception ex)
        {
            string errMsg = "Error getting the client info";
            //...catch error code here...
        }
        
        return c;
    }

基本上我不确定如何处理响应，并且根据我的比较和响应状态仅返回一个客户端模型 (c)。让我知道是否需要包含任何进一步的信息

Answer 1

如果我可以假设你有一个看起来像这样的方法：

private Task<ClientModel> DetermineClientModelFromResponses(IEnumerable<string> responses)

...那么您可以使用 Microsoft 的 Reactive Framework (aka Rx) - NuGet System.Reactive 并添加 using System.Reactive.Linq;。

它让你这样做：

private async Task<ClientModel> GetClientInfoAsync(string clientID) =>
    await DetermineClientModelFromResponses(
        await Observable.Using(
            () => new HttpClient(),
            client =>
                urls
                    .ToObservable()
                    .SelectMany(url => Observable.FromAsync(() => client.GetAsync(getURL(url, "Client", clientID))))
                    .Where(response => response.IsSuccessStatusCode)
                    .SelectMany(response => Observable.FromAsync(() => response.Content.ReadAsStringAsync()))
                    .ToArray()));
                

...或者，或者，这个：

private async Task<ClientModel> GetClientInfoAsync(string clientID) =>
    await DetermineClientModelFromResponses(
        await Observable.Using(
            () => new HttpClient(),
            client =>
            (
                from url in urls.ToObservable()
                from response in Observable.FromAsync(() => client.GetAsync(getURL(url, "Client", clientID)))
                where response.IsSuccessStatusCode
                from text in Observable.FromAsync(() => response.Content.ReadAsStringAsync())
                select text
            ).ToArray()));

---

如果您对第一个成功响应获胜感到满意，那么这应该适合您，但您需要确保您至少有一个成功：

private async Task<ClientModel> GetClientInfoAsync(string clientID) =>
    await Observable.Using(
        () => new HttpClient(),
        client =>
        (
            from url in urls.ToObservable()
            from response in Observable.FromAsync(() => client.GetAsync(getURL(url, "Client", clientID)))
            where response.IsSuccessStatusCode
            from text in Observable.FromAsync(() => response.Content.ReadAsAsync<ClientModel>())
            select text
        ).Take(1));

---

为了使这对错误更加稳健，您有一些策略。

我把你的代码改写成一个简单的例子：

async Task Main()
{
    var result = (string)"no result";
    try
    {
        result = await GetClientInfoAsync("123");
    }
    catch (NotImplementedException ex)
    {
        Console.WriteLine(ex.Message);
    }
    Console.WriteLine(result);
}

private List<string> urls = new List<string>() { "Hello" };

private async Task<string> GetClientInfoAsync(string clientID) =>
    await Observable.Using(
        () => new HttpClient(),
        client =>
        (
            from url in urls.ToObservable()
            from response in Observable.FromAsync(() => Test1(url))
            from text in Observable.FromAsync(() => Test2(response))
            select $"{clientID}:{text}"
        )
            .Concat(Observable.Return<string>(null))
            .Take(1));

private Random _random = new Random();

Task<string> Test1(string url)
{
    if (_random.NextDouble() > 0.3)
    {
        throw new NotImplementedException("Test1!");
    }
    return Task.Run(() => $"{url}!");
}

Task<string> Test2(string response)
{
    if (_random.NextDouble() > 0.3)
    {
        throw new NotImplementedException("Test2!");
    }
    return Task.Run(() => $"{response}#");
}

一旦出现异常，此代码将结束 GetClientInfoAsync，并让它冒泡到 Main 方法。这对你来说可能还不够。

另一种方法是向每个Test1 和Test2 添加正常的try/catch 代码，以确保它们永远不会失败。

或者，您可以很容易地添加“重试”功能。

private async Task<string> GetClientInfoAsync(string clientID) =>
    await Observable.Using(
        () => new HttpClient(),
        client =>
        (
            from url in urls.ToObservable()
            from response in Observable.Defer(() => Observable.FromAsync(() => Test1(url))).Retry(5)
            from text in Observable.Defer(() => Observable.FromAsync(() => Test2(response))).Retry(5)
            select $"{clientID}:{text}"
        )
            .Concat(Observable.Return<string>(null))
            .Take(1));

请注意，现在 Test1 和 Test2 各重试 5 次。

错误仍有可能通过，但这是正常编码，对吗？

请注意，我还添加了.Concat(Observable.Return<string>(null))，以确保如果查询本身没有值，则查询会生成一个值。 Concat 在连接 null 结果之前等待主查询结束，所以如果主查询没有产生任何值，那么 null 就会出来。

Answer 2

首先，如果可以的话，不要使用.Result。有一种更简洁的方式来获取所有响应。

var responses = await Task.WhenAll(requests);

这种方法的一个缺点是，如果任何请求引发异常，它都会引发异常。因此，如果您想智能地处理这种情况，您需要尝试/捕获并有一些特殊的逻辑来处理它。

您可以为每个异步步骤继续该模式，将您的结果作为集合处理：

        var validResponses = responses.Where(r =>r.IsSuccessStatusCode);
        var clientModels = await Task.WhenAll(
            validResponses
                .Select(async r => await r.Content.ReadAsAsync<ClientModel>()));

这种方法的一个缺点是您最终要等待所有请求完成，然后才能开始阅读任何响应内容。因此，将发出请求、获取响应以及沿途收集任何数据的整个过程放在一个异步方法中可能更有意义，只需说var responseData = await Task.WhenAll(urls.Select(ThatMethod))。这样一来，只要有一个请求返回，您就可以开始使用它的响应。

在比较结果时，如果不知道您在寻找哪种比较，就无法提供帮助。但是，假设您想要模型中某些属性值最高的那个，例如：

        var lastResponseModel = clientModels
            .OrderByDescending(c => c.LastSaved)
            .First();
        return lastResponseModel;