does dispose method disposes the calling object also?

Question

I found the following code on MSDN:

public class DisposeExample
{

    public class MyResource: IDisposable
    {    
        private IntPtr handle;
        private Component component = new Component(); 
        private bool disposed = false;

        public MyResource(IntPtr handle)
        {
            this.handle = handle;
        }

        public void Dispose()
        {
            Dispose(true);

            GC.SuppressFinalize(this);
        }


        protected virtual void Dispose(bool disposing)
        {
            if(!this.disposed)
            {

                if(disposing)
                {
                    // Dispose managed resources.
                    component.Dispose();
                }


                CloseHandle(handle);
                handle = IntPtr.Zero;

                disposed = true;

            }
        }

        ~MyResource()
        {
            Dispose(false);
        }
    }
    public static void Main()
    {
        MyResource obj = new MyResource()
        //obj.dispose()
    }
}

Now the confusion I have here is that, if I call obj.dispose, it disposes the objects created in the class MyResources i.e. handle, component etc. But does the obj also gets removed off the heap?? Same applies with the destructor. If I don't call dispose, the destructor will be called sometime. The code inside destructor removes the contained objects. But what about the obj? Secondly, if I don't have a destructor defined inside the class and I dont even call dispose, does the GC never come into picture here?

score 0 · Answer 1 · answered Feb 08 '13 at 08:04

0

IDisposable exists to remove unmanaged items from your managed objects. The runtime automatically provides a destructor, this destructor here has the sole purpose of releasing unmanaged items. As soon as your object goes out of scope or is set to null and has no more references to it will eventually be cleared by the GC.

answered Feb 08 '13 at 08:04

bash.d

13,029
3
29
42

Let me interpret that: - If I don't have disposed called in destructor, only the managed objects of obj will be dealt with leaving the unmanaged as it is. - If I don't have a destructor at all defined, as soon as scope of obj dies a destructor will be called deleting the object completely along with the contained managed/unmanaged objects. If such is the case that contained unmanaged objects will also die, why do we even bother to call dispose method? – Ross Cooper Feb 08 '13 at 08:17
Consider this article here, it should help you: [IDisposable](http://www.codeproject.com/Articles/29534/IDisposable-What-Your-Mother-Never-Told-You-About) . Consider the paragraph "The IDisposable Solution". – bash.d Feb 08 '13 at 08:19

score 0 · Answer 2 · answered Feb 08 '13 at 17:21

The fundamental rule I'd recommend with with IDisposable is that at any given moment in time, for every object that implements IDisposable, there should be exactly one entity which has the clearly-defined responsibility of ensuring that it will get cleaned up (almost always by calling Dispose) before it is abandoned. Such responsibility will initially belong to whatever entity calls the IDidposable object's constructor, but that entity may hand the responsibility off to some other entity (which may hand it off again, etc.).

In general, I'd guess that most programmers would be best served if they pretended finalizers and destructors did not exist. They are generally only needed as a consequence of poorly-written code, and in most cases the effort one would have to spend writing a 100%-correct finalizer/destructor and working through all the tricky issues related to threading context, accidental resurrection, etc. could be better spent ensuring that the primary rule given above is always followed. Because of some unfortunate design decisions in the Framework and its languages, there are a few situations which can't very well be handled without finalizers/destructors, but for the most part they serve to turn code which would fail relatively quickly into code which will mostly work but may sometimes fail in ways that are almost impossible to debug.

does dispose method disposes the calling object also?

2 Answers2