A: IAsyncEnumerable<T> (C# 8 / .NET Core 3.0) is the asynchronous counterpart to IEnumerable<T>. It enables pull-based, lazy, asynchronous iteration -- the consumer requests items one at a time, and each item can involve an await. This is critical for streaming data from databases, APIs, or files without buffering the entire result set into memory.

public interface IAsyncEnumerable<out T>
{
    IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken ct = default);
}

public interface IAsyncEnumerator<out T> : IAsyncDisposable
{
    T Current { get; }
    ValueTask<bool> MoveNextAsync();
}

Key details: MoveNextAsync() returns ValueTask<bool> (not Task<bool>) to avoid heap allocations when the result is synchronously available. The enumerator extends IAsyncDisposable so resources like database connections are properly cleaned up.

A: When a method is declared async, returns IAsyncEnumerable<T>, and contains yield return, the compiler generates a state machine that handles both await suspension (for I/O) and yield return suspension (to hand a value to the consumer).

public async IAsyncEnumerable<string> ReadLinesAsync(string path)
{
    using var reader = new StreamReader(path);
    string? line;
    while ((line = await reader.ReadLineAsync()) is not null)
    {
        yield return line; // suspends, hands line to caller
    }
}

// Consumption
await foreach (var line in ReadLinesAsync("huge-file.csv"))
{
    Process(line); // only one line in memory at a time
}

A: Yes. yield break terminates the sequence early. This is useful for applying limits or short-circuiting on a condition.

public async IAsyncEnumerable<Order> StreamUntilCutoff(
    IAsyncEnumerable<Order> source, DateTime cutoff)
{
    await foreach (var order in source)
    {
        if (order.CreatedAt > cutoff)
            yield break; // stop producing items

        yield return order;
    }
}

A: Task<IEnumerable<T>> buffers all results into memory before returning. The caller waits for the entire collection. IAsyncEnumerable<T> streams results one at a time -- the producer and consumer run in a push-pull rhythm. This means lower memory usage, faster time-to-first-item, and natural backpressure.

// Buffered: loads ALL orders into memory, then returns
public async Task<IEnumerable<Order>> GetAllOrdersBuffered()
{
    return await _dbContext.Orders.ToListAsync(); // entire table in RAM
}

// Streaming: yields one order at a time
public async IAsyncEnumerable<Order> GetAllOrdersStreaming()
{
    await foreach (var order in _dbContext.Orders.AsAsyncEnumerable())
    {
        yield return order; // one row at a time
    }
}

A: Apply [EnumeratorCancellation] to a CancellationToken parameter. The await foreach statement automatically passes its WithCancellation token to the enumerator. Inside the method, check the token or pass it to async calls.

public async IAsyncEnumerable<SensorReading> StreamReadingsAsync(
    string sensorId,
    [EnumeratorCancellation] CancellationToken ct = default)
{
    while (!ct.IsCancellationRequested)
    {
        var reading = await _sensorClient.ReadAsync(sensorId, ct);
        yield return reading;
        await Task.Delay(TimeSpan.FromSeconds(1), ct);
    }
}

// Caller passes cancellation via WithCancellation
using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5));
await foreach (var reading in StreamReadingsAsync("temp-01")
    .WithCancellation(cts.Token))
{
    Console.WriteLine(reading.Value);
}

A: The await foreach desugars to GetAsyncEnumerator(cancellationToken). The [EnumeratorCancellation] attribute tells the compiler to merge the token from WithCancellation() with the parameter so the iterator method receives it. Without it, the token passed via WithCancellation is ignored inside the method body.

A: Return IAsyncEnumerable<T> from a controller method. ASP.NET Core serializes items into the response as they arrive, flushing chunks over the wire. This keeps server memory flat even for large datasets.

[HttpGet("orders/stream")]
public async IAsyncEnumerable<OrderDto> StreamOrders(
    [EnumeratorCancellation] CancellationToken ct)
{
    await foreach (var order in _orderService.GetAllAsync(ct))
    {
        yield return _mapper.Map<OrderDto>(order);
    }
}

The response is serialized as a JSON array by System.Text.Json, with each element flushed as it becomes available. The HttpContext.RequestAborted token propagates into ct.

A: A hub method that returns IAsyncEnumerable<T> becomes a streaming endpoint. The client receives items as they are yielded.

public class StockHub : Hub
{
    public async IAsyncEnumerable<StockPrice> StreamPrices(
        string symbol,
        [EnumeratorCancellation] CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            yield return await _priceService.GetLatestAsync(symbol, ct);
            await Task.Delay(250, ct);
        }
    }
}

A: Channel<T> (from System.Threading.Channels) is a high-performance, thread-safe producer-consumer queue. It bridges producers and consumers that run at different speeds. A channel's Reader exposes ReadAllAsync() which returns IAsyncEnumerable<T>, making it composable with async stream patterns.

// Bounded channel: backpressure kicks in at capacity
var channel = Channel.CreateBounded<LogEntry>(new BoundedChannelOptions(1000)
{
    FullMode = BoundedChannelFullMode.Wait // producer waits when full
});

// Producer (e.g., request middleware)
await channel.Writer.WriteAsync(new LogEntry("Request received"), ct);

// Consumer (background service)
public class LogConsumer : BackgroundService
{
    private readonly ChannelReader<LogEntry> _reader;

    public LogConsumer(Channel<LogEntry> channel) => _reader = channel.Reader;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        await foreach (var entry in _reader.ReadAllAsync(ct))
        {
            await _sink.WriteAsync(entry);
        }
    }
}

A: Use bounded channels when the producer can outrun the consumer -- the capacity limit provides backpressure. Use unbounded channels when the producer rate is naturally constrained or you accept unbounded memory growth. In most real-world scenarios, bounded channels are safer.

A: Standard LINQ operators (Where, Select, Take, etc.) work on IEnumerable<T>. They do not work on IAsyncEnumerable<T>. The NuGet package System.Linq.Async provides async LINQ operators so you can compose async streams declaratively.

// NuGet: dotnet add package System.Linq.Async

var results = _repository.StreamOrdersAsync()
    .WhereAwait(async o => await _validator.IsValidAsync(o))
    .Select(o => new OrderDto(o.Id, o.Total))
    .Take(100);

await foreach (var dto in results)
{
    Console.WriteLine(dto);
}

Key operators: WhereAwait, SelectAwait (when the projection itself is async), Where, Select (for synchronous lambdas), Take, Skip, ToListAsync, FirstOrDefaultAsync, AnyAsync, CountAsync.

A: Backpressure is a mechanism where a slow consumer signals a fast producer to slow down, preventing memory exhaustion. IAsyncEnumerable<T> provides natural backpressure because the producer only runs when the consumer calls MoveNextAsync(). If the consumer is slow, the producer is idle.

With Channel<T>, backpressure is explicit: a bounded channel's WriteAsync blocks when the buffer is full, forcing the producer to wait.

// Natural backpressure: producer yields only when consumer asks
public async IAsyncEnumerable<DataChunk> ProduceAsync(
    [EnumeratorCancellation] CancellationToken ct = default)
{
    await foreach (var raw in _source.ReadAllAsync(ct))
    {
        var chunk = await TransformAsync(raw, ct); // only runs when consumer is ready
        yield return chunk;
    }
}

A: Use a bounded Channel<T> as a buffer between them. The producer writes at its own pace (up to the channel capacity), and the consumer reads at its own pace. When the channel is full, the producer awaits until space opens. This decouples the two without unbounded memory growth.

A: (1) Large database result sets -- stream rows without loading the entire table via EF Core's AsAsyncEnumerable(). (2) File processing -- read and process lines from multi-GB files one at a time. (3) API pagination -- fetch pages from an external API and yield items across page boundaries transparently. (4) gRPC server streaming -- gRPC uses IAsyncEnumerable<T> for server-streaming RPCs. (5) Real-time data feeds -- combine with Channel<T> to push market data, IoT telemetry, or log entries to consumers.

// Transparent pagination over an external API
public async IAsyncEnumerable<User> GetAllUsersAsync(
    [EnumeratorCancellation] CancellationToken ct = default)
{
    string? cursor = null;
    do
    {
        var page = await _httpClient.GetFromJsonAsync<PagedResult<User>>(
            $"/users?cursor={cursor}", ct);
        foreach (var user in page!.Items)
            yield return user;
        cursor = page.NextCursor;
    } while (cursor is not null);
}

A: Async streams reduce peak memory by avoiding full materialization. The ValueTask<bool> return from MoveNextAsync() avoids Task heap allocations in the common synchronous-completion case. However, there is per-element overhead from the state machine. For small collections (under ~100 items), Task<List<T>> can be faster due to fewer state transitions. For large or unbounded sequences, async streams win on memory and time-to-first-item.

A: Use ConfigureAwait(false) on the enumerable to avoid capturing the synchronization context on each iteration. This is important in library code.

await foreach (var item in StreamDataAsync().ConfigureAwait(false))
{
    Process(item); // runs on thread-pool thread, not original context
}

A: The compiler-generated state machine for an async iterator is allocated once on the heap. Each MoveNextAsync() call reuses the same object. The ValueTask<bool> avoids per-call Task allocations when the next item is immediately available. For hot paths, Channel<T> can outperform async iterators because its internal ring buffer is optimized for concurrent access with minimal allocations.