Particionamento de dados (C#)

O particionamento no LINQ refere-se à operação de dividir 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 System.Collections.Generic.IEnumerable<T> dados. Fontes de dados baseadas em System.Linq.IQueryProvider utilizam fontes de dados System.Linq.IQueryable<T> e árvores de expressão . As árvores de expressão têm limitações na sintaxe C# permitida. Além disso, cada IQueryProvider fonte de dados, como o EF Core , pode impor mais restrições. Verifique a documentação da sua 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 próximos três elementos.

Ilustração que mostra três operações de particionamento LINQ.

Os métodos do 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 da expressão de consulta C# Mais informações
Pular Ignora elementos até uma posição especificada numa 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
Pegue Leva elementos até uma posição especificada em uma sequência. Não aplicável. Enumerable.Take
Queryable.Take
TakeWhile Seleciona elementos com base numa função de predicado até encontrar um elemento que não satisfaça a condição. Não aplicável. Enumerable.TakeWhile
Queryable.TakeWhile
Segmento 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 são usados 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 .

Você usa 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 use 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 recebem e ignoram elementos numa sequência. No entanto, em vez de um número definido de elementos, esses métodos ignoram ou usam 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 dado 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.

Ver também

  • Last updated on