Linq get data as quaternary packs

Question

I like to select all data as unpredictable number of quaternary packages (packs which each contains four item) something like the fallowing:

foreach(var quaternary in myEnauerable.ToQuaternaryPackages())
{
    //Whatever (Like: l=page.Add(new List()))
    foreach(var item in quaternary)
    {
        //Whatever (Like: l.Add(item))
    }
}

Answer 1

I think you're looking for something like the MoreLINQ Batch method:

foreach (var batch in myEnumerable.Batch(4))
{
    foreach (var item in batch)
    {
        // ...
    }
}

Note that the final batch will have fewer than 4 items if the total number isn't divisible by 4. (For example, if there are 14 items initially, you'll get three batches of 4 and then a batch of 2.)

You can fetch MoreLINQ either as one big Nuget package, or as individual packages (e.g. the Batch package).

Answer 2

First, make a trivial Batch method (put it in a static class):

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> source, int batchSize)
{
    List<T> temp = new List<T>();
    foreach (T item in source)
    {
        temp.Add(item);
        if (temp.Count == batchSize)
        {
            yield return temp.Select(n => n);
            temp.Clear();
        }
    }
    if (temp.Any())
    {
        yield return temp.Select(n => n);
    }
}

And then just use it like this:

foreach(var quaternary in myEnauerable.Batch(4))
{
    //Whatever (Like: l=page.Add(new List()))
    foreach(var item in quaternary)
    {
        //Whatever (Like: l.Add(item))
    }
}

Answer 3

Shamelessly stolen from Troy Goode's PagedList library: https://github.com/TroyGoode/PagedList/blob/master/src/PagedList/PagedListExtensions.cs

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> superset, int pageSize)
{
  if (superset.Count() < pageSize)
    yield return superset;
  else
  {
    var numberOfPages = Math.Ceiling(superset.Count() / (double)pageSize);
    for (var i = 0; i < numberOfPages; i++)
      yield return superset.Skip(pageSize * i).Take(pageSize);  
  }
}

Use it like so:

var result=myEnumerable.Partition(4);

Answer 4

If you really need the result to be unpredictable (i.e. random), I suggest the following algorithm:

1. Create a random permutation of all elements in the list.
2. Bucket them into quadruples.

For the second part, many good answers have already been provided. For the first part, there is a great in-depth series on creating permutations with LINQ by Eric Lippert.

Answer 5

it's quite simple using linq:

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> source, int batchSize)
{
    for (int i = 0; i < source.Count(); i+=batchSize)
    {
        yield return source.Skip(i).Take(batchSize);
    }
}

that way you split the list by batchSize of items, and if the count of the items is not dividable by batch size, the last iteration will yield the rest of the enumerable.