How does the using statement work in C#, and what are the common bugs with using declarations, deferred execution and exceptions?

1. Iterators own their using correctly

// BUG: the reader is disposed when this method returns, before enumeration
static IEnumerable<string> PaidLazy(string path)
{
    using var reader = new StreamReader(path);
    return ReadLines(reader).Where(l => l.EndsWith(",Paid"));
}

// OK: the whole method is an iterator, so the using lives inside the state machine
static IEnumerable<string> PaidStreaming(string path)
{
    using var reader = new StreamReader(path);
    while (reader.ReadLine() is { } line)
        if (line.EndsWith(",Paid")) yield return line;
}

In the iterator version, the compiler moves the using into the generated enumerator. The file opens on the first MoveNext() and is disposed when enumeration completes or when the enumerator is disposed (which foreach and LINQ operators like First() do). Two consequences:

• If nobody enumerates, the file is never opened.
• If someone calls GetEnumerator()/MoveNext() manually and never disposes the enumerator, the file leaks until finalisation.

The async version works the same way:

public async IAsyncEnumerable<Order> StreamOrdersAsync([EnumeratorCancellation] CancellationToken ct = default)
{
    await using var conn = new SqlConnection(_cs);
    await conn.OpenAsync(ct);
    await foreach (var o in conn.QueryUnbufferedAsync<Order>("select * from Orders").WithCancellation(ct))
        yield return o;
}

2. Exception masking in detail

using (var tx = new ThrowingOnDispose())
{
    throw new InvalidOperationException("real problem");
}
// What propagates: the exception thrown by Dispose. "real problem" is lost.

In C#, an exception thrown from a finally block replaces the one in flight. That's why Dispose should not throw, and why APIs like transactions expose an explicit Commit()/CompleteAsync() that can fail loudly, while Dispose just rolls back quietly.

3. Disposal order and dependent resources

using var file = File.Create("out.gz");
using var zip = new GZipStream(file, CompressionLevel.Optimal);
using var writer = new StreamWriter(zip);
writer.Write("data");
// Disposed: writer (flush) → zip (write footer) → file (close)

If the order were reversed, the zip footer would be written to a closed file and the archive would be corrupt.

4. await using and ConfigureAwait

ConfigureAwait(false) on an IAsyncDisposable returns a ConfiguredAsyncDisposable wrapper, which await using accepts. Because the wrapper is not the resource, declare the resource first:

var stream = File.OpenWrite(path);
await using (stream.ConfigureAwait(false))
{
    await stream.WriteAsync(data).ConfigureAwait(false);
}

// Declaration form:
var file = File.OpenWrite(path);
await using var _ = file.ConfigureAwait(false);
await file.WriteAsync(data).ConfigureAwait(false);

Writing await using (var s = stream.ConfigureAwait(false)) compiles, but s is the wrapper, not the stream. This matters mainly in library code; ASP.NET Core has no synchronisation context.

5. Pattern-based disposal for ref struct

Before C# 13, ref struct types couldn't implement interfaces, so C# 8 allowed using with any accessible void Dispose() on a ref struct. This is used by stack-based builders that rent buffers:

ref struct PooledBuffer
{
    private byte[]? _array;
    public PooledBuffer(int size) => _array = ArrayPool<byte>.Shared.Rent(size);
    public Span<byte> Span => _array;
    public void Dispose() { if (_array is { } a) { _array = null; ArrayPool<byte>.Shared.Return(a); } }
}

using var buf = new PooledBuffer(4096);

6. Pool-friendly scoping

int count;
using (var conn = await _factory.OpenAsync(ct))
{
    count = await conn.ExecuteScalarAsync<int>("select count(*) from Orders");
} // connection returned to the pool here

await _emailClient.SendReportAsync(count, ct); // slow, no connection held

With using var at the top, the connection would be held during the email call; under load that can exhaust the pool (Max Pool Size) and cause timeouts.

7. Version notes

8. Try it yourself

1. Run the code example: the lazy version throws ObjectDisposedException; the materialised version works.
2. Rewrite PaidOrdersLazy as an iterator (yield return) and confirm it works and disposes when the foreach ends.
3. Write a type whose Dispose throws and put it in a using around code that throws; observe which exception you catch.
4. Reverse the order of GZipStream/FileStream disposal manually and try to open the resulting .gz.
5. Set Max Pool Size=5 on a SQL connection string, use using var at the top of a method with Task.Delay(2000) after the query, and run 20 concurrent calls; then narrow the scope and compare.
6. Call GetEnumerator()/MoveNext() on the iterator version without disposing and check whether the file stays locked.

File.WriteAllLines("orders.txt", ["1,Paid", "2,Pending", "3,Paid"]);

try
{
    foreach (string line in PaidOrdersLazy("orders.txt")) Console.WriteLine(line);
}
catch (ObjectDisposedException ex)
{
    Console.WriteLine($"Bug: {ex.GetType().Name} - the reader was disposed before enumeration");
}

foreach (string line in PaidOrders("orders.txt")) Console.WriteLine($"Fixed: {line}");

// BUG: query is deferred; the reader is disposed when the method returns
static IEnumerable<string> PaidOrdersLazy(string path)
{
    using var reader = new StreamReader(path);
    return ReadLines(reader).Where(l => l.EndsWith(",Paid"));
}

// FIX: materialise inside the scope (or make the whole method an iterator)
static List<string> PaidOrders(string path)
{
    using var reader = new StreamReader(path);
    return ReadLines(reader).Where(l => l.EndsWith(",Paid")).ToList();
}

static IEnumerable<string> ReadLines(StreamReader reader)
{
    while (reader.ReadLine() is { } line) yield return line;
}

// Narrow scope: release the pooled resource before slow work
static async Task<int> CountThenProcessAsync(string path)
{
    int count;
    using (var reader = new StreamReader(path))
    {
        count = 0;
        while (await reader.ReadLineAsync() is not null) count++;
    }                                   // file closed here
    await Task.Delay(100);              // slow work without holding the file open
    return count;
}