Liste in Unterlisten aufteilen mit LINQ

Question

Gibt es eine Möglichkeit, wie ich eine List<SomeObject> in mehrere separate Listen von SomeObject und dabei den Artikelindex als Trennzeichen für jeden Split?

Lassen Sie mich ein Beispiel geben:

Ich habe eine List<SomeObject> und ich brauche eine List<List<SomeObject>> o List<SomeObject>[] , so dass jede dieser resultierenden Listen eine Gruppe von 3 Elementen der ursprünglichen Liste (in der Reihenfolge) enthält.

z. B.:

• Ursprüngliche Liste: [a, g, e, w, p, s, q, f, x, y, i, m, c]

• Daraus resultierende Listen: [a, g, e], [w, p, s], [q, f, x], [y, i, m], [c]

Außerdem muss die Größe der resultierenden Liste ein Parameter dieser Funktion sein.

Answer 1

System.Interaktiv bietet Buffer() zu diesem Zweck. Einige schnelle Tests zeigen, dass die Leistung ähnlich ist wie bei Sams Lösung.

Answer 2

Wir können die Lösung von @JaredPar verbessern, um eine echte faule Auswertung zu erreichen. Wir verwenden eine GroupAdjacentBy Methode, die Gruppen von aufeinanderfolgenden Elementen mit demselben Schlüssel liefert:

sequence
.Select((x, i) => new { Value = x, Index = i })
.GroupAdjacentBy(x=>x.Index/3)
.Select(g=>g.Select(x=>x.Value))

Da die Gruppen nacheinander ermittelt werden, funktioniert diese Lösung auch bei langen oder unendlichen Sequenzen.

Answer 3

Ich finde, dieser kleine Ausschnitt erfüllt die Aufgabe ganz gut.

public static IEnumerable<List<T>> Chunked<T>(this List<T> source, int chunkSize)
{
    var offset = 0;

    while (offset < source.Count)
    {
        yield return source.GetRange(offset, Math.Min(source.Count - offset, chunkSize));
        offset += chunkSize;
    }
}

Answer 4

Ab .NET 6 können Sie jetzt auch native Chunk() Methode, verfügbar sowohl für IEnumerable<T> y IQueryable<T> .

Weitere Informationen (und Links) hier: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/partitioning-data

Answer 5

Hier ist eine Routine zum Aufteilen von Listen, die ich vor ein paar Monaten geschrieben habe:

public static List<List<T>> Chunk<T>(
    List<T> theList,
    int chunkSize
)
{
    List<List<T>> result = theList
        .Select((x, i) => new {
            data = x,
            indexgroup = i / chunkSize
        })
        .GroupBy(x => x.indexgroup, x => x.data)
        .Select(g => new List<T>(g))
        .ToList();

    return result;
}