using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

​

public static class Program

{

    public static void Main()

    {

        static IEnumerable<int> Produce()

        {

            int i = 0;

            while (true)

            {

                i++;

                Console.WriteLine($"Producing #{i}");

                yield return i;

                if (i == 15) throw new Exception("Oops!");

            }

        }

​

        foreach (int[] chunk in Produce().ChunkNonDestructive(10))

        {

            Console.WriteLine($"Consumed: [{String.Join(", ", chunk)}]");

        }

    }

​

    private static IEnumerable<TOutput> DeferErrorUntilCompletion<TInput, TOutput>(

        IEnumerable<TInput> input,

        Func<IEnumerable<TInput>, IEnumerable<TOutput>> conversion)

    {

        Task errorContainer = null;

        IEnumerable<TInput> InputIterator()

        {

            using var enumerator = input.GetEnumerator();

            while (true)

            {

                TInput item;

                try

                {

                    if (!enumerator.MoveNext()) break;

                    item = enumerator.Current;

                }

                catch (Exception ex)

                {

                    errorContainer = Task.FromException(ex);

                    break;

                }

                yield return item;

            }

        }

        IEnumerable<TOutput> output = conversion(InputIterator());

        foreach (TOutput item in output) yield return item;

        errorContainer?.GetAwaiter().GetResult();

    }

​

    /// <summary>

    /// Splits the elements of a sequence into chunks of the specified size.

    /// In case the sequence fails and there are buffered elements, a last chunk

    /// that contains these elements is emited before propagating the error.

    /// </summary>

    public static IEnumerable<TSource[]> ChunkNonDestructive<TSource>(

        this IEnumerable<TSource> source, int size)

    {

        ArgumentNullException.ThrowIfNull(source);

        if (size < 1) throw new ArgumentOutOfRangeException(nameof(size));

        return DeferErrorUntilCompletion(source, s => s.Chunk(size));

    }

}