C# .NET - Garbage Collector

Hi All,

Garbage collector will run on the heap at runtime and frees the objects memory which does not have references with stack.
Suppose I have a code
void MyMethod
{
     MyCLass myObject = new MyClass();
     myObject.SomeProperty = "Some Text";
     some code....
}

Now here the object mYObject will be stored in Heap and the refence will be stored in stack.
If the control is at the end of the method myObject will be out of scope refence will be deleted from stack.
What will happen in the below two scenarios
void MyMethod
{
     MyCLass myObject = new MyClass();
     myObject.SomeProperty = "Some Text";
     some code....
     myObject.dispose();
}
void MyMethod
{
     MyCLass myObject = new MyClass();
     myObject.SomeProperty =Te "Some xt";
     some code....
     System.GC.Collect();
}

Please let me know what happens when I run the GC.Collect or dispose method on the object.

Thanks in advance.

Hi,

Calling Dispose on an object will usually release any unmanaged resources it has underneath - it does nothing with the Garbage Collector.

I have a blog post about using Dispose:
http://adamhouldsworth.blogspot.com/2010/02/idisposable-disposable-pattern.html

Calling GC.Collect will fire the garbage collector, but because your myObject reference is not null, your myObject will not be garbage collected.

There are very few places you will likely need to use GC.Collect - I use it when creating add-ins for other applications however, as you are residing in their process.

Objects that are declared in logical scope usually only have the one reference on the stack, as you say.  When the stack pops, it will remove this one reference and be elligible for collection.

Dispose is a pattern implemented by .NET for deterministic release of unmanaged resources.  It has little to do with the Garbage Collector itself.  The GC does not call Dispose on your objects, it calls an object's finalizer - which in certain classes has been used to then call Dispose, as explained in my blog post.

Adam 

1. myObject.Dispose()

Thanks for your reply.

Please clarify my doubts in this scenario,
private Void MyMethod1()
{
     MyMethod2();
     System.GC.Collect();
}
private Void MyMethod2()
{
       MyClass myObj = new MyClass();
       myObj.property = "some text";
       some code..
}

Here in the first method MyMethod1 I am calling another method creating an object and returning the control back to MyMethod1,
then I am calling System.GC.Collect();
Object will be removed from the heap when CLR runs the GarbageCollector on Heap or by the code System.GC.Collect(); written after calling the method MyMethod2(); ?

I can use System.GC.Collect() in the code this will not effect the CLR running GarbageCollector at runtime?

Please let me know the things how it goes.

Thanks in advance.

Hi,

In this scenario, your MyClass instance will be popped from the stack and elligible for collection.

Calling GC.Collect, according to MSDN, forces an immediate collection of all generations:
http://msdn.microsoft.com/en-us/library/xe0c2357.aspx

So, in theory, your MyClass instance should be collected.

Adam

Calling GC.Collect does not affect the automatic collection of objects - however, generally you don't need to do it as the GC is highly optimized.

Adam