What is IEnumerable<T> really? Explain the IEnumerable/IEnumerator contract, how foreach is compiled (including the pattern-based GetEnumerator and struct enumerators), enumerator disposal, IAsyncEnumerable<T>, and when a method should accept or return IEnumerable<T>.

How I would answer this in an interview

IEnumerable<T> is a tiny contract: "I can give you an enumerator that walks a sequence forward, once." It promises nothing about count, indexing, repeatability, cost or whether data is in memory. I'd explain the IEnumerable/IEnumerator contract, how foreach is compiled (including pattern-based enumerators and struct enumerators), disposal, IAsyncEnumerable<T>, and API design guidance.

1. The contract

public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
}

public interface IEnumerator<out T> : IDisposable, IEnumerator
{
    T Current { get; }
    bool MoveNext();     // advance; false when finished
    void Reset();        // legacy; usually throws NotSupportedException
}

• Each call to GetEnumerator() should return a new, independent cursor.
• Current is valid only after MoveNext() returned true.
• Enumerators are disposable — iterators and database readers release resources in Dispose.
• An IEnumerable<T> may be a materialised collection, a lazy LINQ pipeline, an iterator method, a file reader (File.ReadLines) or a database query — the interface doesn't tell you.

2. How foreach is compiled

foreach (var order in orders) Process(order);

becomes:

var e = orders.GetEnumerator();
try
{
    while (e.MoveNext()) { var order = e.Current; Process(order); }
}
finally
{
    e?.Dispose();
}

Key details:

• Pattern-based: foreach doesn't require IEnumerable<T> — any type with an accessible GetEnumerator() returning a type with MoveNext() and Current works (and since C# 9, an extension GetEnumerator).
• Struct enumerators: List<T>, Dictionary<K,V>, HashSet<T>, ImmutableArray<T> expose public GetEnumerator() methods returning structs, so foreach over the concrete type allocates nothing and calls can be inlined. Through the IEnumerable<T> interface, the struct is boxed and calls become interface calls.
• Arrays and spans compile to for loops with no enumerator.
• Disposal happens in finally, so break/exceptions still run iterator finally blocks and close readers.
• Version checks in BCL collections throw if the collection is modified during enumeration.

3. IAsyncEnumerable<T>

public async IAsyncEnumerable<Order> StreamOrdersAsync([EnumeratorCancellation] CancellationToken ct = default)
{
    await foreach (var order in db.Orders.AsNoTracking().AsAsyncEnumerable().WithCancellation(ct))
        yield return order;
}

await foreach (var o in service.StreamOrdersAsync(ct)) { ... }

• MoveNextAsync() returns ValueTask<bool> so each step can await I/O without blocking.
• DisposeAsync() releases resources asynchronously.
• [EnumeratorCancellation] passes the token from WithCancellation into the iterator.
• Used for streaming database results, paging through APIs, gRPC streams, SignalR streams, and ASP.NET Core can stream IAsyncEnumerable<T> JSON responses.

4. When to accept IEnumerable<T>

Accept it when the method iterates once and needs nothing else — maximum flexibility for callers (lists, arrays, LINQ, iterators all work).

If the method needs Count, indexing, or iterates more than once, accept IReadOnlyCollection<T>/IReadOnlyList<T> instead — otherwise you risk multiple enumeration of a lazy/expensive source (CA1851).

5. When to return IEnumerable<T>

Return it when the result is genuinely lazy/streaming (iterator methods, pipelines) and document that. Return IReadOnlyList<T> (or IReadOnlyCollection<T>, arrays, immutable collections) for materialised results — callers then know it's cheap to count and re-iterate, and you avoid the "query escaped its DbContext" bug. Return IAsyncEnumerable<T> for async streaming.

6. A production example

A service method IEnumerable<Order> GetOrders() returned an EF query; a caller did if (orders.Any()), orders.Count(), then foreach — three database round trips — and a background job later enumerated it after the request scope ended (ObjectDisposedException). We changed the signature to Task<IReadOnlyList<OrderDto>> GetOrdersAsync(CancellationToken), materialising inside, and added an IAsyncEnumerable<OrderDto> StreamOrdersAsync for the export path. The types now told callers exactly what they were getting.