从单个列表创建嵌套的对象列表

Question

I have a list of items (not sure they are even or odd number of items). What I wanna do is, pick up records in the pair of 5 (which actually is a list), create another list and insert these pair of 5 lists into that new list.

Thanks

I can create a group of items by doing this

MyList
  .Zip(Enumerable.Range(0, MyList.Count()),
       (s, r) => new { 
          Group = r / 5, 
          Item = s })
  .GroupBy(i => i.Group, 
           g => g.Item)
  .ToList();

But I want to generate a nested list.

Answer 1

Not sure I understand your aim correctly, but you can try to use Dictionary for it:

MyList.Zip(Enumerable.Range(0, MyList.Count()),
  (s, r) => new { Group = r / 5, Item = s })
.GroupBy(i => i.Group, g => g.Item)
.ToDictionary(g => g.Key, g => g.ToList());

Answer 2

If you have a collection of items

var items = Enumerable.Range(1, 20);

And you want to take, say, 5 at a time

var setSize = 5;

You can iterate over the collection by index, and take that 5 at a time as a list, and put all those lists of 5 into one outer list

 Enumerable.Range(0, items.Count() - setSize).Select(x => items.Skip(x).Take(setSize).ToList()).ToList()

The result (from C# interactive shell) looks like

List<List<int>>(15) { 
    List<int>(5) { 1, 2, 3, 4, 5 }, 
    List<int>(5) { 2, 3, 4, 5, 6 }, 
    List<int>(5) { 3, 4, 5, 6, 7 }, 
    List<int>(5) { 4, 5, 6, 7, 8 }, 
    List<int>(5) { 5, 6, 7, 8, 9 }, 
    List<int>(5) { 6, 7, 8, 9, 10 }, 
    List<int>(5) { 7, 8, 9, 10, 11 }, 
    List<int>(5) { 8, 9, 10, 11, 12 }, 
    List<int>(5) { 9, 10, 11, 12, 13 }, 
    List<int>(5) { 10, 11, 12, 13, 14 }, 
    List<int>(5) { 11, 12, 13, 14, 15 }, 
    List<int>(5) { 12, 13, 14, 15, 16 }, 
    List<int>(5) { 13, 14, 15, 16, 17 }, 
    List<int>(5) { 14, 15, 16, 17, 18 }, 
    List<int>(5) { 15, 16, 17, 18, 19 }
}

---

If you want each item to only show up once in each list, you can alter the above. Let's assume there's an odd number of elements:

var items = Enumerable.Range(1, 11);

You want to change the initial range used to index into your collection. Instead of taking 5 at a time on each index, it will jump the index up by 5 each iteration. The only tricky part is making sure to handle when the collection divides the number of elements you want to take; you don't want to end up with an empty list at the end. That is, this is incorrect:

Enumerable.Range(0, items.Count() / setSize).Select( // don't do this

The statement is then

Enumerable.Range(0, ((items.Count() - 1) / setSize) + 1).Select(x => items.Skip(setSize * x).Take(setSize).ToList()).ToList();

The result (from C# interactive shell) looks like

List<List<int>>(3) {
    List<int>(5) { 1, 2, 3, 4, 5 },
    List<int>(5) { 6, 7, 8, 9, 10 },
    List<int>(1) { 11 }
}

Answer 3

It looks like you want to batch elements in batches of 5 items each. The MoreLinq package already offers the Batch operator for this:

var items=Enumerable.Range(0,17);
var batches=items.Batch(5);

foreach(var batch in batches)
{
   Console.WriteLine(String.Join(" - ",batch));
}

This produces:

0 - 1 - 2 - 3 - 4
5 - 6 - 7 - 8 - 9
10 - 11 - 12 - 13 - 14
15 - 16

This is far faster than grouping as it only iterates the collection once.

MoreLINQ has other operators too, like Window , WindowLeft and WindowRight that produce sliding windows of values. items.Window(5) would produce:

0 - 1 - 2 - 3 - 4
1 - 2 - 3 - 4 - 5
...
11 - 12 - 13 - 14 - 15
12 - 13 - 14 - 15 - 16

The implementation

The operator's implementation is simple enough that you can just copy it into your project:

public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(this IEnumerable<TSource> source, int size)
{
    return Batch(source, size, x => x);
}

public static IEnumerable<TResult> Batch<TSource, TResult>( IEnumerable<TSource> source, int size,
    Func<IEnumerable<TSource>, TResult> resultSelector)
{
    if (source == null) throw new ArgumentNullException(nameof(source));
    if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
    if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));

    return _(); IEnumerable<TResult> _()
    {
        TSource[] bucket = null;
        var count = 0;

        foreach (var item in source)
        {
            if (bucket == null)
            {
                bucket = new TSource[size];
            }

            bucket[count++] = item;

            // The bucket is fully buffered before it's yielded
            if (count != size)
            {
                continue;
            }

            yield return resultSelector(bucket);

            bucket = null;
            count = 0;
        }

        // Return the last bucket with all remaining elements
        if (bucket != null && count > 0)
        {
            Array.Resize(ref bucket, count);
            yield return resultSelector(bucket);
        }
    }
}

The code uses arrays for efficiency. If you really want to use mutable lists you can change the type of bucket to a List<T> , eg:

if (bucket == null)
{
   bucket = new List<TSource>(size); //IMPORTANT: set the capacity to avoid reallocations
}

bucket.Add(item);

...

Answer 4

Why not just GroupBy ?

 using System.Linq;

 ...

 int groupSize = 5;

 var result = MyList
   .Select((item, index) => new {
      item,
      index 
    })
   .GroupBy(pair => pair.index / groupSize, 
            pair => pair.item)
   .Select(group => group.ToList())
   .ToList();