C#

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

using (var x = new MyThing()) // MyThing is IDisposable
{
   ... code block ...
}

// is equivalent to

var x = new MyThing();
try
{
   ... code block ...
}
finally
{
   if (x != null) x.Dispose();
}

public class MyBaseClass
{
  // Some stuff in here.
  public virtual void Dispose()
  {}
}
public class MyDisposableBaseClass : MyBaseClass, IDisposable
{
  // No need to implement the Dispose method here because this
  // class derives from a class that already has a Dispose, method
  // even though that class doesn't implement IDisposable.
}
// some code, which then gets called as:
using (MyBaseClass myClass = new MyDisposableBaseClass())
{
  // There's a problem, and this won't compile because MyBaseClass does not
  // implement IDisposable.
}
// Change the code to
using (MyDisposableBaseClass myClass = new MyDisposableBaseClass())
{
  // The code gets disposed automatically.
}

Gideon Engelberth wrote:

As an aside, you should not have a class finalizer (the ~A()) method unless you directly own an unmanaged resource such as a file handle stored as an IntPtr. The IDisposable classes you own as fields will have their own finalizer to take care of the unmanaged resources. Having unnecessary finalizers decreases the efficiency of the garbage collector.

GC.SuppressFinalize(this);

dojohansen wrote:

And since the class didn't implement IDisposable there is a higher probability that objects would not have been disposed.