Async Streams in C# Made Easy (IAsyncEnumerable Guide)

Are you still struggling with async/await when working with data streams in .NET? What if I told you there’s a smoother way to handle asynchronous data in C# that feels just like foreach? Yep, that tool is called IAsyncEnumerable, and once you master it, you might never look back.

Background: Asynchronous Programming in C#

In .NET, asynchronous programming is built around async and await, providing a more readable way to write non-blocking code. Before IAsyncEnumerable, handling a stream of asynchronous data required workarounds like buffering items into a list or using reactive extensions.

But starting with C# 8.0, we now have native support for asynchronous streams through IAsyncEnumerable<T> and await foreach. This simplifies many data-driven and event-driven scenarios, especially when working with I/O-bound operations.

Understanding IAsyncEnumerable

IAsyncEnumerable<T> is like IEnumerable<T>, but for asynchronous streams. It allows you to await each item as it’s received, making it ideal for processing data that comes in gradually.

Here’s the magic syntax:

await foreach (var item in GetDataAsync())
{
    Console.WriteLine(item);
}

What’s happening here? GetDataAsync() returns an IAsyncEnumerable<T>, and C#’s compiler handles the rest, asynchronously iterating over the results.

Basic Usage and Syntax

Let’s start with a simple example:

public async IAsyncEnumerable<int> GetNumbersAsync()
{
    for (int i = 1; i <= 5; i++)
    {
        await Task.Delay(500); // Simulate async operation
        yield return i;
    }
}

And consuming it:

await foreach (var number in GetNumbersAsync())
{
    Console.WriteLine(number);
}

Explanation: The yield return lets us stream data, and the await Task.Delay simulates an asynchronous operation (e.g., network delay). The caller can process each item as it arrives without waiting for the whole sequence.

Advanced Scenarios and Techniques

Filtering with Where and LINQ

await foreach (var even in GetNumbersAsync().Where(n => n % 2 == 0))
{
    Console.WriteLine($"Even: {even}");
}

This uses System.Linq.Async (from the System.Interactive.Async NuGet package).

Cancellation Support

public async IAsyncEnumerable<int> GetNumbersAsync([EnumeratorCancellation] CancellationToken token)
{
    for (int i = 0; i < 10; i++)
    {
        token.ThrowIfCancellationRequested();
        await Task.Delay(1000, token);
        yield return i;
    }
}

Now you can cancel the stream with a CancellationToken.

Reading from APIs or Databases

public async IAsyncEnumerable<string> ReadLinesAsync(string path)
{
    using var reader = new StreamReader(path);
    while (!reader.EndOfStream)
    {
        yield return await reader.ReadLineAsync();
    }
}

Streaming lines from a file becomes elegant with async streams.

Best Practices and Pitfalls

• Avoid eager execution: Don’t ToListAsync() unless you must. It defeats the purpose of streaming.
• Always handle exceptions: Wrap your await foreach in try-catch if your producer might throw.
• Don’t block: Never call .Result or .Wait() inside an async enumerator. That’s a deadlock waiting to happen.
• Use proper cancellation: Always support CancellationToken in your async enumerators.

FAQ: Common questions about async stream usage

Conclusion: Embrace the Stream, Not the Wait

Async streams with IAsyncEnumerable offer a cleaner, scalable approach to asynchronous iteration in .NET. Whether you’re reading lines from a file, consuming paginated APIs, or reacting to live events, this tool brings clarity and performance to your code.

So next time you’re tempted to buffer results into a list, stop and ask: “Can this be an async stream instead?” Chances are, it can—and it should.