Parallel.ForEach plus rapide que Task.WaitAll pour les tâches liées aux E / S?

J'ai deux versions de mon programme qui soumettent ~ 3000 requêtes HTTP GET à un serveur Web.

La première version est basée sur ce que j'ai lu ici . Cette solution a du sens pour moi, car faire des requêtes Web est un travail lié aux E / S, et l'utilisation de async / await avec Task.WhenAll ou Task.WaitAll signifie que vous pouvez soumettre 100 requêtes en même temps, puis attendre qu'elles toutes soient terminez avant de soumettre les 100 demandes suivantes afin de ne pas enliser le serveur Web. J'ai été surpris de voir que cette version a terminé tout le travail en ~ 12 minutes - bien plus lentement que prévu.

La deuxième version soumet les 3000 requêtes HTTP GET dans un parallèle .Pour chaque boucle. J'utilise .Result pour attendre que chaque requête se termine avant que le reste de la logique dans cette itération de la boucle puisse s'exécuter. Je pensais que ce serait une solution beaucoup moins efficace, car l'utilisation de threads pour effectuer des tâches en parallèle est généralement mieux adaptée pour effectuer un travail lié au processeur, mais j'ai été surpris de voir que cette version a terminé tout le travail en ~ 3 minutes!

Ma question est pourquoi la version Parallel.ForEach est-elle plus rapide? Cela a été une surprise supplémentaire car lorsque j'ai appliqué les deux mêmes techniques à une API / un serveur Web différent , la version 1 de mon code était en fait plus rapide que la version 2 d'environ 6 minutes - c'est ce à quoi je m'attendais. Les performances des deux versions différentes pourraient-elles avoir quelque chose à voir avec la façon dont le serveur Web gère le trafic?

Vous pouvez voir une version simplifiée de mon code ci-dessous:

private async Task<ObjectDetails> TryDeserializeResponse(HttpResponseMessage response)
{
    try
    {
        using (Stream stream = await response.Content.ReadAsStreamAsync())
        using (StreamReader readStream = new StreamReader(stream, Encoding.UTF8))
        using (JsonTextReader jsonTextReader = new JsonTextReader(readStream))
        {
            JsonSerializer serializer = new JsonSerializer();
            ObjectDetails objectDetails = serializer.Deserialize<ObjectDetails>(
                jsonTextReader);
            return objectDetails;
        }
    }
    catch (Exception e)
    {
        // Log exception
        return null;
    }
}

private async Task<HttpResponseMessage> TryGetResponse(string urlStr)
{
    try
    {
        HttpResponseMessage response = await httpClient.GetAsync(urlStr)
            .ConfigureAwait(false);
        if (response.StatusCode != HttpStatusCode.OK)
        {
            throw new WebException("Response code is "
                + response.StatusCode.ToString() + "... not 200 OK.");
        }
        return response;
    }
    catch (Exception e)
    {
        // Log exception
        return null;
    }
}

private async Task<ListOfObjects> GetObjectDetailsAsync(string baseUrl, int id)
{
    string urlStr = baseUrl + @"objects/id/" + id + "/details";

    HttpResponseMessage response = await TryGetResponse(urlStr);

    ObjectDetails objectDetails = await TryDeserializeResponse(response);

    return objectDetails;
}

// With ~3000 objects to retrieve, this code will create 100 API calls
// in parallel, wait for all 100 to finish, and then repeat that process
// ~30 times. In other words, there will be ~30 batches of 100 parallel
// API calls.
private Dictionary<int, Task<ObjectDetails>> GetAllObjectDetailsInBatches(
    string baseUrl, Dictionary<int, MyObject> incompleteObjects)
{
    int batchSize = 100;
    int numberOfBatches = (int)Math.Ceiling(
        (double)incompleteObjects.Count / batchSize);
    Dictionary<int, Task<ObjectDetails>> objectTaskDict
        = new Dictionary<int, Task<ObjectDetails>>(incompleteObjects.Count);

    var orderedIncompleteObjects = incompleteObjects.OrderBy(pair => pair.Key);

    for (int i = 0; i < 1; i++)
    {
        var batchOfObjects = orderedIncompleteObjects.Skip(i * batchSize)
            .Take(batchSize);
        var batchObjectsTaskList = batchOfObjects.Select(
            pair => GetObjectDetailsAsync(baseUrl, pair.Key));
        Task.WaitAll(batchObjectsTaskList.ToArray());
        foreach (var objTask in batchObjectsTaskList)
            objectTaskDict.Add(objTask.Result.id, objTask);
    }

    return objectTaskDict;
}

public void GetObjectsVersion1()
{
    string baseUrl = @"https://mywebserver.com:/api";

    // GetIncompleteObjects is not shown, but it is not relevant to
    // the question
    Dictionary<int, MyObject> incompleteObjects = GetIncompleteObjects();

    Dictionary<int, Task<ObjectDetails>> objectTaskDict
        = GetAllObjectDetailsInBatches(baseUrl, incompleteObjects);

    foreach (KeyValuePair<int, MyObject> pair in incompleteObjects)
    {
        ObjectDetails objectDetails = objectTaskDict[pair.Key].Result
            .objectDetails;

        // Code here that copies fields from objectDetails to pair.Value
        // (the incompleteObject)

        AllObjects.Add(pair.Value);
    };
}

public void GetObjectsVersion2()
{
    string baseUrl = @"https://mywebserver.com:/api";

    // GetIncompleteObjects is not shown, but it is not relevant to
    // the question
    Dictionary<int, MyObject> incompleteObjects = GetIncompleteObjects();

    Parallel.ForEach(incompleteHosts, pair =>
    {
        ObjectDetails objectDetails = GetObjectDetailsAsync(
            baseUrl, pair.Key).Result.objectDetails;

        // Code here that copies fields from objectDetails to pair.Value
        // (the incompleteObject)

        AllObjects.Add(pair.Value);
    });
}