Write a C# method that splits a sequence into batches of a fixed size.

• Null items return an empty list.
• batchSize must be positive.
• Preserve original item order.
• Do not drop the final partial batch.

I would validate batch size, then accumulate items into a current list. When the current list reaches batch size, I add it to the result and start a new list. After the loop, I add the current list if it has any items. I would mention that modern .NET has Enumerable.Chunk, but implementing it shows the edge cases clearly.

public static IReadOnlyList<IReadOnlyList<T>> ChunkItems<T>(
    IEnumerable<T>? items,
    int batchSize)
{
    if (batchSize <= 0)
    {
        throw new ArgumentOutOfRangeException(nameof(batchSize));
    }

    if (items is null)
    {
        return Array.Empty<IReadOnlyList<T>>();
    }

    var result = new List<IReadOnlyList<T>>();
    var current = new List<T>(batchSize);

    foreach (var item in items)
    {
        current.Add(item);
        if (current.Count == batchSize)
        {
            result.Add(current);
            current = new List<T>(batchSize);
        }
    }

    if (current.Count > 0)
    {
        result.Add(current);
    }

    return result;
}

The method is O(n) time and O(n) space for the returned batches. A streaming iterator version can reduce peak memory if the caller can consume batches lazily.

• Null input.
• Empty input.
• Batch size 1.
• Input count exactly divisible by batch size.
• Final partial batch.

• Use 5 items with batch size 2 to catch final partial batch.
• Use exact multiples to avoid adding an empty final batch.
• Use invalid batch size to confirm validation.

• Dropping the final partial batch.
• Adding an empty batch at the end.
• Not preserving order.
• Forgetting .NET already has Enumerable.Chunk for production code.