CODEWITHSUNDEEP
c#.netobjectdispose
sysboard
sysboard

Reputation: 287

Object disposal in .Net

Assuming i have the following classes:

Class MainClass
{
   private OtherClass1;
   MainClass()
   {
      OtherClass1 = new OtherClass1();
   }

   void dispose()
   {
      OtherClass1 = null;
   }
}

class OtherClass1
{
   private OtherClass2;
   OtherClass1()
   {
      OtherClass2 = new OtherClass2();
   }
}

class OtherClass2
{
}

If i instatiate MainClass and later call dispose method, does the OtherClass1 gets garbage collected (later on)? Or do i have first to clear the reference to OtherClass2?

Upvotes: 1

Views: 745

Answers (5)

supercat
supercat

Reputation: 81277

The term "Dispose" is a bit of a misnomer, since the Dispose method doesn't delete the targeted object but rather serves a request for the targeted object to do anything that will need to be done before it may be safely abandoned. Essentially, it's a request for the object to put its affairs in order.

The most common situation when a particular object will need to put its affairs in order is when some entities outside of it may be doing something, storing something, refraining from doing something, or otherwise temporarily altering their behavior on its behalf. Note that the entities may be .net objects, other types of OS-recognized objects (GDI handles, etc.), etc. but there's no particular requirement that the entity be any particular kind of thing, nor that they be in the same computer, or even any computer. For an object to puts its affairs in order, outside entities doing, holding, etc. anything on its behalf need to be told that they no longer need to do so. If the entities in question are .net objects that implement IDisposable, the notification would be generally performed by calling their Dispose method.

Note that .net provides a means by which objects can ask to be notified if the system notices that they've been abandoned, and use that as a cue to put their affairs in order. Such notifications may not come in timely fashion, and various factors may cause them to be delayed essentially indefinitely, but the mechanism (called "finalization") is sometimes better than nothing.

Upvotes: -2

Henk Holterman
Henk Holterman

Reputation: 273691

In the code as provided, you don't have to null anything, you can safely remove your dispose() and all will be well.

If your OtherClass1 and/or OtherClass2 are managed resources, ie they implement the IDisposable interface then your code is not good enough. You then will have to chain the Dispose:

class MainClass : IDisposable
{
   private OtherClass1;
   MainClass()
   {
      OtherClass1 = new OtherClass1();
   }

   public void Dispose()
   {
      OtherClass1.Dispose(); 
      // OtherClass1 = null;  // not needed
   }
}

Upvotes: 1

George Duckett
George Duckett

Reputation: 32448

An object will get garbage collected if it has no references, or the references it does have are from objects that themselves don't have references (and so on).

A way of visualising it, is the garbage collector will walk the object reference graph, following all object references, making a note of ones it gets to (still referenced from somewhere). Any it doesn't get to are eligible for garbage collection as if it didn't get to them then they can't possibly be used.

See here for in-depth info (particularly "The Garbage Collection Algorithm"): http://msdn.microsoft.com/en-us/magazine/bb985010.aspx

So yes, it'll be eligible to be GC'd.

Also, if you have a dispose method you really should implement IDisposable.

Upvotes: 6

The Light
The Light

Reputation: 27021

The best practice is to implement IDisposable interface and implementing the Dispose() method.

At Dispose(), you just release the resources used by your object such as any external resources, COM references, database connections, etc.

In terms of When the object will be garbage collected, it's up to the .NET engine to decide that as they frequently update their disposal algorithm with each release.

In general, when an object is orphan (no variable references it), it will be in the queue to be garbage collected.

You can manually call GC.Collect(); but that's not recommended since it interferes .NET garbage collection mechanism.

Upvotes: 0

Lucero
Lucero

Reputation: 60276

If there is no other reference to it, it may at some time be garbage collected. Note that this is not deterministic, you cannot rely on it being collected in a specific timespan.

In general, you shouldn't worry too much abot this, the GC in .NET can by design handle circular references etc. without any problem. Setting fields to null is usually not required. The Dispose method is usually used to release unmanaged resources, such as database connections etc. in a deterministic fashion; it's not about freeing the memory of the object being disposed.

Upvotes: 0

Related Questions