垃圾收集器如何处理静态类使用的类型对象？

Question

Suppose I have the following class:

 public class Class1
 {
      private Class2 _class2;

      public void SomeMethod() 
      { 
           _class2 = new Class2();               
      }
 }

This is my understanding of what happens when I call var instance = new Class1() :

• If it does not already exist, a new Type Object is created on the heap for Class1
• instance is created on the heap, with it's Type Object Pointer pointing to the Class1 Type Object

Question 1 : Will a Type Object be created for Class2 because Class1 references it, even though I have not instantiated one yet (assuming it does not already exist of course)?

Now suppose I have the following static class

 public static class StaticClass
 {
      private static NormalClass _normalClass = new NormalClass();
      public static void SomeMethod() 
      { 
           // Does something using _normalClass 
      }
 }

When I call SomeMethod() , the StaticClass Type Object is created on the heap.

_normalClass is also created and so is the NormalClass Type Object.

I know that the StaticClass Type Object will never be garbage collected. Any because it holds a reference to _normalClass , neither will that.

Question 2 : Are Type Objects garbage collected? If so, will the Type Object for NormalClass ever be eligable for garbage collection? What about the Type Objects for anything referenced inside NormalClass ?

When I create an innocent looking static class, am I potentially filling up the heap with a large 'chain' of Type Objects that can never be garbage collected?

Answer 1

Okay, your idea of how the CLR works is incorrect. Please refer to this article on the .NET Internals if you'd like to fully understand how it works:

http://msdn.microsoft.com/en-us/magazine/cc163791.aspx#S7

First, lets get your understanding correct:

1. Unless you're using reflection, there are no type objects that are created on heap.
2. When an object is allocated, its has a "TypeHandle", which points to the information about the type.

Now, to your questions:

Answer No. 1:

No. Memory allocations happen for Class1 on the heap when its instantiated. Class2, being a reference type, gets a reference pointer. So, memory to hold the reference pointer is allocated. Period.

When, Class2 is instantiated, memory for the actual storage (based on field sizes) is allocated in the heap.

Answer No. 2:

Yes, but they are not what you assumed they are.

Could the _normalClass ever be garbage collected? Yes. If its set to null at some point, it will be collected when the GC runs.