Partitionnement de données (C#)

Le partitionnement dans LINQ fait référence au fonctionnement de la division d’une séquence d’entrée en deux sections, sans réorganiser les éléments, puis en retournant 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.

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

Opérateurs

Noms de méthode	Descriptif	Syntaxe d’expression de requête C#	Plus d’informations
Sautiller	Ignore les éléments jusqu’à une position spécifiée dans une séquence.	Non applicable.	Enumerable.Skip Queryable.Skip
SkipWhile	Ignore les éléments basés sur une fonction de prédicat jusqu’à ce qu’un élément ne réponde pas à la condition.	Non applicable.	Enumerable.SkipWhile Queryable.SkipWhile
Prendre	Prend des éléments jusqu’à une position spécifiée dans une séquence.	Non applicable.	Enumerable.Take Queryable.Take
TakeWhile	Prend des éléments basés sur une fonction de prédicat jusqu’à ce qu’un élément ne réponde 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 Take méthode pour prendre uniquement 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 Skip méthode 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 TakeWhile méthodes prennent SkipWhile également et ignorent les éléments d’une séquence. Toutefois, au lieu d’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 vraie. Le premier élément qui ne correspond pas à la condition, et tous les éléments suivants, sont retournés.

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) la génération d’une séquence de nombres.
• Applique l’opérateur Chunk , fractionnant la séquence en blocs avec une taille maximale de trois.

Voir aussi

• System.Linq