Question

Hope you don’t mind, I may be missing something; I just need some clarification for the following scenario: If an object a contains a reference to a static list and also an entry in that static list, and object a falls out of scope, will it be garbage collected? Do I need to set object a’s reference to the static list and reference to the entry in that list to null before it becomes eligible?

I understand that the static list contains objects which will live for the lifetime of the application, so I was thinking since object a still references an entry in that static list, it is still in the main dependency object graph of objects which are still live?

Thanks in advance

Answer 1

Firstly, objects don’t fall out of scope, variables do. The difference is one of semantics most of the time, but vital here.

Let’s create a concrete example of what you talk about:

private static List<string> static_strings = new List<string>();//this won't be
                                                                //collected unless we
                                                                //assign null or another
                                                                //List<string> to static_strings
public void AddOne()
{
  string a = new Random().Next(0, 2000).ToString();//a is in scope, it refers
                                                   //to a string that won't be collected.
  static_strings.Add(a);//now both a and the list are ways to reach that string.
  SomeListHolder b = new SomeListHolder(static_strings);//can be collected
                                                        //right now. Nobody cares
                                                        //about what an object refers
                                                        //to, only what refers to it.
}//a is out of scope.
public void RemoveOne()
{
  if(static_strings.Count == 0) return;
  a = static_strings[0];//a is in scope.
  static_strings.RemoveAt(0);//a is the only way to reach that string.
  GC.Collect();//Do not try this at home.
  //a is in scope here, which means that we can write some code here
  //that uses a. However, garbage collection does not depend upon what we
  //could write, it depends upon what we did write. Because a is no
  //longer used, it is highly possible that it was collected because
  //the compiled code isn't going to waste its time holding onto referenes
  //it isn't using.
}

As seen here, scope is nothing, reachability is everything.

In the case of an object that refers to a static, what it refers to is irrelevant, only what refers to it.

In particular, note that this means that circular references do not prevent items from being collected, unlike with some reference-counted garbage collection approaches.