Użyj linq, aby podzielić listę <t> na wiele pozycji <t> o długości n?

Question

Powiel możliwe:
How can I split an IEnumerable<String> into groups of IEnumerable<string>

Mam listę, że chciałbym, aby włamać się do grupy 10.

Jeśli mam obiektu

List<Person> allPendingPersons 

o długości m.

Czy istnieje elegancki sposób w LINQ, aby podzielić wszystkich użytkowników do jednego lub więcej obiektów listy, które mają maksymalnie 10 osób?

Answer 1

var groups = allPendingPersons.Select((p, index) => new {p,index}) 
           .GroupBy(a =>a.index/10); 

jeśli chcesz przetworzyć IGrouping<,>. Jeśli szukasz listy> powrót można spróbować

var listOfLists = allPendingPersons.Select((p, index) => new {p, index}) 
    .GroupBy(a => a.index/10) 
    .Select((grp => grp.Select(g => g.p).ToList())) 
    .ToList(); 

Answer 2

Możesz napisać własną metodę rozszerzenia:

public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> sequence, int size) { 
    List<T> partition = new List<T>(size); 
    foreach(var item in sequence) { 
     partition.Add(item); 
     if (partition.Count == size) { 
      yield return partition; 
      partition = new List<T>(size); 
     } 
    } 
    if (partition.Count > 0) 
     yield return partition; 
} 

I explored this in more depth w moim blogu.

Answer 3

Nie jest to najbardziej wydajna technika, ale to będzie produkować sekwencję IEnumerable<IEnumerable<Person>>, z każdej wewnętrznej sekwencji zawierającej dziesięć elementów:

var query = allPendingPersons.Select((x, i) => new { Value = x, Group = i/10 }) 
          .GroupBy(x => x.Group, 
             (k, g) => g.Select(x => x.Value)); 

a jeśli wynik naprawdę nie trzeba być list-of-list zamiast prostej sekwencji następnie można utworzyć List<List<Person>> zamiast dodając w kilku ToList połączeń:

var query = allPendingPersons.Select((x, i) => new { Value = x, Group = i/10 }) 
          .GroupBy(x => x.Group, 
             (k, g) => g.Select(x => x.Value).ToList()) 
          .ToList(); 

Answer 4

Spróbuj blok iterator:

public static IEnumerable<List<Person>> AsGroups(this List<Person> persons) 
{ 
    var buf = new List<Person>(10); 
    for (int i = 0; i<persons.Count i++;) 
    { 
     buf.Add(persons[i]); 
     if (i%10 == 0 && buf.Count > 0) 
     { 
      yield return buf; 
      buf = new List<Person>(10); 
     } 
    } 
    yield return buf; 
} 

Answer 5

Reactive Extensions for .NET (Rx) ma metodę rozszerzenia, który robi dokładnie to, co chcesz:

var buffered = allPendingPersons.BufferWithCount(10); 

Jeśli chcesz to zrobić przy użyciu LINQ można to zrobić:

var buffered = 
    allPendingPersons 
     .Select((p, i) => new { Group = i/10, Person = p }) 
     .GroupBy(x => x.Group, x => x.Person) 
     .Select(g => g.ToArray()); 

Answer 6

Te powinny być pomocne.

How can I split an IEnumerable<String> into groups of IEnumerable<string>
Divide a large IEnumerable into smaller IEnumerable of a fix amount of item
Can I improve these Pagination extension methods?
Get groups of 4 elements from name value list using LINQ in C#
LINQ: Get min and max values of sequence of numbers divided into subsequences
LINQ Partition List into Lists of 8 members

Jednym z bardzo popularnym rozwiązaniem jest sprawdzić MoreLinq w szczególności funkcję Jon Skeet za Batch, który nie tylko, kim jesteś z prośbą, ale także pozwala określić selektor zwrotu!

Answer 7

Czy istnieje elegancki sposób w LINQ

The elegant way jest niezbyt wydajnych. Oto bardziej wydajnych sposobów ...

public static List<List<T>> Chunk<T>(
     this List<T> theList, 
     int chunkSize 
    ) 
    { 
     if (!theList.Any()) 
     { 
      return new List<List<T>>(); 
     } 

     List<List<T>> result = new List<List<T>>(); 
     List<T> currentList = new List<T>(); 
     result.Add(currentList); 

     int i = 0; 
     foreach(T item in theList) 
     { 
      if (i >= chunkSize) 
      { 
       i = 0; 
       currentList = new List<T>(); 
       result.Add(currentList); 
      } 
      i += 1; 
      currentList.Add(item); 
     } 
     return result; 
    }