.NET Iterate through an IEnumerable several elements at a time

Question

Given a collection, I need to iterate through all the elements three (or some other amount) at a time. For example:

string[] exampleData = {"John", "Doe", "1.1.1990", "Jane", "Roe", "2.2.1980"}

for(int i = 0; i < exampleData.Length; i += 3) {
    CreateUser(foreName: exampleData[i], surName: exampleData[i+1], dateOfBirth: exampleData[i+2]);
} 

How could I efficiently reproduce this if exampleData was an IEnumerable instead of an array?

Answer 1

An efficient approach would be with an extension method:

public static IEnumerable<IList<T>> ChunksOf<T>(this IEnumerable<T> sequence, int size)
{
    List<T> chunk = new List<T>(size);

    foreach (T element in sequence)
    {
        chunk.Add(element);
        if (chunk.Count == size)
        {
            yield return chunk;
            chunk = new List<T>(size);
        }
    }
}

You could use it like this:

foreach (IList<string> chunk in exampleData.ChunksOf(3))
{
    CreateUser(foreName: chunk[0], surName: chunk[1], dateOfBirth: chunk[2]);
}

Note that if sequence.Count() is not an integer multiple of size, then ChunksOf discards the last partial chunk. If instead you wanted to return a partial chunk, you could add to the end: if (chunk.Count > 0) yield return chunk;.

Answer 2

This snippet groups your array into sets of 3 elements, and then creates a user for each set.

    exampleData.Select((elem, index) => new {elem, index})
        .GroupBy(x => x.index/3)
        .Select(x => CreateUser(
                          x.ElementAt(0).elem,
                          x.ElementAt(1).elem,
                          x.ElementAt(2).elem));

Naturally, you'll need to make sure the array's length is a multiple of 3.

Answer 3

How about forgetting foreach, the fancy linq stuff, temporary sublists, etc., and going back to the roots? :-)

Call .GetEnumerator() and call .MoveNext() three times in an iteration. That's what enumeration is at its core.

The previous answers seem overly complicated to me. This is simple and hardcore :-).

Answer 4

Although I prefer Michael's approach, you may prefer something a little more specific if you need field specific parsing (eg DOB parsing)

public static IEnumerable<User> ExtractUsers(IEnumerable<string> input)
{
    int i = 0;
    string forename;
    string surname;
    string dateofbirth;
    foreach (string current in input) 
    {
        switch (i) 
        {
        case 0:
            one = forename;
            break;
        case 1:
            two = surname;
            break;
        case 2:
            three = dateofbirth;
            i = -1; //uck, this will get incremented at the bottom
            yield return CreateUser(forename, surname, dateofbirth);
            break;
        }
        i++;
    }
}

Answer 5

Take() and Skip() will do what you want, but I would advise you to avoid using arrays like this. You'd be better off creating a Person class with FirstName, LastName, and DateOfBirth properties and keeping an array of those.

Answer 6

You can use LINQ

        string[] exampleData = {"John", "Doe", "1.1.1990", "Jane", "Roe", "2.2.1980"};

        int chunkSize = 3;
        var seqences = from seqIndex in Enumerable.Range(0, exampleData.Length)
                       group exampleData[seqIndex] by seqIndex / chunkSize;
        foreach (var sub in seqences)
        {
            CreateUser(sub.ToList()[0], sub.ToList()[1], sub.ToList()[2]);
        }

Edit:

     var seqences = from m in Enumerable.Range(0, exampleData.Count()) group 
                           exampleData.ToList()[m] by m / chunkSize;

or

        int chunkSize = 3;
        var seqences = Enumerable.Range(0, exampleData.Count())
                       .GroupBy(m => m/chunkSize, m => exampleData.ToList()[m]);