Backend

Core C# Study Portal

Language fundamentals, LINQ, async/await, records
Flash Cards Practice
Backend / Core C# / IDisposable Patterns

IDisposable Patterns

2 min read
Senior2 min read
Rapid overview

IDisposable Patterns

TL;DR

IDisposable is the .NET contract for releasing unmanaged resources (sockets, file handles, DB connections, timers) deterministically, paired with using/await using so cleanup runs even on exceptions. The senior-engineer details are calling GC.SuppressFinalize(this) to skip the finalizer cost, making Dispose idempotent, throwing ObjectDisposedException after disposal, and implementing IAsyncDisposable for resources that need to release asynchronously — leaks here mean exhausted sockets and outages.

How it works

  • Implement IDisposable when you own unmanaged resources (file handles, sockets, DB connections) or wrap disposables.
  • Pattern:
public sealed class PriceFeed : IDisposable
{
    private bool _disposed;
    private readonly Timer _timer;

    public PriceFeed()
    {
        _timer = new Timer(_ => PullAsync().GetAwaiter().GetResult());
    }

    public void Dispose()
    {
        if (_disposed) return;
        _timer.Dispose();
        _disposed = true;
        GC.SuppressFinalize(this);
    }
}
  • Usage: Wrap with using/await using so cleanup runs even on exceptions.
await using var connection = await _dbFactory.CreateConnectionAsync();

Quick recall Q&A

Q: When should a class implement IDisposable?

When it owns unmanaged resources or wraps objects that implement IDisposable (streams, DbContexts, timers) and must release them deterministically.

Q: Why call GC.SuppressFinalize(this)?

It prevents the GC from invoking the finalizer once you’ve disposed the object, saving an extra GC cycle and improving performance.

Q: How do you dispose async resources?

Implement IAsyncDisposable and use await using to asynchronously release resources like pooled connections or streams.

Q: What happens if you forget to dispose?

Resources leak—sockets stay open, file handles remain locked, and finalizers eventually run, adding GC pressure. In services, this can lead to outages.

Q: How do you handle multiple disposals safely?

Guard with an _disposed flag, throw ObjectDisposedException when methods run after disposal, and make Dispose idempotent.

Q: When do you need a finalizer?

Rarely—only when you wrap unmanaged resources without safe handles. Prefer SafeHandle + IDisposable instead of writing finalizers yourself.

Q: How do you dispose child services resolved from DI scopes?

The scope disposes services when it ends. Don’t capture scoped services beyond scope lifetime; create scopes per operation if needed.

Q: How do you unit test disposal behavior?

Use Mock<IDisposable> to verify Dispose is called, or check resource state (e.g., timer disposed). For async disposal, assert tasks complete and resources release handles.

Q: What’s the difference between DisposeAsync and Dispose?

DisposeAsync returns a ValueTask and awaits asynchronous cleanup. Dispose runs synchronously. Implement both when supporting async resource release but ensure Dispose calls DisposeAsync().GetAwaiter().GetResult() if needed.

Q: How does using translate in IL?

It compiles to a try/finally block where Dispose is invoked in the finally clause, guaranteeing cleanup even if exceptions occur.

See also