How do you implement IDisposable correctly, and who is responsible for disposing an object?

1. What using compiles to

using (var w = new ReportWriter(path)) { w.Write("x"); }

is lowered to:

var w = new ReportWriter(path);
try { w.Write("x"); }
finally { if (w != null) ((IDisposable)w).Dispose(); }

For a struct disposable the compiler calls Dispose without boxing (constrained call). Pattern-based disposal also works for ref struct types with a public Dispose() method.

2. Why Dispose(bool) exists

Two callers, two contracts:

With SafeHandle, you almost never write a finaliser, so sealed classes don't need the bool at all.

3. Inheritance done right

public class Repository : IDisposable
{
    private readonly DbConnection _connection;
    private int _disposed;

    public Repository(DbConnection connection) => _connection = connection; // owns by contract

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

    protected virtual void Dispose(bool disposing)
    {
        if (Interlocked.Exchange(ref _disposed, 1) == 1) return;
        if (disposing) _connection.Dispose();
    }
}

public sealed class CachingRepository : Repository
{
    private readonly MemoryCache _cache = new(new MemoryCacheOptions());
    private bool _disposed;

    public CachingRepository(DbConnection c) : base(c) { }

    protected override void Dispose(bool disposing)
    {
        if (_disposed) return;
        _disposed = true;
        try { if (disposing) _cache.Dispose(); }
        finally { base.Dispose(disposing); }   // base cleanup always runs
    }
}

4. Constructor that acquires several resources

public sealed class Exporter : IDisposable
{
    private readonly FileStream _file;
    private readonly GZipStream _zip;

    public Exporter(string path)
    {
        _file = File.Create(path);
        try
        {
            _zip = new GZipStream(_file, CompressionLevel.Fastest, leaveOpen: true);
        }
        catch
        {
            _file.Dispose();   // nobody else can dispose it: the object was never returned
            throw;
        }
    }

    public void Dispose()
    {
        _zip.Dispose();
        _file.Dispose();
    }
}

5. How the DI container tracks disposables

Microsoft.Extensions.DependencyInjection keeps a list of disposables per scope (and one for the root). Every IDisposable/IAsyncDisposable instance it creates is added to the list of the scope it was resolved from, regardless of which interface you registered it under. Disposing the scope disposes them in reverse order of creation.

Consequences:

• A transient disposable resolved from the root stays in the root list until shutdown.
• Scoped services resolved from the root (with validation off) effectively become singletons.
• If only IAsyncDisposable is implemented, disposing the scope synchronously throws; use DisposeAsync/CreateAsyncScope (see the IAsyncDisposable question).

6. Disposable types with special rules

7. Version notes

8. Try it yourself

1. Run the code example and call WriteLine after Dispose to see ObjectDisposedException.
2. Register a transient disposable, resolve it 10,000 times from the root provider, take a gcdump and find what roots the instances.
3. Repeat with a scope per resolution and confirm instances are collected.
4. Enable dotnet_diagnostic.CA2000.severity = error and CA2213 in .editorconfig; remove a using and see the build fail.
5. Write a base class with Dispose(bool) and a derived class; verify the base cleanup runs even when the derived cleanup throws.
6. Register an instance with AddSingleton(instance) and confirm the container does not dispose it at shutdown.

using Microsoft.Extensions.DependencyInjection;

// Sealed: the simple form is enough
public sealed class ReportWriter : IDisposable
{
    private readonly StreamWriter _writer;
    private bool _disposed;

    public ReportWriter(string path) => _writer = new StreamWriter(path);

    public void WriteLine(string line)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        _writer.WriteLine(line);
    }

    public void Dispose()
    {
        if (_disposed) return;      // idempotent
        _disposed = true;
        _writer.Dispose();          // dispose what we own
    }
}

// Unsealed: full pattern so derived classes can add cleanup
public class Repository : IDisposable
{
    private readonly System.Data.Common.DbConnection _connection;
    private int _disposed;

    public Repository(System.Data.Common.DbConnection connection) => _connection = connection; // we own it by contract

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

    protected virtual void Dispose(bool disposing)
    {
        if (Interlocked.Exchange(ref _disposed, 1) == 1) return;   // thread-safe idempotency
        if (disposing) _connection.Dispose();
    }
}

public static class Jobs
{
    // Correct: resolve per-run services from a scope that is disposed
    public static async Task RunOnceAsync(IServiceProvider root)
    {
        await using AsyncServiceScope scope = root.CreateAsyncScope();
        var writer = scope.ServiceProvider.GetRequiredService<ReportWriter>();
        writer.WriteLine($"Run at {DateTimeOffset.UtcNow:O}");
    } // writer is disposed with the scope
}