When do I need to manage managed resources?

Question

I have been looking at the standard Dispose pattern and I'm just wondering what I need to write to free managed resources? If these resources are 'managed' already then surely I shouldn't need to do anything.

If that's the case, and my class doesn't hold any unmanaged resources (hence no need for it to be finalized by GC) then do I only need to suppress finalization in my Dispose method? :-

public void Dispose()
{
   GC.SuppressFinalize(this);
}

so suppose this is my class:

public sealed class MyClass : IDisposable
{
    IList<MyObject> objects; // MyObject doesn't hold any unmanaged resource
    private bool _disposed;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {
        if (!_disposed)
        {  
            // do I need to set the list to null and 
            // call Dispose on each item in the list?
            if (disposing)
            {
                foreach (var o in objects)
                    o.Dispose();

                objects = null;
            }
        }

        _disposed = true;
    }

    ~MyClass()
    {
        Dispose(false);
    }
}

Do I actually need to free the managed resources here?

Thanks,

Answer 1

If your class holds any IDisposable instances, you're using managed resources and thus you should implement IDisposable to allow users to dispose of the resources. Your Dispose method should call Dispose on the managed resources.

As for freeing managed memory, you don't need to do anything. That is handled by GC, but that is the only part of the cleanup that is handled by GC. Managed and unmanaged resources must be cleaned up by Dispose and/or finalizers.

If you don't use any managed or unmanaged resources, there is no need to implement neither IDisposable nor a finalizer. Implementing a finalizer will actually impact the performance of your type, so don't implement it unless you need it.

Answer 2

You should dispose any of the managed objects that implement IDisposable.

You won't be able to call Dispose on objects that don't implement IDisposable so you'll need to check for that. (Obviously, if all possible instances/descendants of MyObject will always implement IDisposable then you won't need that check.)

There's no need to set the list itself to null.

In the general case, I'd probably re-write the loop to look something like this:

if (disposing)
{
    foreach (var o in objects)
    {
        var d = o as IDisposable;
        if (d != null) d.Dispose();
    }
}

(By the way, if your class doesn't actually hold any IDisposable objects or unmanaged resources then you probably don't need to implement IDisposable, or a finaliser, at all.)