C#

BillWoodruff wrote:

Perhaps it is the case that transforming the IEnumerable to a List<T;> is a good thing to do, if it needs to be evaluated more than once.

BillWoodruff wrote:

Perhaps it is the case that transforming the IEnumerable to a List<T;> is a good thing to do, if it needs to be evaluated more than once.

PIEBALDconsult wrote:

it is clear that you (Bill) do not want an IEnumerable at all for the method presented.

Jörgen Andersson wrote:

would consume

public static IEnumerable<KeyValuePair<T1, List<T1>>> ToChunkedKvPList<T1>(this IEnumerable<T1> source, int chunksz)
{
    if (source == null) throw new ArgumentNullException("source");
    if (chunksz <= 0) throw new ArgumentOutOfRangeException("chunksz", "The chunk size must be greater than 0.");
    
    // The iterator method should be separate from the argument validation,
    // so that the exceptions are throw when the method is called,
    // rather than when the returned sequence is iterated.
    
    return ToChunkedKvPListIterator(source, chunksz);
}

private static IEnumerable<KeyValuePair<T1, List<T1>>> ToChunkedKvPListIterator<T1>(IEnumerable<T1> source, int chunksz)
{
    int currentChunkSize = 0;
    T1 currentHeader = default(T1);
    var currentChunk = new List<T1>(chunksz);
    
    foreach (T1 item in source)
    {
        if (currentChunkSize == 0)
        {
            currentHeader = item;
        }
        else
        {
            currentChunk.Add(item);
        }
        
        currentChunkSize++;
        
        if (currentChunkSize == chunksz)
        {
            yield return new KeyValuePair<T1, List<T1>>(currentHeader, currentChunk);
            
            currentChunkSize = 0;
            currentHeader = default(T1);
            currentChunk = new List<T1>(chunksz);
        }
    }
    
    if (currentChunkSize != 0)
    {
        // We have a partial chunk left over:
        yield return new KeyValuePair<T1, List<T1>>(currentHeader, currentChunk);
    }
}

IEnumerable<int> AskDeepThought()
{
    while (true)
    {
        yield return 42;
    }
}

var answers = AskDeepThought().ToChunkedKvPList().Take(42);
// If ToChunkedKvPList uses Count(), this will never return.

BillWoodruff wrote:

pending eye-surgery

BillWoodruff wrote:

modified closures

BillWoodruff wrote:

an IEnumerable that was not "sequence deterministic"

using (var bc = new BlockingCollection<int>())
{
    Task.Run(() =>
    {
        for (int i = 0; i < 10; i++)
        {
            bc.Add(i);
            Thread.Sleep(100);
        }
        
        bc.CompleteAdding();
    });
    
    var list = bc.GetConsumingEnumerable();
    Console.WriteLine("{0} items in the collection.", list.Count());
    // Output: 10 items in the collection.
    
    Console.WriteLine("Iterate the list:");
    foreach (var item in list)
    {
        Console.WriteLine(item);
    }
    // No output.
    
    Console.WriteLine("Iterate again:");
    foreach (var item in bc.GetConsumingEnumerable())
    {
        Console.WriteLine(item);
    }
    // Still no output.
}

BillWoodruff wrote:

have you ever thought about writing articles, or tip/tricks, for CP on Linq ?

Richard Deeming wrote:

It's not technically wrong, and the code will work as expected, but it "feels" icky. (Hence your post asking if there was a way to avoid it.)

return source
    .Select((item, index) => new 
    { 
        item, 
        chunk = index / chunksz 
    })
    .GroupBy(
        x => x.chunk, 
        x => x.item,
        (key, grp) => KeyValuePair.Create(grp.First(), grp.Skip(1).ToList())
    );