Partitionieren von Daten (C#)

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.

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

• System.Linq