Freigeben über

Partitionieren von Daten (C#)

  • Artikel

Partitionieren in LINQ bezieht sich auf den Vorgang, bei dem eine Eingabesequenz in zwei Abschnitte unterteilt wird, ohne die Elemente dabei neu anzuordnen, und bei dem anschließend einer der Abschnitte zurückzugeben wird.

Wichtig

In diesen Beispielen wird eine System.Collections.Generic.IEnumerable<T>-Datenquelle verwendet. Datenquellen, die auf System.Linq.IQueryProvider basieren, verwenden System.Linq.IQueryable<T>-Datenquellen und Ausdrucksbaumstrukturen. Ausdrucksbaumstrukturen haben Einschränkungen für die zulässige C#-Syntax. Darüber hinaus kann jede IQueryProvider-Datenquelle, z. B. EF Core, weitere Einschränkungen erzwingen. Konsultieren Sie die Dokumentation für Ihre Datenquelle.

Die folgende Abbildung zeigt das Ergebnis von drei verschiedenen Partitionierungsvorgängen einer Zeichensequenz. Der erste Vorgang gibt die ersten drei Elemente in der Sequenz zurück. Der zweite Vorgang überspringt die ersten drei Elemente und gibt die übrigen Elemente zurück. Der dritte Vorgang überspringt die ersten beiden Elemente in der Sequenz und gibt die nächsten drei Elemente zurück.

Abbildung zu drei LINQ-Partitionierungsvorgängen.

Die Methoden des Standardabfrageoperators, die Sequenzen partitionieren, sind im folgenden Abschnitt aufgeführt.

Operatoren

Methodennamen BESCHREIBUNG C#-Abfrageausdruckssyntax Weitere Informationen
Skip Überspringt Elemente bis zu einer angegebenen Position in einer Sequenz Nicht zutreffend. Enumerable.Skip
Queryable.Skip
SkipWhile Überspringt Elemente basierend auf einer Prädikatfunktion, bis ein Element die Bedingung nicht erfüllt Nicht zutreffend. Enumerable.SkipWhile
Queryable.SkipWhile
Take Übernimmt Elemente bis zu einer angegebenen Position in einer Sequenz Nicht zutreffend. Enumerable.Take
Queryable.Take
TakeWhile Übernimmt Elemente basierend auf einer Prädikatfunktion, bis ein Element der Bedingung nicht erfüllt Nicht zutreffend. Enumerable.TakeWhile
Queryable.TakeWhile
Block Diese Methode teilt die Elemente einer Sequenz in Teile mit einer festgelegten Maximalgröße auf. Nicht zutreffend Enumerable.Chunk
Queryable.Chunk

In allen folgenden Beispielen wird Enumerable.Range(Int32, Int32) verwendet, um eine Sequenz von Zahlen zwischen 0 und 7 zu generieren.

Sie verwenden die Take-Methode, um nur die ersten Elemente in einer Sequenz zu übernehmen:

foreach (int number in Enumerable.Range(0, 8).Take(3))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 0
// 1
// 2

Sie verwenden die Skip-Methode, um die ersten Elemente in einer Sequenz zu überspringen und die verbleibenden Elemente zu verwenden:

foreach (int number in Enumerable.Range(0, 8).Skip(3))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 3
// 4
// 5
// 6
// 7

Die Methoden TakeWhile und SkipWhile übernehmen und überspringen ebenfalls Elemente in einer Sequenz. Anstelle einer festgelegten Anzahl von Elementen übernehmen oder überspringen diese Methoden jedoch Elemente basierend auf einer Bedingung. TakeWhile übernimmt die Elemente einer Sequenz, bis ein Element nicht der Bedingung entspricht.

foreach (int number in Enumerable.Range(0, 8).TakeWhile(n => n < 5))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 0
// 1
// 2
// 3
// 4

SkipWhile überspringt die ersten Elemente, solange die Bedingung TRUE ist. Es werden das erste Element, das nicht der Bedingung entspricht, und alle nachfolgenden Elemente zurückgegeben.

foreach (int number in Enumerable.Range(0, 8).SkipWhile(n => n < 5))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 5
// 6
// 7

Der Operator Chunk wird verwendet, um Elemente einer Folge auf der Grundlage eines bestimmten size aufzuteilen.

int chunkNumber = 1;
foreach (int[] chunk in Enumerable.Range(0, 8).Chunk(3))
{
    Console.WriteLine($"Chunk {chunkNumber++}:");
    foreach (int item in chunk)
    {
        Console.WriteLine($"    {item}");
    }

    Console.WriteLine();
}
// This code produces the following output:
// Chunk 1:
//    0
//    1
//    2
//
//Chunk 2:
//    3
//    4
//    5
//
//Chunk 3:
//    6
//    7

Für den C#-Code oben gilt:

  • Verlässt sich auf Enumerable.Range(Int32, Int32) um eine Zahlenfolge erzeugen.
  • Wendet den Operator Chunk an, der die Folge in Abschnitte mit der maximalen Größe drei aufspaltet.

Weitere Informationen