Dispose pattern?

Sumitra Paul

Hi,

I was going through dispose pattern. I implemented IDisposable inteface with few codes and tried to dispose some object.
But not sure how the dispose method gets called.

Please find my code below:

public class Program
    {
        static void Main(string[] args)
        {
            MyClass myClass = new MyClass();
            myClass.TestMethod();
        }
    }

    public class MyClass : IDisposable
    {
        StreamReader strReader;
        private bool disposed = false;
        public void TestMethod()
        {
            strReader = new StreamReader("TextFile1.txt");
        }
        #region IDisposable Members

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    if (strReader != null)
                    {
                        strReader.Dispose();
                    }
                }
                disposed = true;
            }
        }

#endregion
}

Now here, from where to call dispose method ?

Is that correct the way I am doing?
Is it that for each object that i create, I need to dispose it this way?

Thanks.

5 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Accepted answer
Well, if you were simply implementing the IDisposable interface, then you might come up with something simple like this:

public void Dispose()
{
if(strReader != null) strReader.Dispose();
}

What makes it into a pattern is that you're going further than this by :

1. Allowing for the possibility that the Dispose() method might be called more than once by mistake.

2. Providing a firm base whereby derived classes of MyClass can dispose of not just their own unmanaged resources but those of the base class as well by calling its Dispose method.

3. Suppressing finalization in case a derived class has a destructor.

The benefit of using a pattern here is that you can just implement it without having to think out all these aspects from scratch.
Vulpes14y ago
Notice that the MSDN articles for the Dispose pattern are contradictory.

In the .NET 4.0 version of the article which Sukesh found for version 2.0, it tells you that it is not necessary to create a finalizer (destructor in C#) for a class which contains a Stream as a field because it is not directly creating a file handle in the unmanaged heap:

http://msdn.microsoft.com/en-us/library/fs2xkftw(VS.100).aspx

In other words, the CLR will release the file handle anyway when MyClass (and the Stream before it) are GC'ed.
Sukesh Marla14y ago

You are also required to do one more thing
Create Desctror as follow
~YouRClassName()
   {
      Dispose(false);
   }

If You(user) forget to call dispose explictly Destrcuir will do the necessary task

Check this microst article
http://msdn.microsoft.com/en-us/library/fs2xkftw%28VS.80%29.aspx

one more thing you can like this'
Using(MyClass myClass = new MyClass())
{
            myClass.TestMethod();
            //myClass.Dispose();   Not required
}
Checj this is correct answer if it helped
Sumitra Paul14y ago
Thanks Vulpes..

Here I don'nt understand one thing.
Just implementaing an interface i.e. IDisposable, why we call it as Pattern.

I mean is there anything else?
Vulpes14y ago
Although it doesn't really matter here as the program is about to finish anyway, in principle, you'd call the Dispose() method as follows:

public class Program
{
static void Main(string[] args)
{
MyClass myClass = new MyClass();
myClass.TestMethod();
myClass.Dispose();
}
}

You only need to implement IDisposable if your object uses unmanaged resources so that you can release them immediately when the object is no longer needed.

As the StreamReader object uses a file handle, it makes sense for MyClass to implement IDisposable so what you're doing here is fine.