Realizar particiones de datos (C#)

La creación de particiones en LINQ hace referencia al funcionamiento de dividir una secuencia de entrada en dos secciones, sin reorganizar los elementos y, a continuación, devolver 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 usanSystem.Linq.IQueryable<T> orígenes de datos y árboles de expresión . Los árboles de expresión tienen limitaciones en la sintaxis de C# permitida. Además, cada origen de datos IQueryProvider, como EF Core puede imponer más restricciones. Compruebe la documentación del origen de datos.

En la ilustración siguiente se muestran los resultados de tres operaciones de creación de particiones 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 elementos restantes. La tercera operación omite los dos primeros elementos de la secuencia y devuelve los tres elementos siguientes.

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

Operadores

Nombres de método	Descripción	Sintaxis de expresiones de consulta de C#	Información adicional
Omitir	Omite los elementos hasta una posición especificada en una secuencia.	No aplicable.	Enumerable.Skip Queryable.Skip
SkipWhile	Omite los elementos basados en una función de predicado hasta que un elemento no cumple la condición.	No aplicable.	Enumerable.SkipWhile Queryable.SkipWhile
Tomar	Toma elementos hasta una posición especificada en una secuencia.	No aplicable.	Enumerable.Take Queryable.Take
TakeWhile	Toma elementos basados en una función de predicado hasta que un elemento no cumple 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.

Nota:

Puede consultar los orígenes de datos comunes de esta área en el artículo Información general sobre operadores de consulta estándar .

Use el Take método 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 Skip método para omitir los primeros elementos de una secuencia y use 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 TakeWhile métodos 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 Chunk operador se usa para dividir elementos de una secuencia en función de un 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

El código de C# anterior:

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

Consulte también

• System.Linq