Why should we call SuppressFinalize when we don’t have a destructor

by

I’m going out on a limb here, but… most people don’t need the full-blown dispose pattern. It’s designed to be solid in the face of having direct access to unmanaged resources (usually via IntPtr) and in the face of inheritance. Most of the time, neither of these is actually required.

If you’re just holding a reference to something else which implements IDisposable, you almost certainly don’t need a finalizer – whatever holds the resource directly is responsible for dealing with that. You can make do with something like this:

public sealed class Foo : IDisposable
{
    private bool disposed;
    private FileStream stream;

    // Other code

    public void Dispose()
    {
        if (disposed)
        {
            return;
        }
        stream.Dispose();
        disposed = true;
    }
}

Note that this isn’t thread-safe, but that probably won’t be a problem.

By not having to worry about the possibility of subclasses holding resources directly, you don’t need to suppress the finalizer (because there isn’t one) – and you don’t need to provide a way of subclasses customising the disposal either. Life is simpler without inheritance.

If you do need to allow uncontrolled inheritance (i.e. you’re not willing to bet that subclasses will have very particular needs) then you need to go for the full pattern.

Note that with SafeHandle from .NET 2.0, it’s even rarer that you need your own finalizer than it was in .NET 1.1.

To address your point about why there’s a disposing flag in the first place: if you’re running within a finalizer, other objects you refer to may already have been finalized. You should let them clean up themselves, and you should only clean up the resources you directly own.

More Related Contents:

  1. GC.Collect() and Finalize
  2. When should I use GC.SuppressFinalize()?
  3. What’s the purpose of GC.SuppressFinalize(this) in Dispose() method?
  4. Proper use of the IDisposable interface
  5. Understanding garbage collection in .NET
  6. Use of Finalize/Dispose method in C#
  7. Do event handlers stop garbage collection from occurring?
  8. When is it acceptable to call GC.Collect?
  9. Do you need to dispose of objects and set them to null?
  10. Best Practice for Forcing Garbage Collection in C#
  11. Implementing IDisposable correctly
  12. Memory Leak in C#
  13. Dispose, when is it called?
  14. .Net and Bitmap not automatically disposed by GC when there is no memory left
  15. Does garbage collector call Dispose()? [duplicate]
  16. GC.Collect()
  17. Monitoring Garbage Collector in C#
  18. How can I write a unit test to determine whether an object can be garbage collected?
  19. Is correct to use GC.Collect(); GC.WaitForPendingFinalizers();?
  20. Can .NET Task instances go out of scope during run?
  21. Timer, event and garbage collection : am I missing something?
  22. GC.Collect() not collecting immediately?
  23. MemoryStream.Close() or MemoryStream.Dispose()
  24. Guidelines For Dispose() and Ninject
  25. Does WeakReference make a good cache?
  26. How does garbage collection and scoping work in C#? [duplicate]
  27. Garbage Collection should have removed object but WeakReference.IsAlive still returning true
  28. How do I get .NET to garbage collect aggressively?
  29. Should we use “workstation” garbage collection or “server” garbage collection?
  30. Garbage Collection not happening even when needed

Leave a Comment