IDisposable - what to Dispose in class without external references?

Question

I have small helper classes. The classes are used internally to make sure that certain types of string always have the appropriate format (mail addresses, phone numbers, ids, urls, keys, colors, ...).

I wanted to put them into using blocks, to be able to recycle variable names:

using(Id id = ids.First())
{
    Container container = containers.getById(id);
    ...
}
foreach(Id id in ids.Skip(1))
{
    Container container = containers.getById(id);
    ...
}

As I did this, Visual Studio asked me to mark these classes as Disposable, which I did, but I am not sure what to do with the method stub. Let's take a "Mail Address" class as an example:

public class MailAddress : IEquatable<MailAddress>, IDisposable
{
    const string MAILADDRESSPATTERN = ...
    protected string _address;
    public MailAddress(string address)
    {
        if (address == null) throw new ArgumentNullException("address");
        if (!Regex.IsMatch(address, MAILADDRESSPATTERN)) throw new ArgumentException("address");
        this._address = address.ToLower();
    }

    bool IEquatable<MailAddress>.Equals(MailAddress other)
    ...
    public override int GetHashCode()
    ...
    ...
    ...
    public override string ToString()
    ...

    public void Dispose()
    {
        throw new NotImplementedException();
    }
}

What exactly would the Dispose function have to do in such a class? What do I have to dispose of, and what would the Garbage Collector do automatically?

Up to now, I didn't call Dispose on that class anywhere, and it seemed to work fine. Now, that the class is Disposable, do I have to add calls to Dispose throughout the code?

Answer 1

Your Dispose method has no purpose at all since you don't seem to have any unmanaged resources. Dispose is only useful in the case you want to manually dispose those resources.

All managed resources are garbage-collected by the GC, so no need for any action on your side. Removing the IDisposable on your class seems to be the appropriate action. That would require to remove the useless using too, which you can exchange for simple brackets:

{
    Id id = ids.First();
    Container container = containers.getById(id);
    ...
}

Answer 2

The compiler forces you to implement the IDiposable interface in your Id class, because you use it with using. The sole and only purpose of using is to call IDisposable.Dispose after you leave its block. So you can only use it on IDisposable implementations.

The purpose of the IDisposable is to clean up external resources when the object is not used anymore. That includes closing files, disconneting from databases, returning windows handles and much, much more.

Since you don't seem to have anthing to clean up, you have no need for the usingstatement. In those cases when you have to use using (for example you are using one method for different types of objects where some have external resources), you still have to implement the Dispose method to satisfy the interface, but you can leave it empty.

If your class is disposable, you indeed should dispose it whenever you don't need it anymore, even if Dispose does nothing. If you or someone else adds cleanup code to Dispose later, you should rely on it being executed.

Answer 3

Don't do this, you are abusing the language and the Disposable interface / pattern.

IDisposable is there for very specific reasons, among which are deterministic release of unmanaged resources or when your class owns disposable references.

It is most certainly not a means to create local scope so you can reuse variable names. If you need to do that simply do:

{
    Id id = ids.First())
    Container container = containers.getById(id);
    ...
}

Answer 4

Not sure why you are using the using keyword. The using keyword guaratees a call to Dispose() when the execution leaves the scope of the using. The object inside the using brackets is therefore required to be an IDisposable. If you don't have any resources you need to clean up, there is no need to wrap your object in a using. Since it is not a great idea to use destructors in .net, the logic you would put in a destructor is often placed in the Dispose() method. This allows controlled resource management when combined with the using keyword.