HttpClient rampant entraîne une fuite de mémoire

Je ne suis pas bon à la définition des problèmes de mémoire, mais j'ai essayé avec le code suivant. C'est dans .NET 4.5 et utilise async/await fonction de C#, trop. Il semble garder l'utilisation de la mémoire autour de 10 - 15 MO pour l'ensemble du processus (vous ne savez pas si vous voyez ce une meilleure utilisation de la mémoire). Mais si vous regardez # Collections de la génération 0# Gen 1 Collections et # Gen 2 Collections perf compteurs, ils sont assez haut avec le code ci-dessous.

Si vous supprimez le GC.Collect appels ci-dessous, il va-et-vient entre 30 MO à 50 mo pour l'ensemble du processus. La partie intéressante est que lorsque j'exécute ton code sur mon 4 core de la machine, je ne vois pas anormal de l'utilisation de la mémoire par le processus. J'ai .NET 4.5 est installé sur ma machine et si vous ne le faites pas, le problème peut être lié au CLR internes .NET 4.0 et je suis sûr que TPL, s'est beaucoup améliorée .NET 4.5 sur la base de l'utilisation des ressources.

class Program {
static void Main(string[] args) {
ServicePointManager.DefaultConnectionLimit = 500;
CrawlAsync().ContinueWith(task => Console.WriteLine("***DONE!"));
Console.ReadLine();
}
private static async Task CrawlAsync() {
int numberOfCores = Environment.ProcessorCount;
List<string> requestUris = File.ReadAllLines(@"C:\Users\Tugberk\Downloads\links.txt").ToList();
ConcurrentDictionary<int, Tuple<Task, HttpRequestMessage>> tasks = new ConcurrentDictionary<int, Tuple<Task, HttpRequestMessage>>();
List<HttpRequestMessage> requestsToDispose = new List<HttpRequestMessage>();
var httpClient = new HttpClient();
for (int i = 0; i < numberOfCores; i++) {
string requestUri = requestUris.First();
var requestMessage = new HttpRequestMessage(HttpMethod.Get, requestUri);
Task task = MakeCall(httpClient, requestMessage);
tasks.AddOrUpdate(task.Id, Tuple.Create(task, requestMessage), (index, t) => t);
requestUris.RemoveAt(0);
}
while (tasks.Values.Count > 0) {
Task task = await Task.WhenAny(tasks.Values.Select(x => x.Item1));
Tuple<Task, HttpRequestMessage> removedTask;
tasks.TryRemove(task.Id, out removedTask);
removedTask.Item1.Dispose();
removedTask.Item2.Dispose();
if (requestUris.Count > 0) {
var requestUri = requestUris.First();
var requestMessage = new HttpRequestMessage(HttpMethod.Get, requestUri);
Task newTask = MakeCall(httpClient, requestMessage);
tasks.AddOrUpdate(newTask.Id, Tuple.Create(newTask, requestMessage), (index, t) => t);
requestUris.RemoveAt(0);
}
GC.Collect(0);
GC.Collect(1);
GC.Collect(2);
}
httpClient.Dispose();
}
private static async Task MakeCall(HttpClient httpClient, HttpRequestMessage requestMessage) {
Console.WriteLine("**Starting new request for {0}!", requestMessage.RequestUri);
var response = await httpClient.SendAsync(requestMessage).ConfigureAwait(false);
Console.WriteLine("**Request is completed for {0}! Status Code: {1}", requestMessage.RequestUri, response.StatusCode);
using (response) {
if (response.IsSuccessStatusCode){
using (response.Content) {
Console.WriteLine("**Getting the HTML for {0}!", requestMessage.RequestUri);
string html = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
Console.WriteLine("**Got the HTML for {0}! Legth: {1}", requestMessage.RequestUri, html.Length);
}
}
else if (response.Content != null) {
response.Content.Dispose();
}
}
}
}

La valeur par défaut HttpClient fuites lorsque vous l'utilisez comme un objet éphémère et de créer de nouvelles HttpClients par demande.

Ici est une reproduction de ce comportement.

Comme une solution de contournement, j'ai été en mesure de continuer à utiliser HttpClient comme un objet éphémère à l'aide de la suite de package Nuget au lieu de l'intégré dans System.Net.Http assemblée:
https://www.nuget.org/packages/HttpClient

Pas sûr de ce que l'origine de ce package est, cependant, dès que j'ai référencé la fuite de mémoire a disparu. Assurez-vous que vous supprimez la référence à l'intégré .NET System.Net.Http bibliothèque et utiliser le package Nuget à la place.