Skip to main content

Garbage Collection and IDisposable

Short, interview-ready summary.

Memory hook​

"GC = reclaims heap objects with no references; IDisposable = release unmanaged or scarce resources explicitly"

Garbage collector (GC)​

  • Heap — reference types (objects) live here
  • GC — finds objects no longer referenced and reclaims memory
  • Non-deterministic — you don’t control when it runs
  • Generations — Gen0 (short-lived), Gen1, Gen2 (long-lived); Gen0 collected most often

What GC does not do​

  • It does not free unmanaged resources (handles, native memory, file descriptors)
  • It does not run at a predictable time

IDisposable and using​

"IDisposable = contract for releasing resources; using = call Dispose automatically"

public interface IDisposable
{
    void Dispose();
}

using statement (dispose at end of scope)​

using (var stream = File.OpenRead("file.txt"))
{
    // use stream
}  // Dispose() called here

// using declaration (C# 8+)
using var stream = File.OpenRead("file.txt");
// Dispose at end of enclosing scope

Implementing IDisposable (simple pattern)​

public class MyResource : IDisposable
{
    private bool _disposed;

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

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
        if (disposing)
        {
            // release managed resources
        }
        // release unmanaged resources
        _disposed = true;
    }
}
  • Dispose(bool disposing) — disposing true = from Dispose(); false = from finalizer (if any)
  • GC.SuppressFinalize(this) — skip finalizer when Dispose was called

Finalizer (destructor)​

~MyResource();
{
  Dispose(false);
}
  • Runs when GC collects the object (non-deterministic)
  • Use only as backup for unmanaged resources if caller didn’t call Dispose
  • Finalizers are expensive; prefer IDisposable + using

When to use IDisposable​

  • File handles, streams, DB connections
  • Native/unmanaged resources
  • Event subscriptions (to unsubscribe and avoid leaks)
  • Any scarce or unmanaged resource that must be released

Interview one-liner​

"GC reclaims unreferenced objects on the heap. For unmanaged or scarce resources, implement IDisposable and call Dispose (or use using). Finalizers are a fallback for unmanaged resources only; prefer Dispose + using."

Cheat sheet​

GC = heap, non-deterministic, generations
IDisposable = release resources
using = auto Dispose
Implement Dispose(bool); SuppressFinalize in Dispose
Finalizer = last resort for unmanaged