Resultados de rastreo HttpClient en la pérdida de memoria

Estoy trabajando en un WebCrawlerimplementación pero estoy enfrentando una extraña pérdida de memoria en el HTTP HttpClient de la API Web.

Así que la versión reducida está aquí:

[ACTUALIZACIÓN 2]

Encontré el problema y no es HttpClient que tiene fugas. Mira mi respuesta

[ACTUALIZACIÓN 1]

He añadido desechar sin efecto:

    static void Main(string[] args)
    {
        int waiting = 0;
        const int MaxWaiting = 100;
        var httpClient = new HttpClient();
        foreach (var link in File.ReadAllLines("links.txt"))
        {

            while (waiting>=MaxWaiting)
            {
                Thread.Sleep(1000);
                Console.WriteLine("Waiting ...");
            }
            httpClient.GetAsync(link)
                .ContinueWith(t =>
                                  {
                                      try
                                      {
                                          var httpResponseMessage = t.Result;
                                          if (httpResponseMessage.IsSuccessStatusCode)
                                              httpResponseMessage.Content.LoadIntoBufferAsync()
                                                  .ContinueWith(t2=>
                                                                    {
                                                                        if(t2.IsFaulted)
                                                                        {
                                                                            httpResponseMessage.Dispose();
                                                                            Console.ForegroundColor = ConsoleColor.Magenta;
                                                                            Console.WriteLine(t2.Exception);
                                                                        }
                                                                        else
                                                                        {
                                                                            httpResponseMessage.Content.
                                                                                ReadAsStringAsync()
                                                                                .ContinueWith(t3 =>
                                                                                {
                                                                                    Interlocked.Decrement(ref waiting);

                                                                                    try
                                                                                    {
                                                                                        Console.ForegroundColor = ConsoleColor.White;

                                                                                        Console.WriteLine(httpResponseMessage.RequestMessage.RequestUri);
                                                                                        string s =
                                                                                            t3.Result;

                                                                                    }
                                                                                    catch (Exception ex3)
                                                                                    {
                                                                                        Console.ForegroundColor = ConsoleColor.Yellow;

                                                                                        Console.WriteLine(ex3);
                                                                                    }
                                                                                    httpResponseMessage.Dispose();
                                                                                });                                                                                
                                                                        }
                                                                    }
                                                  );
                                      }
                                      catch(Exception e)
                                      {
                                          Interlocked.Decrement(ref waiting);
                                          Console.ForegroundColor = ConsoleColor.Red;                                             
                                          Console.WriteLine(e);
                                      }
                                  }
                );

            Interlocked.Increment(ref waiting);

        }

        Console.Read();
    }

El archivo que contiene enlaces está disponible.aquí.

Esto se traduce en un aumento constante de la memoria. El análisis de memoria muestra muchos bytes posiblemente retenidos por AsyncCallback. He hecho muchos análisis de pérdida de memoria antes, pero este parece estar en el nivel HttpClient.

Estoy usando C # 4.0, así que no hay async / await aquí, así que solo se usa TPL 4.0.

El código anterior funciona, pero no está optimizado y, a veces, provoca una rabieta, pero es suficiente para reproducir el efecto. El punto es que no puedo encontrar ningún punto que pueda causar una pérdida de memoria.

Respuestas a la pregunta(2)

Su respuesta a la pregunta