Udostępnij za pośrednictwem

Partycjonowanie danych (C#)

  • Artykuł

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.

Ważne

Te przykłady używają System.Collections.Generic.IEnumerable<T> źródła danych. Źródła danych oparte na System.Linq.IQueryProviderSystem.Linq.IQueryable<T> źródłach danych i drzewach wyrażeń. Drzewa wyrażeń mają ograniczenia dotyczące dozwolonej składni języka C#. Ponadto każde IQueryProvider źródło danych, takie jak EF Core , może nakładać więcej ograniczeń. Zapoznaj się z dokumentacją źródła danych.

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.

Ilustracja przedstawiająca trzy operacje partycjonowania LINQ.

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ż