c# - 使用System.Net.Http.HttpClient的并行HTTP请求

我正试图找出使用Task和async/await并行化http请求的正确方法。我正在使用HttpClient类，该类已经有了用于检索数据的异步方法。如果我只是在foreach循环中调用它并等待响应，那么一次只发送一个请求（这是有意义的，因为在await期间，控制返回到我们的事件循环，而不是foreach循环的下一次迭代）。
我的包装看起来是这样的

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

我尝试了一些不同的方法，包括HttpClient，Parallel.ForEach，并将循环的全部内容包装在Linq.AsParallel中。

最佳答案

基本思想是跟踪所有异步任务，并立即等待它们。最简单的方法是将foreach的主体提取到一个单独的异步方法中，然后执行如下操作：

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

这样，单独的任务被单独发布（仍然是按顺序的，但是没有等待i/o完成），您可以同时等待它们。
请注意，您还需要进行一些配置-默认情况下，http被限制为只允许两个同时连接到同一服务器。

forEach

c# - 使用System.Net.Http.HttpClient的并行HTTP请求