Partitionnement des données (C#)

Le partitionnement dans LINQ désigne l’opération consistant à diviser une séquence d’entrée en deux sections, sans réorganiser les éléments, puis à retourner l’une des sections.

L’illustration suivante montre les résultats de trois opérations de partitionnement différentes sur une séquence de caractères. La première opération retourne les trois premiers éléments de la séquence. La deuxième opération ignore les trois premiers éléments et retourne les éléments restants. La troisième opération ignore les deux premiers éléments de la séquence et retourne les trois éléments suivants.

Les méthodes d’opérateurs de requête standard qui partitionnent des séquences sont répertoriées dans la section suivante.

Opérateurs

Noms des méthodes	Description	Syntaxe d'expression de requête C#	Informations complémentaires
Ignorer	Ignore les éléments jusqu’à une position spécifiée dans une séquence.	Non applicable.	Enumerable.Skip Queryable.Skip
SkipWhile	Ignore des éléments selon une fonction de prédicat jusqu’à un élément qui ne remplit pas la condition.	Non applicable.	Enumerable.SkipWhile Queryable.SkipWhile
Take	Prend les éléments jusqu’à une position spécifiée dans une séquence.	Non applicable.	Enumerable.Take Queryable.Take
TakeWhile	Prend des éléments selon une fonction de prédicat jusqu’à un élément qui ne remplit pas la condition.	Non applicable.	Enumerable.TakeWhile Queryable.TakeWhile
Bloc	Fractionne les éléments d’une séquence en blocs d’une taille maximale spécifiée.	Non applicable.	Enumerable.Chunk Queryable.Chunk

Tous les exemples suivants utilisent Enumerable.Range(Int32, Int32) pour générer une séquence de nombres compris entre 0 et 7.

Vous utilisez la méthode Take pour ne prendre que les premiers éléments d’une séquence :

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

Vous utilisez la méthode Skip pour ignorer les premiers éléments d’une séquence et utiliser les éléments restants :

foreach (int number in Enumerable.Range(0, 8).Skip(3))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 3
// 4
// 5
// 6
// 7

Les méthodes TakeWhile et SkipWhile prennent et ignorent également les éléments d’une séquence. Toutefois, plutôt qu’un nombre défini d’éléments, ces méthodes ignorent ou prennent des éléments en fonction d’une condition. TakeWhile prend les éléments d’une séquence, jusqu’à ce qu’un élément ne corresponde pas à la condition.

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 ignore les premiers éléments, tant que la condition est vérifiée. Le premier élément qui ne respecte pas la condition, tout comme les éléments suivants, est retourné.

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

L’opérateur Chunk est utilisé pour fractionner des éléments d’une séquence en fonction d’un donné 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

Le code C# précédent :

• S’appuie sur Enumerable.Range(Int32, Int32) pour générer une séquence de nombres.
• Applique l’opérateur Chunk, fractionnant la séquence en blocs d’une taille maximale de trois.

Voir aussi

• System.Linq