IList<T> Custom Collections

Comments

• StephenC Redgate › Posts: 314

  July 20, 2009 4:00AM

  The object retention graph is designed to show what is referencing an object and therefore preventing it from being GC'd.
  
  This should help you identify what's keeping the remaining instance in memory.
  
  Stephen

  0 · Share on Twitter
• StephenC Redgate › Posts: 314

  July 20, 2009 6:21AM

  There's another possibility that it's simply on the Finalizer queue.
  
  If you take another snapshot does the instance still remain?
  
  Stephen

  0 · Share on Twitter
• sandyp Posts: 2

  September 18, 2009 6:20AM

  I have the same situation. The very simple WinForms test:
  

  public class MyInfoClass
      {
          string _name = String.Empty;
  
          public MyInfoClass(string name)
          {
              _name = name;
          }
  
          public string Name
          {
              get
              {
                  return _name;
              }
              set
              {
                  _name = value;
              }
          }
      }
  
      public partial class Form1 : Form
      {
          private List<MyInfoClass> _list = null;
  
          public Form1()
          {
              InitializeComponent();
              List<MyInfoClass> list = new List<MyInfoClass>();
              list.Add(new MyInfoClass("1"));
              list.Add(new MyInfoClass("2"));
              list.Add(new MyInfoClass("3"));
  
              _list = list;
          }
  
          private void button1_Click(object sender, EventArgs e)
          {
              _list = null;
          }
  
          private void button2_Click(object sender, EventArgs e)
          {
              _list.Clear();
              _list = null;
              GC.Collect();
          }
      }
  

  
  After pressing button2, I have [GC Handle]->System.Object[]->MyInfoClass[] chain and it's remained in memory after new snapshots. Any ideas why?

  0 · Share on Twitter
• Andrew H Redgate › Posts: 121

  September 18, 2009 7:06AM

  It took me a little while to work this one out It's odd, but you're not seeing something that indicates a memory leak here, I think.
  
  System.Generic.List contains a static reference to an empty array, so that it can represent 0 item lists more effectively: that's the array that you're seeing after you click the button. Note that it's actually there beforehand as well: you'll see two arrays when you take a snapshot before clicking the button.
  
  It's not a memory leak, but rather an implementation detail of the .NET framework. You'll note that the array is always very small and there's only every one of these.
  
  The pattern [GC Handle]->System.Object[]->MyInfoClass[] usually indicates a static variable: this is how they're implemented internally by the .NET framework. The profiler does try to identify which variable contains a particular object provided you're using .NET 2 or later, but there are some CLR limitations that prevent it from working reliably in all cases. Generic classes, such as List<T> is one such example, unfortunately, which is why this gets presented in this way.

  Andrew Hunter
  Software Developer
  Red Gate Software Ltd.

  0 · Share on Twitter
• sandyp Posts: 2

  September 21, 2009 10:16AM

  Yes, it looks strange but your findings explain everything. Thanks!

  0 · Share on Twitter