Teilen Sie eine Liste in kleinere Listen mit der Größe N auf

Ich versuche, eine Liste in eine Reihe kleinerer Listen aufzuteilen.

Mein Problem: Meine Funktion zum Teilen von Listen teilt sie nicht in Listen mit der richtigen Größe auf. Es sollte sie in Listen der Größe 30 aufteilen, aber stattdessen in Listen der Größe 114?

Wie kann ich meine Funktion dazu bringen, eine Liste in X Listen mit einer Größe von 30 oder weniger aufzuteilen ?

public static List<List<float[]>> splitList(List <float[]> locations, int nSize=30) 
{       
    List<List<float[]>> list = new List<List<float[]>>();

    for (int i=(int)(Math.Ceiling((decimal)(locations.Count/nSize))); i>=0; i--) {
        List <float[]> subLocat = new List <float[]>(locations); 

        if (subLocat.Count >= ((i*nSize)+nSize))
            subLocat.RemoveRange(i*nSize, nSize);
        else subLocat.RemoveRange(i*nSize, subLocat.Count-(i*nSize));

        Debug.Log ("Index: "+i.ToString()+", Size: "+subLocat.Count.ToString());
        list.Add (subLocat);
    }

    return list;
}

Wenn ich die Funktion in einer Liste der Größe 144 verwende, lautet die Ausgabe:

Index: 4, Größe: 120
Index: 3, Größe: 114
Index: 2, Größe: 114
Index: 1, Größe: 114
Index: 0, Größe: 114

public static List<List<float[]>> SplitList(List<float[]> locations, int nSize=30)  
{        
    var list = new List<List<float[]>>(); 

    for (int i = 0; i < locations.Count; i += nSize) 
    { 
        list.Add(locations.GetRange(i, Math.Min(nSize, locations.Count - i))); 
    } 

    return list; 
} 

Generische Version:

public static IEnumerable<List<T>> SplitList<T>(List<T> locations, int nSize=30)  
{        
    for (int i = 0; i < locations.Count; i += nSize) 
    { 
        yield return locations.GetRange(i, Math.Min(nSize, locations.Count - i)); 
    }  
} 

Ich würde vorschlagen, diese Erweiterungsmethode zu verwenden, um die Quellliste nach der angegebenen Blockgröße in die Unterlisten zu unterteilen:

/// <summary>
/// Helper methods for the lists.
/// </summary>
public static class ListExtensions
{
    public static List<List<T>> ChunkBy<T>(this List<T> source, int chunkSize) 
    {
        return source
            .Select((x, i) => new { Index = i, Value = x })
            .GroupBy(x => x.Index / chunkSize)
            .Select(x => x.Select(v => v.Value).ToList())
            .ToList();
    }
}

Wenn Sie beispielsweise die Liste mit 18 Elementen auf 5 Elemente pro Block aufteilen, erhalten Sie die Liste mit 4 Unterlisten mit den folgenden Elementen: 5-5-5-3.

wie wäre es mit:

while(locations.Any())
{    
    list.Add(locations.Take(nSize).ToList());
    locations= locations.Skip(nSize).ToList();
}

Die Serj-Tm-Lösung ist in Ordnung. Dies ist auch die generische Version als Erweiterungsmethode für Listen (in eine statische Klasse einfügen):

public static List<List<T>> Split<T>(this List<T> items, int sliceSize = 30)
{
    List<List<T>> list = new List<List<T>>();
    for (int i = 0; i < items.Count; i += sliceSize)
        list.Add(items.GetRange(i, Math.Min(sliceSize, items.Count - i)));
    return list;
} 

Ich finde die akzeptierte Antwort (Serj-Tm) am robustesten, möchte aber eine generische Version vorschlagen.

public static List<List<T>> splitList<T>(List<T> locations, int nSize = 30)
{
    var list = new List<List<T>>();

    for (int i = 0; i < locations.Count; i += nSize)
    {
        list.Add(locations.GetRange(i, Math.Min(nSize, locations.Count - i)));
    }

    return list;
}

Bibliothek MoreLinq hat Methode aufgerufen Batch

List<int> ids = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; // 10 elements
int counter = 1;
foreach(var batch in ids.Batch(2))
{
    foreach(var eachId in batch)
    {
        Console.WriteLine("Batch: {0}, Id: {1}", counter, eachId);
    }
    counter++;
}

Ergebnis ist

Batch: 1, Id: 1
Batch: 1, Id: 2
Batch: 2, Id: 3
Batch: 2, Id: 4
Batch: 3, Id: 5
Batch: 3, Id: 6
Batch: 4, Id: 7
Batch: 4, Id: 8
Batch: 5, Id: 9
Batch: 5, Id: 0

ids werden in 5 Stücke mit 2 Elementen aufgeteilt.

Ich habe eine generische Methode, die alle Arten von Float annehmen würde, und sie wurde in Einheiten getestet. Ich hoffe, sie hilft:

    /// <summary>
    /// Breaks the list into groups with each group containing no more than the specified group size
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="values">The values.</param>
    /// <param name="groupSize">Size of the group.</param>
    /// <returns></returns>
    public static List<List<T>> SplitList<T>(IEnumerable<T> values, int groupSize, int? maxCount = null)
    {
        List<List<T>> result = new List<List<T>>();
        // Quick and special scenario
        if (values.Count() <= groupSize)
        {
            result.Add(values.ToList());
        }
        else
        {
            List<T> valueList = values.ToList();
            int startIndex = 0;
            int count = valueList.Count;
            int elementCount = 0;

            while (startIndex < count && (!maxCount.HasValue || (maxCount.HasValue && startIndex < maxCount)))
            {
                elementCount = (startIndex + groupSize > count) ? count - startIndex : groupSize;
                result.Add(valueList.GetRange(startIndex, elementCount));
                startIndex += elementCount;
            }
        }


        return result;
    }

Während viele der oben genannten Antworten den Job machen, scheitern sie alle schrecklich an einer nie endenden Sequenz (oder einer wirklich langen Sequenz). Das Folgende ist eine vollständig Online-Implementierung, die die bestmögliche Zeit- und Speicherkomplexität garantiert. Wir iterieren die aufzählbare Quelle nur genau einmal und verwenden Yield Return für eine verzögerte Auswertung. Der Verbraucher könnte die Liste bei jeder Iteration wegwerfen, wodurch der Speicherbedarf dem der Liste mit der batchSizeAnzahl der Elemente entspricht.

public static IEnumerable<List<T>> BatchBy<T>(this IEnumerable<T> enumerable, int batchSize)
{
    using (var enumerator = enumerable.GetEnumerator())
    {
        List<T> list = null;
        while (enumerator.MoveNext())
        {
            if (list == null)
            {
                list = new List<T> {enumerator.Current};
            }
            else if (list.Count < batchSize)
            {
                list.Add(enumerator.Current);
            }
            else
            {
                yield return list;
                list = new List<T> {enumerator.Current};
            }
        }

        if (list?.Count > 0)
        {
            yield return list;
        }
    }
}

BEARBEITEN: Gerade jetzt, als das OP realisiert wird, wird gefragt, ob ein List<T>in kleinere List<T>Teile zerlegt werden soll. Daher sind meine Kommentare zu unendlichen Aufzählungen nicht auf das OP anwendbar, können aber anderen helfen, die hier landen. Diese Kommentare waren eine Reaktion auf andere veröffentlichte Lösungen, die IEnumerable<T>als Eingabe für ihre Funktion verwendet werden, die Quelle jedoch mehrmals auflisten.

Ergänzung nach sehr nützlichem Kommentar von mhand am Ende

Ursprüngliche Antwort

Obwohl die meisten Lösungen funktionieren könnten, denke ich, dass sie nicht sehr effizient sind. Angenommen, Sie möchten nur die ersten Elemente der ersten Teile. Dann möchten Sie nicht alle (zig) Elemente in Ihrer Sequenz durchlaufen.

Folgendes wird höchstens zweimal aufgezählt: einmal für den Take und einmal für den Skip. Es werden nicht mehr Elemente aufgelistet, als Sie verwenden werden:

public static IEnumerable<IEnumerable<TSource>> ChunkBy<TSource>
    (this IEnumerable<TSource> source, int chunkSize)
{
    while (source.Any())                     // while there are elements left
    {   // still something to chunk:
        yield return source.Take(chunkSize); // return a chunk of chunkSize
        source = source.Skip(chunkSize);     // skip the returned chunk
    }
}

Wie oft wird die Sequenz aufgelistet?

Angenommen, Sie teilen Ihre Quelle in Teile von chunkSize. Sie zählen nur die ersten N Chunks auf. Von jedem aufgezählten Block werden nur die ersten M Elemente aufgelistet.

While(source.Any())
{
     ...
}

Das Any erhält den Enumerator, führt 1 MoveNext () aus und gibt den zurückgegebenen Wert zurück, nachdem der Enumerator entsorgt wurde. Dies wird N-mal durchgeführt

yield return source.Take(chunkSize);

Laut der Referenzquelle wird dies ungefähr Folgendes bewirken:

public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
{
    return TakeIterator<TSource>(source, count);
}

static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> source, int count)
{
    foreach (TSource element in source)
    {
        yield return element;
        if (--count == 0) break;
    }
}

Dies macht nicht viel, bis Sie anfangen, über den abgerufenen Chunk aufzuzählen. Wenn Sie mehrere Chunks abrufen, sich jedoch dafür entscheiden, nicht über den ersten Chunk aufzuzählen, wird der foreach nicht ausgeführt, wie Ihr Debugger Ihnen zeigt.

Wenn Sie sich entscheiden, die ersten M Elemente des ersten Blocks zu verwenden, wird die Ertragsrendite genau M Mal ausgeführt. Das heisst:

• Holen Sie sich den Enumerator
• Rufen Sie MoveNext () und Current M times auf.
• Entsorgen Sie den Enumerator

Nachdem der erste Block zurückgegeben wurde, überspringen wir diesen ersten Block:

source = source.Skip(chunkSize);

Noch einmal: Wir werfen einen Blick auf die Referenzquelle , um die zu findenskipiterator

static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count)
{
    using (IEnumerator<TSource> e = source.GetEnumerator()) 
    {
        while (count > 0 && e.MoveNext()) count--;
        if (count <= 0) 
        {
            while (e.MoveNext()) yield return e.Current;
        }
    }
}

Wie Sie sehen, werden die SkipIteratorAufrufe MoveNext()für jedes Element im Chunk einmal ausgeführt. Es ruft nicht an Current.

Pro Chunk sehen wir also, dass Folgendes getan wird:

• Any (): GetEnumerator; 1 MoveNext (); Enumerator entsorgen;

• Nehmen():

  • nichts, wenn der Inhalt des Blocks nicht aufgezählt ist.

  • Wenn der Inhalt aufgelistet ist: GetEnumerator (), ein MoveNext und ein Current pro aufgezähltem Element, Enpose enumerator;

  • Skip (): für jeden aufgezählten Block (NICHT den Inhalt des Blocks): GetEnumerator (), MoveNext () chunkSize times, no Current! Enumerator entsorgen

Wenn Sie sich ansehen, was mit dem Enumerator passiert, werden Sie feststellen, dass MoveNext () häufig aufgerufen wird und nur Currentdie TSource-Elemente aufgerufen werden, auf die Sie tatsächlich zugreifen möchten.

Wenn Sie N Chunks der Größe chunkSize nehmen, rufen Sie MoveNext () auf

• N mal für Any ()
• Noch keine Zeit für Take, solange Sie die Chunks nicht aufzählen
• N mal chunkSize für Skip ()

Wenn Sie nur die ersten M Elemente jedes abgerufenen Blocks auflisten möchten, müssen Sie MoveNext M-mal pro aufgezähltem Block aufrufen.

Die Summe

MoveNext calls: N + N*M + N*chunkSize
Current calls: N*M; (only the items you really access)

Wenn Sie sich also dazu entschließen, alle Elemente aller Blöcke aufzulisten:

MoveNext: numberOfChunks + all elements + all elements = about twice the sequence
Current: every item is accessed exactly once

Ob MoveNext viel Arbeit ist oder nicht, hängt von der Art der Quellsequenz ab. Bei Listen und Arrays handelt es sich um ein einfaches Indexinkrement mit möglicherweise einer Überprüfung außerhalb des Bereichs.

Wenn Ihre IEnumerable jedoch das Ergebnis einer Datenbankabfrage ist, stellen Sie sicher, dass die Daten tatsächlich auf Ihrem Computer materialisiert sind. Andernfalls werden die Daten mehrmals abgerufen. DbContext und Dapper übertragen die Daten ordnungsgemäß an den lokalen Prozess, bevor auf sie zugegriffen werden kann. Wenn Sie dieselbe Sequenz mehrmals aufzählen, wird sie nicht mehrmals abgerufen. Dapper gibt ein Objekt zurück, das eine Liste ist. DbContext merkt sich, dass die Daten bereits abgerufen wurden.

Es hängt von Ihrem Repository ab, ob es sinnvoll ist, AsEnumerable () oder ToLists () aufzurufen, bevor Sie mit der Aufteilung der Elemente in Chunks beginnen

public static IEnumerable<IEnumerable<T>> SplitIntoSets<T>
    (this IEnumerable<T> source, int itemsPerSet) 
{
    var sourceList = source as List<T> ?? source.ToList();
    for (var index = 0; index < sourceList.Count; index += itemsPerSet)
    {
        yield return sourceList.Skip(index).Take(itemsPerSet);
    }
}

public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> items, int maxItems)
{
    return items.Select((item, index) => new { item, index })
                .GroupBy(x => x.index / maxItems)
                .Select(g => g.Select(x => x.item));
}

Wie wäre es mit diesem? Die Idee war, nur eine Schleife zu verwenden. Und wer weiß, vielleicht verwenden Sie nur IList-Implementierungen in Ihrem Code und möchten nicht in List umwandeln.

private IEnumerable<IList<T>> SplitList<T>(IList<T> list, int totalChunks)
{
    IList<T> auxList = new List<T>();
    int totalItems = list.Count();

    if (totalChunks <= 0)
    {
        yield return auxList;
    }
    else 
    {
        for (int i = 0; i < totalItems; i++)
        {               
            auxList.Add(list[i]);           

            if ((i + 1) % totalChunks == 0)
            {
                yield return auxList;
                auxList = new List<T>();                
            }

            else if (i == totalItems - 1)
            {
                yield return auxList;
            }
        }
    }   
}

Einer noch

public static IList<IList<T>> SplitList<T>(this IList<T> list, int chunkSize)
{
    var chunks = new List<IList<T>>();
    List<T> chunk = null;
    for (var i = 0; i < list.Count; i++)
    {
        if (i % chunkSize == 0)
        {
            chunk = new List<T>(chunkSize);
            chunks.Add(chunk);
        }
        chunk.Add(list[i]);
    }
    return chunks;
}

public static List<List<T>> ChunkBy<T>(this List<T> source, int chunkSize)
    {           
        var result = new List<List<T>>();
        for (int i = 0; i < source.Count; i += chunkSize)
        {
            var rows = new List<T>();
            for (int j = i; j < i + chunkSize; j++)
            {
                if (j >= source.Count) break;
                rows.Add(source[j]);
            }
            result.Add(rows);
        }
        return result;
    }

List<int> list =new List<int>(){1,2,3,4,5,6,7,8,9,10,12};
Dictionary<int,List<int>> dic = new Dictionary <int,List<int>> ();
int batchcount = list.Count/2; //To List into two 2 parts if you want three give three
List<int> lst = new List<int>();
for (int i=0;i<list.Count; i++)
{
lstdocs.Add(list[i]);
if (i % batchCount == 0 && i!=0)
{
Dic.Add(threadId, lstdocs);
lst = new List<int>();**strong text**
threadId++;
}
}
Dic.Add(threadId, lstdocs);

Ich war auf dasselbe Bedürfnis gestoßen und habe eine Kombination der Linq- Methoden Skip () und Take () verwendet. Ich multipliziere die Anzahl, die ich nehme, mit der Anzahl der Iterationen, und das gibt mir die Anzahl der zu überspringenden Elemente. Dann nehme ich die nächste Gruppe.

        var categories = Properties.Settings.Default.MovementStatsCategories;
        var items = summariesWithinYear
            .Select(s =>  s.sku).Distinct().ToList();

        //need to run by chunks of 10,000
        var count = items.Count;
        var counter = 0;
        var numToTake = 10000;

        while (count > 0)
        {
            var itemsChunk = items.Skip(numToTake * counter).Take(numToTake).ToList();
            counter += 1;

            MovementHistoryUtilities.RecordMovementHistoryStatsBulk(itemsChunk, categories, nLogger);

            count -= numToTake;
        }

Basierend auf Dimitry Pavlov Antwort würde ich entfernen .ToList(). Und vermeiden Sie auch die anonyme Klasse. Stattdessen verwende ich gerne eine Struktur, für die keine Heap-Speicherzuordnung erforderlich ist. (A ValueTuplewürde auch Arbeit machen.)

public static IEnumerable<IEnumerable<TSource>> ChunkBy<TSource>(this IEnumerable<TSource> source, int chunkSize)
{
    if (source is null)
    {
        throw new ArgumentNullException(nameof(source));
    }
    if (chunkSize <= 0)
    {
        throw new ArgumentOutOfRangeException(nameof(chunkSize), chunkSize, "The argument must be greater than zero.");
    }

    return source
        .Select((x, i) => new ChunkedValue<TSource>(x, i / chunkSize))
        .GroupBy(cv => cv.ChunkIndex)
        .Select(g => g.Select(cv => cv.Value));
} 

[StructLayout(LayoutKind.Auto)]
[DebuggerDisplay("{" + nameof(ChunkedValue<T>.ChunkIndex) + "}: {" + nameof(ChunkedValue<T>.Value) + "}")]
private struct ChunkedValue<T>
{
    public ChunkedValue(T value, int chunkIndex)
    {
        this.ChunkIndex = chunkIndex;
        this.Value = value;
    }

    public int ChunkIndex { get; }

    public T Value { get; }
}

Dies kann wie folgt verwendet werden, wobei die Sammlung nur einmal durchlaufen wird und auch kein signifikanter Speicher zugewiesen wird.

int chunkSize = 30;
foreach (var chunk in collection.ChunkBy(chunkSize))
{
    foreach (var item in chunk)
    {
        // your code for item here.
    }
}

Wenn tatsächlich eine konkrete Liste benötigt wird, würde ich das so machen:

int chunkSize = 30;
var chunkList = new List<List<T>>();
foreach (var chunk in collection.ChunkBy(chunkSize))
{
    // create a list with the correct capacity to be able to contain one chunk
    // to avoid the resizing (additional memory allocation and memory copy) within the List<T>.
    var list = new List<T>(chunkSize);
    list.AddRange(chunk);
    chunkList.Add(list);
}