Partager via

Partitionnement des données (C#)

  • Article

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.

Important

Ces exemples utilisent une source de données System.Collections.Generic.IEnumerable<T>. Les sources de données basées sur System.Linq.IQueryProvider utilisent des sources de données System.Linq.IQueryable<T> et des arborescences d’expressions. Les arborescences d’expressions présentent des limitations sur la syntaxe C# autorisée. De plus, chaque source de données IQueryProvider, telle que EF Core peut imposer des restrictions supplémentaires. Consultez la documentation de votre source de données.

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.

Illustration des trois opérations de partitionnement LINQ.

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