c# - HttpClient - 发送一批请求

Question

我想迭代一批请求，使用 HttpClient 类将每个请求发送到外部 API。

  foreach (var MyRequest in RequestsBatch)
  {
            try
            {
                HttpClient httpClient = new HttpClient();
                httpClient.Timeout = TimeSpan.FromMilliseconds(5);
                HttpResponseMessage response = await httpClient.PostAsJsonAsync<string>(string.Format("{0}api/GetResponse", endpoint), myRequest);
                JObject resultResponse = await response.Content.ReadAsAsync<JObject>();
            }
            catch (Exception ex)
            {
                continue;
            }
 }

这里的上下文是我需要设置一个非常小的超时值，因此如果响应花费的时间超过该时间，我们只需获取“任务已取消”异常并继续迭代即可。

现在，在上面的代码中，注释这两行:

                HttpResponseMessage response = await httpClient.PostAsJsonAsync<string>(string.Format("{0}api/GetResponse", endpoint), myRequest);
                resultResponse = await response.Content.ReadAsAsync<JObject>();

迭代结束得非常快。取消注释并重试。这需要很多时间。

我想知道使用 await 调用 PostAsJsonAsync/ReadAsAsync 方法是否需要比超时值更多的时间？

根据下面的答案，假设它会创建不同的线程，我们有这个方法:

  public Task<JObject> GetResponse(string endPoint, JObject request, TimeSpan timeout)
    {
        return Task.Run(async () =>
        {
            try
            {
                HttpClient httpClient = new HttpClient();
                httpClient.Timeout = TimeSpan.FromMilliseconds(5);
                HttpResponseMessage response = await httpClient.PostAsJsonAsync<string>(string.Format("{0}api/GetResponse", endPoint), request).WithTimeout<HttpResponseMessage>(timeout);
                JObject resultResponse = await response.Content.ReadAsAsync<JObject>().WithTimeout<JObject>(timeout);
                return resultResponse;
            }
            catch (Exception ex)
            {
                return new JObject() { new JProperty("ControlledException", "Invalid response. ")};
            }
        });
    }

那里引发了一个异常并且应该返回 JObject 异常，非常快，但是，如果使用 httpClient 方法，即使它引发了异常也需要很多时间。即使返回值是一个简单的异常 JObject，是否存在影响 Task 的幕后处理？

如果是，可以使用另一种方法以非常快速的方式向 API 发送一批请求吗？

Answer 1

我同意接受的答案，因为加快速度的关键是并行运行请求。但是，任何通过使用 Task.Run 或 Parallel.ForEach 强制混合使用其他线程的解决方案都不会提高 I/O 绑定(bind)异步操作的效率。如果有任何伤害的话。

您可以轻松地让所有调用并发运行，同时让底层异步子系统决定尽可能高效地完成任务需要多少线程。有可能这个数字远小于并发调用的数量，因为它们在等待响应时根本不需要任何线程。

此外，接受的答案会为每次调用创建一个新的 HttpClient 实例。也不要这样做 - bad things can happen .

这是已接受答案的修改版本:

var httpClient = new HttpClient {
    Timeout = TimeSpan.FromMilliseconds(5)
};

var taskList = new List<Task<JObject>>();

foreach (var myRequest in RequestsBatch)
{
    // by virtue of not awaiting each call, you've already acheived parallelism
    taskList.Add(GetResponseAsync(endPoint, myRequest));
}

try
{
    // asynchronously wait until all tasks are complete
    await Task.WhenAll(taskList.ToArray());
}
catch (Exception ex)
{
}

async Task<JObject> GetResponseAsync(string endPoint, string myRequest)
{
    // no Task.Run here!
    var response = await httpClient.PostAsJsonAsync<string>(
        string.Format("{0}api/GetResponse", endpoint), 
        myRequest);
    return await response.Content.ReadAsAsync<JObject>();
}