What’s the purpose of GC.SuppressFinalize(this) in Dispose() method?

by

When implementing the dispose pattern you might also add a finalizer to your class that calls Dispose(). This is to make sure that Dispose() always gets called, even if a client forgets to call it.

To prevent the dispose method from running twice (in case the object already has been disposed) you add GC.SuppressFinalize(this);. The documentation provides a sample:

class MyResource : IDisposable
{
    [...]

    // This destructor will run only if the Dispose method 
    // does not get called.
    ~MyResource()      
    {
        // Do not re-create Dispose clean-up code here.
        // Calling Dispose(false) is optimal in terms of
        // readability and maintainability.
        Dispose(false);
    }

    // Implement IDisposable.
    // Do not make this method virtual.
    // A derived class should not be able to override this method.
    public void Dispose()
    {
        Dispose(true);
        // This object will be cleaned up by the Dispose method.
        // Therefore, you should call GC.SupressFinalize to
        // take this object off the finalization queue 
        // and prevent finalization code for this object
        // from executing a second time.
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {
        // Check to see if Dispose has already been called.
        if(!this.disposed)
        {
            // If disposing equals true, dispose all managed 
            // and unmanaged resources.
            if(disposing)
            {
                // Dispose managed resources.
                component.Dispose();
            }

            // Call the appropriate methods to clean up 
            // unmanaged resources here.
            resource.Cleanup()          
        }
        disposed = true;         
    }
}

More Related Contents:

  1. When should I use GC.SuppressFinalize()?
  2. Proper use of the IDisposable interface
  3. Dispose, when is it called?
  4. Guidelines For Dispose() and Ninject
  5. Why should we call SuppressFinalize when we don’t have a destructor
  6. Understanding garbage collection in .NET
  7. Do event handlers stop garbage collection from occurring?
  8. Do you need to dispose of objects and set them to null?
  9. Best Practice for Forcing Garbage Collection in C#
  10. Implementing IDisposable correctly
  11. Memory Leak in C#
  12. .Net and Bitmap not automatically disposed by GC when there is no memory left
  13. What happens if i return before the end of using statement? Will the dispose be called?
  14. Monitoring Garbage Collector in C#
  15. Is correct to use GC.Collect(); GC.WaitForPendingFinalizers();?
  16. GC.Collect() and Finalize
  17. Implementing IDisposable on a subclass when the parent also implements IDisposable
  18. Can .NET Task instances go out of scope during run?
  19. What does Process.Dispose() actually do?
  20. What is IDisposable for?
  21. Timer, event and garbage collection : am I missing something?
  22. Who should call Dispose on IDisposable objects when passed into another object?
  23. MemoryStream.Close() or MemoryStream.Dispose()
  24. Does WeakReference make a good cache?
  25. Garbage Collection should have removed object but WeakReference.IsAlive still returning true
  26. How do I get .NET to garbage collect aggressively?
  27. Do I need to Dispose a SemaphoreSlim?
  28. Should we use “workstation” garbage collection or “server” garbage collection?
  29. Who Disposes of an IDisposable public property?
  30. Garbage Collection not happening even when needed

Leave a Comment