Partitionering av data (C#)

Partitionering i LINQ syftar på att dela upp en indatasekvens i två avsnitt, utan att ändra ordning på elementen och sedan returnera ett av avsnitten.

Viktigt!

Dessa exempel använder en System.Collections.Generic.IEnumerable<T> datakälla. Datakällor baserade på System.Linq.IQueryProvider använder System.Linq.IQueryable<T> datakällor och uttrycksträd. Uttrycksträd har begränsningar för den tillåtna C#-syntaxen. Dessutom kan varje IQueryProvider datakälla, till exempel EF Core , införa fler begränsningar. Kontrollera dokumentationen för din datakälla.

Följande bild visar resultatet av tre olika partitioneringsåtgärder på en sekvens med tecken. Den första åtgärden returnerar de tre första elementen i sekvensen. Den andra åtgärden hoppar över de tre första elementen och returnerar de återstående elementen. Den tredje åtgärden hoppar över de två första elementen i sekvensen och returnerar de följande tre elementen.

Bild som visar tre LINQ-partitioneringsåtgärder.

Standardfrågeoperatormetoderna som partitionerar sekvenser listas i följande avsnitt.

Operatörer

Metodnamn Beskrivning Syntax för C#-frågeuttryck Mer information
Hoppa över Hoppar över element upp till en angiven position i en sekvens. Ej tillämpbart. Enumerable.Skip
Queryable.Skip
Hoppa över Hoppar över element baserat på en predikatfunktion tills ett element inte uppfyller villkoret. Ej tillämpbart. Enumerable.SkipWhile
Queryable.SkipWhile
Ta Tar element upp till en angiven position i en sekvens. Ej tillämpbart. Enumerable.Take
Queryable.Take
TaMedan Tar element baserat på en predikatfunktion tills ett element inte uppfyller villkoret. Ej tillämpbart. Enumerable.TakeWhile
Queryable.TakeWhile
Segment Delar upp elementen i en sekvens i segment med en angiven maximal storlek. Ej tillämpbart. Enumerable.Chunk
Queryable.Chunk

Alla följande exempel används Enumerable.Range(Int32, Int32) för att generera en sekvens med tal från 0 till 7.

Anmärkning

Du kan läsa vanliga datakällor för det här området i artikeln Översikt över vanliga frågeoperatorer .

Du använder Take metoden för att bara ta de första elementen i en sekvens:

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

Du använder Skip metoden för att hoppa över de första elementen i en sekvens och använda de återstående elementen:

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

Metoderna TakeWhile och SkipWhile tar även och hoppar över element i en sekvens. Men i stället för ett visst antal element hoppar dessa metoder över eller tar element baserat på ett villkor. TakeWhile tar elementen i en sekvens tills ett element inte matchar villkoret.

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 hoppar över de första elementen så länge villkoret är sant. Det första elementet som inte matchar villkoret, och alla efterföljande element, returneras.

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

Operatorn Chunk används för att dela upp element i en sekvens baserat på en viss 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

Föregående C#-kod:

  • Förlitar sig på Enumerable.Range(Int32, Int32) för att generera en sekvens med tal.
  • Tillämpar operatorn Chunk och delar upp sekvensen i segment med en maxstorlek på tre.

Se även

  • Last updated on