All 18 Memory & Garbage Collection questions
More in Memory & Garbage Collection
What is the difference between a finalizer and Dispose? How does the IDisposable pattern and the 'using' statement help manage UNMANAGED resources that the garbage collector doesn't automatically clean up? What is a memory leak in a garbage-collected language like C#, given that the GC handles cleanup automatically? What is boxing and unboxing, and why does it have a real performance cost? What causes managed memory leaks despite the GC? How do Span<T> and ArrayPool reduce GC pressure? How does the difference between the Server GC and Workstation GC modes affect a .NET application's throughput and latency characteristics? How would you use a memory profiler (or dotnet-counters / dotnet-gcdump) to diagnose excessive garbage collection pressure in a production .NET application? What is the Large Object Heap (LOH), and why do objects allocated there behave differently from regular small objects? How do WeakReference<T> objects work, and in what scenario would you use one instead of a normal strong reference?
Advertisement
C# › Memory & Garbage Collection

What is the difference between Dispose and Finalize in C#, and when should each actually be used?

Intermediate

Answer

Dispose (part of IDisposable) provides deterministic, explicit cleanup of unmanaged resources -- you call it yourself (typically via a using statement) as soon as you're done with an object, rather than waiting for garbage collection. Finalize (implemented via a destructor, ~ClassName()) is invoked automatically and non-deterministically by the garbage collector as a last-resort safety net before an object's memory is reclaimed, but finalizers add real overhead to GC (finalizable objects require an extra collection pass), so a class implementing IDisposable should call GC.SuppressFinalize(this) inside Dispose to skip the unnecessary finalizer call once cleanup has already happened deterministically.
public class ResourceHandler : IDisposable {
    public void Dispose() {
        Console.WriteLine("Dispose called - resources freed.");
        GC.SuppressFinalize(this); // skip the now-unnecessary finalizer
    }
    ~ResourceHandler() {
        Console.WriteLine("Finalizer called by GC - backup cleanup only.");
    }
}

using (var handler = new ResourceHandler()) {
    // use the resource
} // Dispose() is called automatically here, at a known, predictable point
Real-world example A database connection wrapper implements IDisposable so the connection is always closed deterministically at the end of a using block, while its finalizer exists purely as a safety net catching the rare case where a caller forgot to dispose it properly.

Common follow-ups: What happens to an object's finalizer if Dispose() is never called at all?;Why does the 'using' statement generate a try/finally block under the hood?

Error Handling;Garbage Collection
All 18 Memory & Garbage Collection questions