Partitionieren von Daten (C#)

Die Partitionierung in LINQ bezieht sich auf den Vorgang der Aufteilung einer Eingabesequenz in zwei Abschnitte, ohne die Elemente neu anzuordnen und dann einen der Abschnitte zurückzugeben.

Von Bedeutung

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 die Ergebnisse von drei verschiedenen Partitionierungsvorgängen in einer Folge von Zeichen. Der erste Vorgang gibt die ersten drei Elemente in der Sequenz zurück. Der zweite Vorgang überspringt die ersten drei Elemente und gibt die verbleibenden Elemente zurück. Der dritte Vorgang überspringt die ersten beiden Elemente in der Sequenz und gibt die nächsten drei Elemente zurück.

Die Standardabfrageoperator-Methoden, die Partitionierungssequenzen verwenden, sind im folgenden Abschnitt aufgeführt.

Betriebspersonal

Methodennamen	BESCHREIBUNG	Syntax des C#-Abfrageausdrucks	Mehr Informationen
Überspringen	Ü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
Nehmen	Nimmt Elemente bis zu einer angegebenen Position in einer Sequenz.	Nicht zutreffend.	Enumerable.Take Queryable.Take
TakeWhile	Verwendet Elemente basierend auf einer Prädikatfunktion, bis ein Element die Bedingung nicht erfüllt.	Nicht zutreffend.	Enumerable.TakeWhile Queryable.TakeWhile
Block	Teilt die Elemente einer Sequenz in Blöcke einer angegebenen maximalen Größe auf.	Nicht zutreffend.	Enumerable.Chunk Queryable.Chunk

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

Hinweis

Im Artikel "Übersicht über Standardabfrageoperatoren " finden Sie informationen zu den allgemeinen Datenquellen für diesen Bereich.

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 TakeWhile und SkipWhile Methoden erfassen und überspringen auch Elemente in einer Sequenz. Statt einer festgelegten Anzahl von Elementen überspringen oder übernehmen diese Methoden Elemente basierend auf einer Bedingung. TakeWhile verwendet die Elemente einer Sequenz, bis ein Element nicht mit der Bedingung übereinstimmt.

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 wahr ist. Das erste Element, das nicht mit der Bedingung abgleicht, und alle nachfolgenden Elemente werden 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 Chunk Operator wird verwendet, um Elemente einer Sequenz basierend auf einem bestimmten sizeElement 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

Der vorhergehende C#-Code:

• Stützt sich auf Enumerable.Range(Int32, Int32), um eine Sequenz von Zahlen zu generieren.
• Wendet den Chunk Operator an, wobei die Sequenz in Blöcke mit einer maximalen Größe von drei aufgeteilt wird.

Siehe auch

• System.Linq