Particionamento de dados (C#)

Particionamento no LINQ refere-se à operação de divisão de uma sequência de entrada em duas seções, sem reorganizar os elementos e, em seguida, 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 do operador de consulta padrão que particionam as sequências estão listados na seção a seguir.

Operadores

Nomes de método	Descrição	Sintaxe da expressão de consulta 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 atenda à condição.	Não aplicável.	Enumerable.SkipWhile Queryable.SkipWhile
Tomar	Leva elementos até uma posição especificada em uma sequência.	Não aplicável.	Enumerable.Take Queryable.Take
TakeWhile	Seleciona elementos com base em uma função condicional até que um elemento não satisfaça a condição.	Não aplicável.	Enumerable.TakeWhile Queryable.TakeWhile
Pedaço	Divide os elementos de uma sequência em partes de um 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.

Observação

Você pode consultar as fontes de dados comuns para essa área no artigo Visão Geral dos Operadores de Consulta Padrão .

Use o Take método para pegar apenas os primeiros elementos em 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

Use o Skip método para ignorar os primeiros elementos em 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 definido de elementos, esses métodos ignoram ou tomam elementos com base em uma condição. TakeWhile usa os elementos de uma sequência até que um elemento não corresponda à condição.

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 corresponde à condição e todos os elementos subsequentes sã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 Chunk operador é usado para dividir elementos de uma sequência com base em um 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 C# anterior:

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

Consulte também

• System.Linq