Como particionar dados (C#)

Particionamento em LINQ refere-se à operação de dividir uma sequência de entrada em duas seções sem reorganizar os elementos e, depois, retornar uma das seções.

Importante

Esses exemplos usam uma fonte de dados System.Collections.Generic.IEnumerable<T>. Fontes de dados baseadas em System.Linq.IQueryProvider usam as fontes de dados System.Linq.IQueryable<T> e as árvores de expressão. As árvores de expressão possuem limitações na sintaxe C# permitida. Além disso, todas as fontes de dados IQueryProvider, como EF Core, podem impor mais restrições. Verifique a documentação da fonte de dados.

A ilustração a seguir mostra os resultados de três operações de particionamento diferentes em uma sequência de caracteres. A primeira operação retorna os três primeiros elementos na sequência. A segunda operação ignora os três primeiros elementos e retorna os elementos restantes. A terceira operação ignora os dois primeiros elementos na sequência e retorna os três elementos seguintes.

Os métodos de operador de consulta padrão que particionam sequências estão listados na seção a seguir.

Operadores

Nomes de método	Descrição	Sintaxe de expressão de consulta em C#	Mais informações
Ignorar	Ignora elementos até uma posição especificada na sequência.	Não aplicável.	Enumerable.Skip Queryable.Skip
SkipWhile	Ignora elementos com base em uma função de predicado até que um elemento não satisfaça a condição.	Não aplicável.	Enumerable.SkipWhile Queryable.SkipWhile
Take	Aceita elementos até uma posição especificada na sequência.	Não aplicável.	Enumerable.Take Queryable.Take
TakeWhile	Obtém elementos com base em uma função de predicado até que um elemento não satisfaça a condição.	Não aplicável.	Enumerable.TakeWhile Queryable.TakeWhile
Chunk	Divide os elementos de uma sequência em partes com tamanho máximo especificado.	Não aplicável.	Enumerable.Chunk Queryable.Chunk

Todos os exemplos a seguir usam Enumerable.Range(Int32, Int32) para gerar uma sequência de números de 0 a 7.

Use o método Take para obter apenas os primeiros elementos de uma sequência:

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

O método Skip é usado para ignorar os primeiros elementos de uma sequência e usar os elementos restantes:

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

Os métodos TakeWhile e SkipWhile também pegam e ignorar elementos em uma sequência. No entanto, em vez de um número fixo de elementos, esses métodos ignoram ou selecionam elementos com base em uma condição. TakeWhile pega os elementos de uma sequência até que um elemento não corresponda à condição de correspondência.

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 ignora os primeiros elementos, desde que a condição seja verdadeira. O primeiro elemento que não corresponder à condição e todos os elementos subsequentes serão retornados.

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

O operador Chunk é usado para dividir elementos de uma sequência com base em determinado 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

O código anterior do C#:

• Depende de Enumerable.Range(Int32, Int32) para gerar uma sequência de números.
• Aplica o operador Chunk, dividindo a sequência em partes com tamanho máximo igual a três.

Confira também

• System.Linq