using System;

using System.Collections.Generic;

using System.Threading;

using System.Threading.Tasks;

public static class Program

{

    public static async Task Main()

    {

        Print($"Starting");

        //foreach (string s in BlockingIterator())

        await foreach (string s in BlockingIterator().OffloadEnumerationAsync())

        {

            Print($"--Received: {s}");

            Thread.Sleep(50);

        }

        Print($"Finished");

    }

​

    private static IEnumerable<string> BlockingIterator()

    {

        for (int i = 1; i <= 10; i++)

        {

            Thread.Sleep(100);

            Print($"Producing: {i}");

            yield return i.ToString();

        }

    }

​

    /// <summary>

    /// Offloads the enumeration of the sequence to the ThreadPool.

    /// Each element is yielded concurrently with fetching the sequence's next element.

    /// </summary>

    public static async IAsyncEnumerable<T> OffloadEnumerationAsync<T>(

        this IEnumerable<T> source)

    {

        ArgumentNullException.ThrowIfNull(source);

        IEnumerator<T> enumerator = await Task.Run(

            () => source.GetEnumerator()).ConfigureAwait(false);

        (T Value, bool HasValue) item = default;

        try

        {

            while (true)

            {

                Task<(T, bool)> moveTask = Task.Run(() =>

                {

                    bool moved = enumerator.MoveNext();

                    if (moved) return (enumerator.Current, true);

                    return default;

                });

                if (item.HasValue)

                {

                    bool yieldOK = false;

                    try { yield return item.Value; yieldOK = true; }

                    finally

                    {

                        // Prevent fire-and-forget in case the consumer stopped enumerating.

                        if (!yieldOK) try { await moveTask.ConfigureAwait(false); } catch { }

                    }

                }

                item = await moveTask.ConfigureAwait(false);

                if (!item.HasValue) break;

            }

        }

        finally { await Task.Run(() => enumerator?.Dispose()).ConfigureAwait(false); }

    }

​

    private static void Print(object value)

    {

        Console.WriteLine($@"{DateTime.Now:HH:mm:ss.fff} [{Thread.CurrentThread

            .ManagedThreadId}] > {value}");

    }

}

​