Compartir a través de

Realizar particiones de datos (C#)

  • Artículo

Partición en LINQ es la operación de dividir una secuencia de entrada en dos secciones, sin reorganizar los elementos, y devolver después una de las secciones.

Importante

Estos ejemplos usan un origen de datos System.Collections.Generic.IEnumerable<T>. Los orígenes de datos basados en System.Linq.IQueryProvider usan orígenes de datos de System.Linq.IQueryable<T> y árboles de expresiones. Los árboles de expresión tienen limitaciones en la sintaxis de C# permitida. Además, cada origen de datos de IQueryProvider, como EF Core puede imponer más restricciones. Compruebe la documentación del origen de datos.

En la siguiente ilustración se muestran los resultados de tres operaciones de partición diferentes en una secuencia de caracteres. La primera operación devuelve los tres primeros elementos de la secuencia. La segunda operación omite los tres primeros elementos y devuelve los restantes. La tercera operación omite los dos primeros elementos de la secuencia y devuelve los tres siguientes.

Ilustración que muestra tres operaciones de creación de particiones de LINQ.

Los métodos de operador de consulta estándar que realizan particiones de las secuencias se enumeran en la sección siguiente.

Operadores

Nombres de método Descripción Sintaxis de la expresión de consulta de C# Información adicional
Skip Omite los elementos hasta una determinada posición de una secuencia. No es aplicable. Enumerable.Skip
Queryable.Skip
SkipWhile Omite los elementos según una función de predicado hasta que un elemento no satisface la condición. No aplicable. Enumerable.SkipWhile
Queryable.SkipWhile
Take Admite los elementos hasta una determinada posición de una secuencia. No es aplicable. Enumerable.Take
Queryable.Take
TakeWhile Toma los elementos según una función de predicado hasta que un elemento no satisface la condición. No aplicable. Enumerable.TakeWhile
Queryable.TakeWhile
Fragmento Divide los elementos de una secuencia en fragmentos de un tamaño máximo especificado. No aplicable. Enumerable.Chunk
Queryable.Chunk

Todos los ejemplos siguientes usan Enumerable.Range(Int32, Int32) para generar una secuencia de números de 0 a 7.

Use el método Take para tomar solo los primeros elementos de una secuencia:

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

Use el método Skip para omitir los primeros elementos de una secuencia y usar los 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

Los métodos TakeWhile y SkipWhile también toman y omiten elementos en una secuencia. Sin embargo, en lugar de un número establecido de elementos, estos métodos omiten o toman elementos en función de una condición. TakeWhile toma los elementos de una secuencia hasta que un elemento no coincide con la condición.

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 omite los primeros elementos, siempre y cuando la condición sea verdadera. Se devuelve el primer elemento que no coincide con la condición y todos los elementos posteriores.

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

El operador Chunk se usa para dividir los elementos de una secuencia en función de un valor size determinado.

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

El código de C# anterior:

  • Se basa en Enumerable.Range(Int32, Int32) para generar una secuencia de números.
  • Aplica el operador Chunk y divide la secuencia en fragmentos con un tamaño máximo de tres.

Consulte también