C# .Net_ IDisposable interface

Question

why do we need to implement IDisposable interface when we actually have to write the code for Dispose method. We may write code for clearing managed code without implementing the IDisposable interface? what is the point?

Answer 1

I know the IDisposable interface and how to use it already.

When I come to use your class, I'm going to have to learn a few things (which might be really simple, or really complicated) about what it's actually for, but I shouldn't have to learn how to do a clean-up of a sort that many other classes also do, and do through the IDisposable interface I already know about.

That's already a big point in favour of having a well-known interface for such use. Another is that it's the best way to have code that works with lots of different types with the common feature of their requiring clean-up. I can write a method that takes IDisposable thingToDispose a lot more easily than I can write code that cleans up different objects in different ways according to how each was implemented.

Answer 2

One major advantage of implementing IDisposable is being able to use a using statement. From the MSDN page on the using statement:

The using statement ensures that Dispose is called even if an exception occurs while you are calling methods on the object.

A using statement will only accept an IDisposable, so if you weren't to implement IDisposable, you'd need to create your own logic to ensure Dispose is called on your object when exiting the code block which calls methods on your object.

With IDisposable:

using (var myObject = new MyClass()) {
    ... logic ...
}

Without IDisposable:

{
    var myObject = new MyClass();
    try {
        ... logic ...
    }
    finally {
        myObject.Dispose();
    }
}

Above, the try... finally pattern ensures that, in the case of an exception being raised, the Dispose method is still called, which is a feature you'd have gotten by using IDisposable in the using. It's also in a self-contained block to ensure myObject is not accessed elsewhere after calling Dispose – again, a feature of the using statement when declaring myObject as above.

Answer 3

We may write code for clearing managed code without implementing the IDisposable interface? what is the point?

Imagine you have this class:

public class Bad
{
    private StreamWriter writer;
    public Bad()
    {
        this.writer = new StreamWriter("Bad.txt");
    }
    public void Write(string line)
    {
        writer.Write(line);
    }
}

How will you write code for disposing the writer? You cannot know from within the class when the client (consumer of your class) will be done with needing it. And the client cannot dispose it because it is private. So how will you do it?

You can create another method called CloseWriter like this:

public void CloseWriter()
{
    this.writer.Dispose();
}

And in your documentation you can instruct clients to call this method once they are done with using your class. But the clients will need to read your documentation and sometimes, in some classes this may be called CloseWriter and other times it may be called Done() or Finish().

The whole idea of implementing the IDisposable interface is to have a common language which all clients (developers) are familiar with. Plus they can use the using block if you have implemented IDisposable interface.

More Advantages

There are also more advantages.

1. Class Definition

Your class definition will be like this so other developers will know right away how to properly use your class:

public class Good : IDisposable

2. Many frameworks, for example, ASP MVC, WCF and others will call the Dispose method on your class if it implements IDisposable. For example, MVC will call it after the view is rendered.

You see without the interface, how will MVC know what method to call: CloseWriter(), Done(), Finish() etc.

3. People will be able to treat your class polymorphically.

   var disposables = new List(); disposables.Add(new A()); disposables.Add(new B()); disposables.Add(new C());

   foreach(var thisDisposable in dispsables) { thisDisposable.Dispose(); }

That will work even if A, B, and C are doing completely different things but they all implement IDisposable interface.