Gegevens partitioneren (C#)

Partitionering in LINQ verwijst naar de werking van het verdelen van een invoerreeks in twee secties, zonder de elementen opnieuw te rangschikken en vervolgens een van de secties te retourneren.

Belangrijk

In deze voorbeelden wordt een System.Collections.Generic.IEnumerable<T> gegevensbron gebruikt. Gegevensbronnen gebaseerd op System.Linq.IQueryProvider maken gebruik van System.Linq.IQueryable<T> gegevensbronnen en expressiebomen. Expressiestructuren hebben beperkingen voor de toegestane C#-syntaxis. Bovendien kan elke IQueryProvider gegevensbron, zoals EF Core , meer beperkingen opleggen. Raadpleeg de documentatie voor uw gegevensbron.

In de volgende afbeelding ziet u de resultaten van drie verschillende partitioneringsbewerkingen op een reeks tekens. De eerste bewerking retourneert de eerste drie elementen in de reeks. Met de tweede bewerking worden de eerste drie elementen overgeslagen en worden de resterende elementen geretourneerd. Met de derde bewerking worden de eerste twee elementen in de reeks overgeslagen en worden de volgende drie elementen geretourneerd.

Afbeelding van drie LINQ-partitioneringsbewerkingen.

De standaardqueryoperatormethoden die partitiereeksen bevatten, worden vermeld in de volgende sectie.

Bedieners

Methodenamen Beschrijving C#-query-expressie-syntaxis Meer informatie
Overslaan Hiermee worden elementen overgeslagen tot een opgegeven positie in een reeks. Niet van toepassing. Enumerable.Skip
Queryable.Skip
In de tussentijd overslaan Slaat elementen over op basis van een predicaatfunctie totdat een element niet aan de voorwaarde voldoet. Niet van toepassing. Enumerable.SkipWhile
Queryable.SkipWhile
Nemen Selecteert elementen tot een opgegeven positie in een reeks. Niet van toepassing. Enumerable.Take
Queryable.Take
In de tussentijd Neemt elementen op basis van een predicaatfunctie totdat een element niet aan de voorwaarde voldoet. Niet van toepassing. Enumerable.TakeWhile
Queryable.TakeWhile
Segment Hiermee worden de elementen van een reeks gesplitst in segmenten van een opgegeven maximale grootte. Niet van toepassing. Enumerable.Chunk
Queryable.Chunk

Alle volgende voorbeelden gebruiken Enumerable.Range(Int32, Int32) om een reeks getallen van 0 tot en met 7 te genereren.

Opmerking

Raadpleeg de veelvoorkomende gegevensbronnen voor dit gebied in het artikel Overzicht van Standaardqueryoperators.

U gebruikt de Take methode om alleen de eerste elementen in een reeks te nemen:

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

U gebruikt de Skip methode om de eerste elementen in een reeks over te slaan en de resterende elementen te gebruiken:

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

De TakeWhile en SkipWhile methoden nemen en slaan ook elementen in een reeks over. In plaats van een vast aantal elementen slaan deze methoden echter elementen over of nemen ze deze op basis van een voorwaarde. TakeWhile neemt de elementen van een reeks totdat een element niet overeenkomt met de voorwaarde.

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 slaat de eerste elementen over, zolang de voorwaarde waar is. Het eerste element dat niet overeenkomt met de voorwaarde en alle volgende elementen, worden geretourneerd.

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

De Chunk operator wordt gebruikt om elementen van een reeks te splitsen op basis van een bepaalde size.

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

De voorgaande C#-code:

  • Vertrouwt op Enumerable.Range(Int32, Int32) om een reeks getallen te genereren.
  • Hiermee past u de Chunk operator toe en splitst u de reeks in segmenten met een maximale grootte van drie.

Zie ook

  • Last updated on