Realizar particiones de datos (C#)

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.

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.

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

• System.Linq