IAsyncEnumerable is a strong function launched in C# 8.0 that enables us to work with a sequence of information asynchronously. Because the title suggests, IAsyncEnumerable is the asynchronous counterpart of IEnumerable, the interface that enables us to simply iterate by the weather of a group.

Apparently, the IAsyncEnumerable interface works on a pull-based method, the place the following merchandise will both be created or retrieved when requested by the patron. Not like IEnumerable, which waits for the following factor to be created, IAsyncEnumerable returns an awaitable that may be resumed later.

On this article, we’ll study how we will use the IAsyncEnumerable interface in C# to work with asynchronous streams of information. 

Create a console utility venture in Visible Studio

First off, let’s create a .NET Core console utility venture in Visible Studio. Assuming Visible Studio 2022 is put in in your system, observe the steps outlined under to create a brand new .NET Core console utility venture in Visible Studio.

1. Launch the Visible Studio IDE.
2. Click on on “Create new venture.”
3. Within the “Create new venture” window, choose “Console App (.NET Core)” from the record of templates displayed.
4. Click on Subsequent.
5. Within the “Configure your new venture” window, specify the title and site for the brand new venture.
6. Click on Subsequent.
7. Within the “Further info” window proven subsequent, select “.NET 7.0 (Normal Time period Help)” because the Framework model you want to use.
8. Click on Create.

We’ll use this .NET 7 console utility venture to work with the code examples proven within the subsequent sections of this text.

IAsyncEnumerable advantages

The important thing advantages of IAsyncEnumerable embody the next:

• Help for asynchronous streaming: A standard assortment like a listing or IEnumerable requires that every one parts be accessible prematurely. IAsyncEnumerable, alternatively, streams objects as they turn into accessible. Utilizing IAsyncEnumerable is very useful when coping with massive knowledge units or real-time knowledge streams the place all knowledge is probably not accessible prematurely. With IAsyncEnumerable, you can begin processing objects instantly with out having to attend for the info set to be loaded in its entirety. When working with real-time knowledge feeds equivalent to inventory quotes or social media updates, the place new info is continually being generated and must be processed as quickly as it’s accessible, this flexibility is helpful.
• Environment friendly use of obtainable sources: IAsyncEnumerable permits you to work with massive sequences of information in an asynchronous method, which ensures that worthwhile computing sources are usually not wasted.
• Enhanced efficiency: IAsyncEnumerable can enhance your utility’s efficiency by eliminating the necessity to load all the info at one go. Consequently, the system can use much less reminiscence and release sources. 
• Improved responsiveness: With IAsyncEnumerable, you possibly can simply write code that handles massive streams of information responsively. You may as well use sources extra effectively and enhance general utility efficiency, in order that your utility stays responsive even when working with massive knowledge units. 
• Easier code: IAsyncEnumerable simplifies code by eliminating complicated synchronization mechanisms equivalent to locks and semaphores thus decreasing the chance of deadlocks and different synchronization-related points in your utility.

Within the following part we’ll study just a few superior operations you possibly can carry out on asynchronous sequences of information utilizing IAsyncEnumerable.

Filtering with IAsyncEnumerable

The next code snippet illustrate how one can filter an asynchronous sequence of information to retrieve solely the even numbers.

public async IAsyncEnumerable<int> GetEvenNumbersAsync(IEnumerable<int> integers)
{
    foreach (var n in integers)
    {
        await Job.Delay(500);
        if (n % 2 == 0)
        {
            yield return n;
        }
    }
}

Aggregating with IAsyncEnumerable

The next code snippet illustrates how one can reap the benefits of IAsyncEnumerable to calculate the sum of integers in an asynchronous sequence of numbers.

public async Job<int> GetSumAsync(IEnumerable<int> integers)
{
    int sum = 0;
        await foreach (var n in GetNumbersAsync(integers))
    {
        sum += n;
    }
        return sum;
}

Asynchronous projection with IAsyncEnumerable

The next code snippet exhibits how you need to use projections with IAsyncEnumerable.

public async IAsyncEnumerable<int> GetNumbersUsingProjectionAsync(IEnumerable<int> integers)
{
    foreach (var n in integers)
    {
        await Job.Delay(500);
        yield return await Job.Run(() => n * 10);
    }
}

Remodeling a sequence with IAsyncEnumerable

The next code snippet exhibits how one can reap the benefits of IAsyncEnumerable to remodel a sequence of numbers and yield the reworked values.

public async IAsyncEnumerable<string> TransformNumbersAsync(IEnumerable<int> integers)
{
    foreach (var n in integers)
    {
        await Job.Delay(500);
        yield return n.ToString();
    }
}

Batch processing with IAsyncEnumerable

Other than fetching objects one by one, it’s also possible to course of objects in batches when working with IAsyncEnumerable. That is proven within the code snippet given under.

public static async IAsyncEnumerable<IEnumerable<T>> ProcessBatch<T>(IAsyncEnumerable<T> supply, int measurement,
    CancellationToken cancellationToken = default)
{
    var batch = new Listing<T>();
    await foreach (var merchandise in supply)
    {
        if (cancellationToken.IsCancellationRequested)
            yield break;
        batch.Add(merchandise);
        if (batch.Rely >= measurement)
        {
            yield return batch;
            batch = new Listing<T>();
        }
    }
    if (batch.Rely > 0)
    {
        yield return batch;
    }
}

Buffering with IAsyncEnumerable

You may as well reap the benefits of buffering for higher efficiency in processing objects asynchronously.

public static async IAsyncEnumerable<T> ProcessBuffer<T>(this IAsyncEnumerable<T> supply, int measurement,
    CancellationToken cancellationToken = default)
    {
        var queue = new Queue<T>();
        await foreach (var merchandise in supply)
        {
            if (cancellationToken.IsCancellationRequested)
                yield break;
            queue.Enqueue(merchandise);
            whereas (queue.Rely >= measurement)
            {
                yield return queue.Dequeue();
            }
        }
        whereas (queue.Rely > 0)
        {
            yield return queue.Dequeue();
        }
    }

Conclusion

As we’ve seen, IAsyncEnumеrablе providеs sеvеral powеrful fеaturеs that may bе appliеd to asynchronous sеquеncеs. Moreover, you need to use IAsyncEnumerable with LINQ operators to carry out numerous operations that embody however are usually not restricted to filtering, remodeling, and aggregating massive knowledge units. You may as well deal with runtime errors that may happen while you’re working with IAsyncEnumerable, and you’ll reap the benefits of retries and implement logging to deal with such errors gracefully.