IDisposable and using

Memory isn't the only resource

The GC frees memory — eventually. But programs also hold resources that are scarce and that other code is waiting for:

• open files (others can't write to them while you hold them),
• network sockets and HTTP connections,
• database connections (a pool might allow only 100),
• locks, timers, native memory, GPU buffers…

You can't wait for a garbage collection that might happen in a minute — you need to release these right when you're done. .NET's convention for that is the IDisposable interface:

public interface IDisposable
{
    void Dispose();
}

Any type holding such a resource implements it: FileStream, StreamReader, HttpClient, SqlConnection, DbContext, Timer…

using: dispose automatically

Calling Dispose() manually is error-prone — an exception could skip it. The using statement guarantees it:

using (var reader = new StreamReader("data.txt"))
{
    Console.WriteLine(reader.ReadLine());
}   // reader.Dispose() runs here, even if ReadLine threw

The compiler turns it into:

var reader = new StreamReader("data.txt");
try
{
    Console.WriteLine(reader.ReadLine());
}
finally
{
    reader?.Dispose();
}

The shorter using declaration disposes at the end of the enclosing scope (usually the method):

void Import()
{
    using var file = File.OpenRead("orders.csv");
    using var reader = new StreamReader(file);
    // ... work with reader ...
}   // reader disposed first, then file — reverse order of declaration

Implementing IDisposable

If your class owns something disposable (or a native resource), it should be disposable too:

public sealed class ReportWriter : IDisposable
{
    private readonly StreamWriter writer;
    private bool disposed;
 
    public ReportWriter(string path) => writer = new StreamWriter(path);
 
    public void WriteLine(string text)
    {
        ObjectDisposedException.ThrowIf(disposed, this);   // using a disposed object is a bug
        writer.WriteLine(text);
    }
 
    public void Dispose()
    {
        if (disposed) return;        // Dispose must be safe to call more than once
        disposed = true;
        writer.Dispose();            // dispose what you own
    }
}

Rules of thumb:

• Dispose what you own, not what was given to you (if a stream is passed into your constructor, the caller usually owns it).
• Dispose must be idempotent — calling it twice is harmless.
• After disposal, other methods should throw ObjectDisposedException.
• The full "dispose pattern" with Dispose(bool) and a finalizer is only needed for classes that directly hold unmanaged handles — rare in application code.

Async disposal

Some resources flush data or close connections asynchronously. They implement IAsyncDisposable, used with await using:

await using var db = new ShopDbContext();
var orders = await db.Orders.ToListAsync();

Key takeaways

• Scarce resources (files, connections, sockets) must be released deterministically — that's IDisposable.
• using statements and declarations call Dispose even when exceptions occur, in reverse order.
• Implement IDisposable when your class owns disposable things; make Dispose idempotent.
• Use await using for IAsyncDisposable types.