Partycjonowanie danych (C#)

Partycjonowanie w LINQ odnosi się do operacji dzielenia sekwencji danych wejściowych na dwie sekcje, bez zmieniania układu elementów, a następnie zwracania jednej z sekcji.

Poniższa ilustracja przedstawia wyniki trzech różnych operacji partycjonowania na sekwencji znaków. Pierwsza operacja zwraca pierwsze trzy elementy w sekwencji. Druga operacja pomija pierwsze trzy elementy i zwraca pozostałe elementy. Trzecia operacja pomija pierwsze dwa elementy w sekwencji i zwraca następne trzy elementy.

Standardowe metody operatorów zapytań, które sekwencje partycji są wymienione w poniższej sekcji.

Operatory

Nazwy metod	opis	Składnia wyrażeń zapytań języka C#	Więcej informacji
Pomiń	Pomija elementy do określonej pozycji w sekwencji.	Nie dotyczy.	Enumerable.Skip Queryable.Skip
Skipwhile	Pomija elementy na podstawie funkcji predykatu, dopóki element nie spełnia warunku.	Nie dotyczy.	Enumerable.SkipWhile Queryable.SkipWhile
Take	Przyjmuje elementy do określonej pozycji w sekwencji.	Nie dotyczy.	Enumerable.Take Queryable.Take
Takewhile	Pobiera elementy na podstawie funkcji predykatu, dopóki element nie spełnia warunku.	Nie dotyczy.	Enumerable.TakeWhile Queryable.TakeWhile
Fragment	Dzieli elementy sekwencji na fragmenty określonego maksymalnego rozmiaru.	Nie dotyczy.	Enumerable.Chunk Queryable.Chunk

Wszystkie poniższe przykłady służą Enumerable.Range(Int32, Int32) do generowania sekwencji liczb z zakresu od 0 do 7.

Metoda służy Take do stosowania tylko pierwszych elementów w sekwencji:

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

Skip Użyj metody , aby pominąć pierwsze elementy w sekwencji i użyć pozostałych elementów:

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

Metody TakeWhile i SkipWhile również przyjmują i pomijają elementy w sekwencji. Jednak zamiast zestawu elementów te metody pomijają lub przyjmują elementy na podstawie warunku. TakeWhile pobiera elementy sekwencji, dopóki element nie jest zgodny z warunkiem.

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 Pomija pierwsze elementy, o ile warunek ma wartość true. Zwracany jest pierwszy element, który nie pasuje do warunku, a wszystkie kolejne elementy.

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

Operator Chunk służy do dzielenia elementów sekwencji na podstawie danego sizeelementu .

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

Poprzedni kod języka C#:

• Opiera się na Enumerable.Range(Int32, Int32) generowaniu sekwencji liczb.
• Chunk Stosuje operator, dzieląc sekwencję na fragmenty o maksymalnym rozmiarze trzech.

Zobacz też

• System.Linq