并行HTTP请求使用System.Net.Http.HttpClient

我想找出使用Task和async/await并行HTTP请求的正确方法。我正在使用HttpClient类，它已经有用于检索数据的异步方法。如果我只是在foreach循环中调用它并等待响应，则一次只发送一个请求（这很有意义，因为在await期间，控制权将返回到我们的事件循环中，而不是返回到foreach循环的下一次迭代中）。并行HTTP请求使用System.Net.Http.HttpClient

我来包裹HttpClient看起来这样

public sealed class RestClient 
{ 
    private readonly HttpClient client; 

    public RestClient(string baseUrl) 
    { 
     var baseUri = new Uri(baseUrl); 

     client = new HttpClient 
     { 
      BaseAddress = baseUri 
     }; 
    } 

    public async Task<Stream> GetResponseStreamAsync(string uri) 
    { 
     var resp = await GetResponseAsync(uri); 
     return await resp.Content.ReadAsStreamAsync(); 
    } 

    public async Task<HttpResponseMessage> GetResponseAsync(string uri) 
    { 
     var resp = await client.GetAsync(uri); 
     if (!resp.IsSuccessStatusCode) 
     { 
      // ... 
     } 

     return resp; 
    } 

    public async Task<T> GetResponseObjectAsync<T>(string uri) 
    { 
     using (var responseStream = await GetResponseStreamAsync(uri)) 
     using (var sr = new StreamReader(responseStream)) 
     using (var jr = new JsonTextReader(sr)) 
     { 
      var serializer = new JsonSerializer {NullValueHandling = NullValueHandling.Ignore}; 
      return serializer.Deserialize<T>(jr); 
     } 
    } 

    public async Task<string> GetResponseString(string uri) 
    { 
     using (var resp = await GetResponseStreamAsync(uri)) 
     using (var sr = new StreamReader(resp)) 
     { 
      return sr.ReadToEnd(); 
     } 
    } 
}

由我们的事件循环中调用的代码是

public async void DoWork(Action<bool> onComplete) 
{ 
    try 
    { 
     var restClient = new RestClient("https://example.com"); 

     var ids = await restClient.GetResponseObjectAsync<IdListResponse>("/ids").Ids; 

     Log.Info("Downloading {0:D} items", ids.Count); 
     using (var fs = new FileStream(@"C:\test.json", FileMode.Create, FileAccess.Write, FileShare.Read)) 
     using (var sw = new StreamWriter(fs)) 
     { 
      sw.Write("["); 

      var first = true; 
      var numCompleted = 0; 
      foreach (var id in ids) 
      { 
       Log.Info("Downloading item {0:D}, completed {1:D}", id, numCompleted); 
       numCompleted += 1; 
       try 
       { 
        var str = await restClient.GetResponseString($"/info/{id}"); 
        if (!first) 
        { 
         sw.Write(","); 
        } 

        sw.Write(str); 

        first = false; 
       } 
       catch (HttpException e) 
       { 
        if (e.StatusCode == HttpStatusCode.Forbidden) 
        { 
         Log.Warn(e.ResponseMessage); 
        } 
        else 
        { 
         throw; 
        } 
       } 
      } 

      sw.Write("]"); 
     } 

     onComplete(true); 
    } 
    catch (Exception e) 
    { 
     Log.Error(e); 
     onComplete(false); 
    } 
}

我已经尝试不同的方法涉及Parallel.ForEach，Linq.AsParallel，并包裹了一把循环的全部内容在Task中。

来源

2017-02-09 Austin Wagner

其基本思想是保持跟踪所有异步任务，并一次等待它们。要做到这一点最简单的方法是将您的foreach体内提取到一个单独的异步方法，做这样的事情：

var tasks = ids.Select(i => DoWorkAsync(i)); 
await Task.WhenAll(tasks);

这样，各个任务分别发出（还是按顺序，但不等待为了完成I/O），并且你在同一时间等待它们。

请注意，您还需要进行一些配置 - 默认情况下，HTTP会被限制为仅允许两个同时连接到同一台服务器。

来源

2017-02-09 15:28:38 Luaan

因此，您是说因为HTTP库的异步调用如何工作，我可以同时启动所有任务，而无需担心同时发送数千个请求的垃圾邮件。 –

查看接受的答案在这里：http://stackoverflow.com/questions/19102966/parallel-foreach-vs-task-run-and-task-whenall –

@AustinWagner默认情况下，是的。 HTTP限制是HTTP规范的一部分，因此在技术上禁用（或放宽）它违反了规范。也就是说，我们生活在不同的时代 - 多个并发请求并不像HTTP最初设计时那样糟糕。无论如何，如果你希望（显着）限制速度，那么你可能也想实现自己的节流 - 否则你只是在浪费一堆内存来处理并行处理，而不是将其转换为流 - 假设你当然，并不需要所有的回应。 – Luaan

并行HTTP请求使用System.Net.Http.HttpClient

回答

相关问题