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.