Vous êtes sur la page 1sur 50

ASP.

NET MVC AVEC C#

CHAPITRE 3:
LE LANGAGE DE REQUETES LINQ

ENSEIGNANT :
MALEK ZRIBI
INTRODUCTION

 LINQ est une abréviation pour Language-INtegrated


Query, C’est un composant intégré dans .NET
Framework. (namespace System.Linq)
 Il est inspiré du langage SQL et il fournit une syntaxe
de requête uniforme utilisée pour enregistrer et
récupérer des données provenant de différentes
sources.
 Il est intégré à C# ou à VB.NET, tout en éliminant les
disparités entre les langages de programmation et les
bases de données,
 Une interface de requête unique pour différents types
de sources de données.
2
INTRODUCTION
Selon la source de données interrogée, on distingue :
 LINQ to Object : Liée à l’utilisation de collections
(Liste, IEnumerable …)
 LINQ to Entities : Liée à l’utilisation de l’Entity
Model de .NET
 LINQ to SQL : Liée à des requêtes SQL
 LINQ to DataSet : Liée à l’utilisation de DataSet
 LINQ to XML : Liée à l’utilisation de données XML
Il existe deux méthodes de base pour écrire une
requête LINQ dans une collection IEnumerable ou des
sources de données IQueryable :
 En utilisant une syntaxe de requête.
 Ou une syntaxe de méthode ou méthode
d'extension 3
SYNTAXE DE REQUÊTE LINQ

 La syntaxe de requête LINQ est similaire à la


syntaxe SQL pour l’accès aux bases de données.
 c’est l’ordre des mots clés qui est inversé, il commence
par le mot clé from et se termine par le mot-clé
select.
from < variable intervalle> in <IEnumerable<T> ou
IQueryable<T> Collection>
< Opérateurs de requête standard > < expression
lambda >
< Opérateur select ou groupBy > <format du
résultat>

4
SYNTAXE DE REQUÊTE LINQ

 Après la clause From, vous pouvez utiliser différents


opérateurs de requête standard pour filtrer, grouper,
joindre des éléments de la collection.
 Dans LINQ, il existe environ 50 opérateurs de
requêtes standards disponibles.
 Toutes les opérations de requête LINQ consistent en
trois actions distinctes :
 Obtenir la source de données.

 Créer la requête.

 Exécutez la requête.

5
EXEMPLE : SYNTAXE DE REQUETE LINQ

// Les trois parties d'une requête LINQ :


// 1. Source de données
int[] Nombres = new int[10] {0, 1, 5, 8, 14, 25,
6, 8, 11, 46};
// 2. Création de la requête
var NBPairs = from Nb in Nombres
where (Nb % 2) == 0
select Nb;
// 3. Exécution de la requête
foreach (int Nb in NBPairs)
{
Console.Write("{0} ", Nb);
6
}
LAMBDA EXPRESSION

 Les expressions Lambda sont des méthodes


anonymes (une méthode anonyme est une méthode
qui possède un corps, mais n’a pas de nom) contenant
des expressions ou une séquence d'opérateurs.
 Toutes les expressions lambda utilisent l'opérateur
lambda => dans leurs syntaxes.
 Le côté gauche de l'opérateur lambda spécifie les
paramètres d'entrée et le côté droit contient une
expression ou un bloc de code exécuté en fonction des
paramètres d'entrée et renvoie éventuellement un
résultat.

7
LAMBDA EXPRESSION
Une expression lambda est composée de trois parties :
 Une liste de paramètres

 Le signe =>

 Une expression

X => X >0 && X < 20


(X,N)=> X >N && X < 20
() => Console.Write("Expression lambda sans paramètre");

Paramètres Expression

8
SYNTAXE DE MÉTHODE LINQ

Resultat = <IEnumerable<T> ou IQueryable<T>


Collection>.<Métohe d’extension(< expression lambda >)
 Les méthodes d'extension sont des opérateurs de
requête standard LINQ qui ajoutent une
fonctionnalité de requête aux types
System.Collections.IEnumerable et
System.Collections.Generic.IEnumerable <T>
existants.
 Tout type qui implémente IEnumerable <T> possède
des méthodes d'instance telles que GroupBy,
OrderBy, Average, etc.

9
SYNTAXE DE MÉTHODE LINQ - EXEMPLE

int[] Nombres = new int[10]


{ 0, 1,5, 8, 14, 25, 6,8,11,46 };
var NBPairs=Nombres.Where(Nb=> (Nb % 2) == 0);
foreach (int Nb in NBPairs)
{
Console.Write("{0} ", Nb);
}

10
LES OPÉRATEURS DE REQUÊTES

 Les opérateurs de requête standard dans LINQ sont


en réalité des méthodes d'extension pour les types
IEnumerable <T> et IQueryable <T>.
 Ils sont définis dans les classes
System.Linq.Enumerable et System.Linq.Queryable.
 Il existe plus de 50 opérateurs de requête standard
disponibles dans LINQ qui fournissent différentes
fonctionnalités telles que le tri, le regroupement, le
filtrage l'agrégation, la concaténation, etc.

11
LES OPÉRATEURS DE REQUÊTES
Classification Opérateur de requête standard
Filtrage Where, OfType
Tri OrderBy, OrderByDescending, ThenBy, Reverse, ThenByDescending

Groupement GroupBy, ToLookup


Jointure GroupJoin, Join
Projection Select, SelectMany
Agrégation Aggregate, Average, Count, LongCount, Max, Min, Sum

Quantificateurs All, Any, Contains


Éléments ElementAt, ElementAtOrDefault, First, FirstOrDefault, Last,
LastOrDefault, Single, SingleOrDefault

Ensemble Distinct, Except, Intersect, Union


Partitionnement Skip, SkipWhile, Take, TakeWhile
Concaténation Concat
Egalité SequenceEqual
Génération DefaultEmpty, Empty, Range, Repeat 12
Conversion AsEnumerable, AsQueryable, Cast, ToArray, ToDictionary, ToList
EXEMPLE

 Dans la partie suivante, nous allons nous baser sur la


classe Client et la collection LClient suivants pour
expliquer les différents opérateurs LINQ :
class Client
{
public Int64 CIN_Cl { get; set; }
public String Nom_Cl { get; set; }
public String Prenom_Cl { get; set; }
public String Ville_Cl { get; set; }
public Int64 Tel_Cl { get; set; }
} 13
EXEMPLE

List<Client> LClient = new List<Client>{


new Client() { CIN_Cl = 10023321, Nom_Cl="Tounsi",
Prenom_Cl = "Aymen", Ville_Cl="Tunis", Tel_Cl = 22324566
},
new Client() { CIN_Cl = 11367588, Nom_Cl="Soussi",
Prenom_Cl = "Ali", Ville_Cl="Sousse", Tel_Cl = 99745521
},
new Client() { CIN_Cl = 11556477, Nom_Cl="Sfaxi",
Prenom_Cl = "Linda", Ville_Cl="Sfax", Tel_Cl = 44321155
},
new Client() { CIN_Cl = 10004532, Nom_Cl="Ben Ahmed",
Prenom_Cl = "Youssef", Ville_Cl="Tunis", Tel_Cl = 40665433
},
new Client() { CIN_Cl = 12134456, Nom_Cl="Tounsi",
Prenom_Cl = "Sofien", Ville_Cl="Sfax", Tel_Cl = 20556439
}
14
};
PROJECTION DES DONNÉES

 La projection est la transformation des données d’une


requête suite à l’application d'un filtre pour modifier le type
de la collection renvoyée.
 Deux opérateurs de projection sont disponibles dans LINQ :
Select et SelectMany.
 Opérateur Select :

//Utilisation de la syntaxe de requête


var Liste_Select = from Cl in LClient
select Cl;
//Ou bien utilisation de la syntaxe de méthode
var Liste_Select1 = LClient.Select(Cl=>Cl);
foreach (var c in Liste_Select)
Console.WriteLine("{0} : {1}",c.CIN_Cl, c.Nom_Cl +
c.Prenom_Cl); 15
PROJECTION DES DONNÉES

 Opérateur SelectMany :
 SelectMany est un opérateur utilisé pour "aplatir" une
séquence dans laquelle chacun des éléments de la séquence
est une séquence distincte et subordonnée.

 Par exemple, SelectMany() peut transformer un tableau à


deux dimensions en une seule séquence de valeurs, comme
indiqué dans cet exemple :

16
PROJECTION DES DONNÉES

int[][] TabInt = {
new[] {1, 2, 3},
new[] {4},
new[] {5, 6, 7, 8},
new[] {12, 14}
};
IEnumerable<int> Resultat =
TabInt.SelectMany(tab => tab);
foreach (int res in Resultat)
Console.Write(res + " ");

17
SELECTMANY- EXEMPLE 2
List<string> Mots_Cles = new List<string>() { "Livre C#",
"Framework .NET", "WPF Et ASP.NET" };
//Utilisation de la syntaxe de requête
var Resultat = from mot_cle in Mots_Cles
from mot in mot_cle.Split(' ')
select mot;
//Ou bien utilisation de la syntaxe de méthode
var Resultat1 = Mots_Cles.SelectMany(mot_cle =>
mot_cle.Split(' '));
foreach (string res in Resultat1)
Console.WriteLine(res);

18
FILTRAGE DES DONNÉES (WHERE, OFTYPE)

L’opération de filtrage dans LINQ consiste à filtrer afin


de réduire les éléments de la séquence (collection) en
fonction d’un certain nombre de critères.

 Opérateur Where : L’opérateur Where renvoie les


valeurs de la collection basées sur une fonction de
prédicat.

19
L’OPÉRATEUR WHERE

//Utilisation de la syntaxe de requête


var LC_Filtre = from Cl in LClient
where Cl.Ville_Cl.Equals("Sfax")
select Cl;
//Ou bien utilisation de la syntaxe de méthode
var LC_Filtre1= LClient.Where(Cl =>
Cl.Ville_Cl.Equals("Sfax"));
//Affichage de la liste filtrée
foreach (Client c in LC_Filtre)
Console.WriteLine("{0} {1}", c.Nom_Cl,
c.Prenom_Cl); 20
L’OPÉRATEUR OFTYPE
L'opérateur OfType filtre une collection donnée en fonction de la
possibilité de convertir un élément de la collection en un type spécifié.
ArrayList Liste = new ArrayList();
Liste.Add(10);
Liste.Add("Livre C#");
Liste.Add("Framework .Net");
Liste.Add(3);
Liste.Add(new Client() { CIN_Cl = 100233, Nom_Cl = "Tounsi",
Prenom_Cl = "Aymen", Ville_Cl = "Tunis", Tel_Cl = 22324566 });
//Utilisation de la syntaxe de requête
var Liste_String = from s in Liste.OfType<string>()
select s;
//Ou bien utilisation de la syntaxe de méthode
var Liste_String1 = Liste.OfType<string>();
Console.WriteLine("\nListe des chaînes");
foreach (string s in Liste_String) 21
Console.Write("{0} ", s);
L’OPÉRATEUR OFTYPE
Console.WriteLine("\nListe des entiers");
//Utilisation de la syntaxe de requête
var Liste_Int = from s in Liste.OfType<int>()
select s;
var Liste_Int = Liste.OfType<int>();
foreach (int x in Liste_Int)
Console.Write("{0} ", x);

22
TRI DES DONNÉES

 L’opération de tri consiste à organiser les éléments


d’une collection par ordre croissant ou décroissant et
ce selon un ou plusieurs critères.
 les opérateurs de tri sont :
 OrderBy,

 OrderByDescending,

 ThenBy,

 ThenByDescending

23
L’OPÉRATEUR ORDERBY

Tri de la liste par ordre croissant de CIN_Cl


//Utilisation de la syntaxe de requête
var LC_Triee = from Cl in LClient
orderby Cl.CIN_Cl ascending
select Cl;
//Utilisation de la syntaxe de méthode
var LC_Triee1 = LClient.OrderBy(cl=>cl.CIN_Cl);
foreach (Client c in LC_Triee)
Console.WriteLine("{0}:{1} {2}",c.CIN_Cl,
c.Nom_Cl, c.Prenom_Cl);
24
L’OPÉRATEUR ORDERBYDESCENDING

 L’opérateur OrderByDescending trie la collection par


ordre décroissant.
 Cet opérateur est valide uniquement avec la syntaxe
de méthode.
var LC_Triee1 =
LClient.OrderByDescending(cl=>cl.CIN_Cl);

25
TRI MULTIPLE
 La collection peut être triée selon plusieurs champs séparés
par une virgule.
 La collection serait d'abord triée sur la base du premier
champ, puis si la valeur du premier champ était identique
pour deux éléments, le second champ serait utilisé pour le
tri, etc.
var LC_Triee = from Cl in LClient
orderby Cl.Nom_Cl, Cl.Prenom_Cl
select new
{ Cl.CIN_Cl,
NomPren = Cl.Nom_Cl + " " + Cl.Prenom_Cl
};
foreach (var c in LC_Triee)
Console.WriteLine("{0}:{1} ", c.CIN_Cl, c.NomPren); 26
Console.Read();
L’OPÉRATEUR THENBY ET THENBYDESCENDING

 Disponibles uniquement pour les méthodes d’extension


Exemple :
Tri croissant par cin puis en deuxième critère par nom
décroissant
var LC_Triee =
LClient.OrderBy(cl=>cl.CIN_Cl).ThenByDescending(
cl=>cl.Nom_Cl);

27
LE GROUPEMENT AVEC LA CLAUSE GROUPBY

 Les opérateurs Linq de regroupement jouent le même


rôle que la clause GroupBy de la requête SQL.
 Les opérateurs de regroupement créent un groupe
d’éléments basé sur une clé donnée
Exemple :
Afficher la liste des clients groupés par ville
//Utilisation de la syntaxe de requête
var Groupe_Client = from Cl in LClient
group Cl by Cl.Ville_Cl;

28
LE GROUPEMENT AVEC LA CLAUSE GROUPBY
//Utilisation de la syntaxe de méthode
var Groupe_Client1 = LClient.GroupBy(cl => cl.Ville_Cl);
//itération pour chaque groupe
foreach (var gCl in Groupe_Client)
{
Console.WriteLine("Ville : {0}", gCl.Key); //clé du groupe
foreach (Client c in gCl)
// Chaque groupe possède une collection interne
Console.WriteLine("{0} {1}", c.Nom_Cl, c.Prenom_Cl);
}

29
LA JOINTURE

 La jointure correspond à l’association d’une


collection de données avec les objets d’une autre
collection de données ayant une propriété commune.
 On va créer une nouvelle classe Commande ayant
comme propriété commune avec la classe Client, le
champ CIN_Cl,
 Puis on va créer une collection LCommande, qu’on
va utiliser dans le reste des exemples.
class Commande
{ public int Num_Cde{ get; set; }
public Int64 CIN_Cl { get; set; }
public DateTime Date_Cde { get; set; }
} 30
LA JOINTURE
List<Commande> LCommande = new List<Commande>
{
new Commande(){Num_Cde=10020,CIN_Cl=10023321,Date_Cde=new
DateTime(2016,09,15)},
new Commande(){Num_Cde=12114,CIN_Cl=10023321,Date_Cde=new
DateTime(2017,01,05)},
new Commande(){Num_Cde=45334,CIN_Cl=10023321,Date_Cde=new
DateTime(2017,10,23)},
new Commande(){Num_Cde=23112,CIN_Cl=12134456,Date_Cde=new
DateTime(2017,06,20)},
new Commande(){Num_Cde=33246,CIN_Cl=12134456,Date_Cde=new
DateTime(2017,08,12)},
new Commande(){Num_Cde=55112,CIN_Cl=11556477,Date_Cde=new
DateTime(2017,12,01)}
31
};
L’OPÉRATEUR JOIN
 L'opérateur Join opère sur deux collections, une collection
interne et une collection externe.
 Elle retourne une nouvelle collection contenant des éléments
des deux collections qui répondent à l'expression spécifiée.
 Cet opérateur joue le même rôle que la jointure interne de
SQL.
var Liste_Join = from Cl in LClient//séquence externe
join Cde in LCommande //séquence interne
on Cl.CIN_Cl equals Cde.CIN_Cl //clé jointure
select new
{ //résultat de jointure
NomPren = Cl.Nom_Cl+" "+Cl.Prenom_Cl,
NumCde = Cde.Num_Cde }; 32
L’OPÉRATEUR JOIN
foreach (var c in Liste_Join)
Console.WriteLine("{0}:{1}",c.NomPren,c.NumCde);

33
L’AGRÉGATION
Les opérations d’agrégation sont utilisées pour effectuer
un calcul d’une valeur unique à partir d’une collection de
valeurs. Les opérations les plus courantes sont :
 Aggregate : effectue une opération d'agrégation
personnalisée sur les valeurs d’une collection,
 Average : calcule la moyenne des éléments
numériques dan une collection.
 Count et LongCount : permettent de calculer le
nombre d’éléments dans une collection.
 Max :renvoie la valeur Maximale dans une collection.

 Min: renvoie la valeur Minimale dans une collection.

 Sum : permet de calculer la somme des valeurs dans


une collection. 34
L’AGRÉGATION

L’exemple suivant permet d’effectuer une agrégation sur


un tableau de valeurs entières pour renvoyer la valeur
correspondante au produit de la liste des valeurs :

int[] Valeurs = new int[4] { 1, 2, 10, 5 };


var ValeursMultiples = Valeurs.Aggregate((a,b)
=> a * b);
Console.WriteLine(ValeursMultiples);
//Affiche 100 (1 * 2 * 10 * 5)

35
L’AGRÉGATION

Dans cet exemple, on va essayer de tester tous les opérateurs


d’agrégation en prenant comme base un tableau de Notes :
double[] Notes = new double[5] {12.5, 8, 15.5, 7, 20 };
double Moy_Notes = Notes.Average();
Console.WriteLine("Moyenne des Notes : " + Moy_Notes);
double Nb_Notes = Notes.Count();
Console.WriteLine("Nombre de Notes : " + Nb_Notes);
double Max_Notes = Notes.Max();
Console.WriteLine("Valeur Maximale : " + Max_Notes);
double Min_Notes = Notes.Min();
Console.WriteLine("Valeur Minimale : " + Min_Notes);
double Som_Notes = Notes.Sum();
Console.WriteLine("Somme des Notes :" + Som_Notes); 36
LES QUANTIFICATEURS (ALL, ANY, CONTAINS)

 Les opérateurs quantificateurs évaluent les éléments


d’une collection de données selon certaines conditions
et renvoient une valeur booléenne pour indiquer que
certains ou tous les éléments satisfont à cette
condition.
 Dans cet exemple, on va tester les trois opérateurs All,
Any et Contains sur la même liste de notes
précédente :

37
LES QUANTIFICATEURS (ALL, ANY, CONTAINS)
bool Note_Valide = Notes.All(not => not >= 0 && not <= 20);
Console.WriteLine("Toutes les notes sont valides : " +
Note_Valide);
bool Note_Non_Valide = Notes.Any(not => not < 0 || not > 20);
Console.WriteLine("Contient notes non valides : " +
Note_Non_Valide);
double X = 10;
bool Note_Existe = Notes.Contains(X);
Console.WriteLine("Note {0} Existe dans le tableau: {1}",X,
Note_Existe);

38
LES OPÉRATEURS D’ÉLÉMENTS
Les opérateurs d'élément renvoient un élément particulier
dans une collection de données. On distingue les
opérateurs :
 ElementAt : renvoie l'élément à un index spécifié dans
une collection ;
 ElementAtOrDefault : retourne l'élément à un index
spécifié dans une collection ou une valeur par défaut si
l'index est hors limites ;
 First : retourne le premier élément d'une collection ou le
premier élément qui vérifie une condition ;
 FirstOrDefault : retourne le premier élément d'une
collection ou le premier élément qui vérifie une condition.
Il retourne une valeur par défaut si l’index est hors
limites ;
 Last : retourne le dernier élément d'une collection ou 39le
dernier élément qui vérifie une condition ;
LES OPÉRATEURS D’ÉLÉMENTS

 LastOrDefault : retourne le dernier élément d'une


collection ou le dernier élément qui vérifie une
condition. Retourne une valeur par défaut si aucun
élément de ce type n'existe.
 Single : retourne le seul élément d'une collection ou le
seul élément qui vérifie une condition.
 SingleOrDefault : retourne le seul élément d'une
collection ou le seul élément qui vérifie une condition.
Retourne une valeur par défaut si un tel élément
n'existe pas ou si la collection ne contient pas
exactement un élément.

40
EXEMPLE
double[] Notes = new double[5] { 12.5, 8, 15.5,
7, 20 }; Console.WriteLine("Note à l'indice 1 :
{0}", Notes.ElementAt(1));
Console.WriteLine("Note à l'indice 10 : {0}",
Notes.ElementAtOrDefault(10));
Console.WriteLine("1ère Note : {0}",
Notes.First());
Console.WriteLine("Dernière Note : {0}",
Notes.Last());
Console.WriteLine("Note comprise entre 10 et 15 :
{0}", Notes.Single(not=>not>=10 && not<=15));

41
LES ENSEMBLES (DISTINCT, EXCEPT, INTERSECT, UNION)
Différents opérateurs sont disponibles dans LINQ
permettant de définir des conditions pour la sélection
d’un ensemble d’éléments dans une collection. Les
opérateurs disponibles sont :
 Distinct : renvoie les valeurs distinctes dans une
collection ;
 Except : renvoie la différence entre deux séquences,
c'est-à-dire les éléments d'une collection qui
n'apparaissent pas dans la deuxième collection ;
 Intersect : renvoie l'intersection de deux séquences, ce
qui signifie les éléments apparaissant dans les deux
collections.
 Union : renvoie des éléments uniques à partir de deux
séquences, ce qui signifie les éléments uniques
apparaissant dans l'une ou l'autre des séquences. 42
LES ENSEMBLES (DISTINCT, EXCEPT, INTERSECT, UNION)
int[] Liste1 = new int[10]
{ 12, 5, 5, 8, 15, 8, 10, 20, 5, 33 };
int[] Liste2 = new int[5]
{ 10, 5, 24, 67, 12 };
var Liste_Distinct = Liste1.Distinct();
Console.WriteLine("Liste d'éléments distincts");
foreach (int n in Liste_Distinct)
Console.Write("{0} ", n);
var Liste_Expect = Liste1.Except(Liste2);
Console.WriteLine("\nDifférence entre Liste1 et
Liste2");
foreach (int n in Liste_Expect)
Console.Write("{0} ", n); 43
LES ENSEMBLES (DISTINCT, EXCEPT, INTERSECT, UNION)

var Liste_Intersect = Liste1.Intersect(Liste2);


Console.WriteLine("\nIntersection entre Liste1 et Liste2");
foreach (int n in Liste_Intersect)
Console.Write("{0} ", n);
var Liste_Union = Liste1.Union(Liste2);
Console.WriteLine("\nUnion entre Liste1 et Liste2");
foreach (int n in Liste_Union)
Console.Write("{0} ", n);

Sortie :

Liste d'éléments distincts


12 5 8 15 10 20 33
Différence entre Liste1 et Liste2
8 15 20 33
Intersection entre Liste1 et Liste2
12 5 10
Union entre Liste1 et Liste2
12 5 8 15 10 20 33 24 67
44
PARTITIONNEMENT DES DONNÉES
(SKIP, SKIPWHILE, TAKE, TAKEWHILE)
Les opérateurs de partitionnement divisent la
séquence (collection) en deux parties et renvoient l'une
des parties. Les opérateurs de partitionnement
disponibles sont :
 Skip : ignore les éléments d’une collection jusqu'à
une position spécifiée à partir du premier élément.
 SkipWhile : ignore les éléments en fonction d'une
condition spécifiée jusqu'à ce qu'un élément ne
satisfasse pas à la condition.
Si le premier élément lui-même ne satisfait pas la
condition, il ignore 0 élément et renvoie tous les
éléments de la séquence.
45
PARTITIONNEMENT DES DONNÉES
(SKIP, SKIPWHILE, TAKE, TAKEWHILE)

 Take : prend les éléments jusqu'à une position


spécifiée à partir du premier élément d'une
séquence.
 TakeWhile : renvoie les éléments à partir du
premier élément jusqu'à ce qu'un élément ne
réponde pas à la condition. Si le premier élément
lui-même ne satisfait pas la condition, une
collection vide est renvoyée.

46
PARTITIONNEMENT DES DONNÉES
(SKIP, SKIPWHILE, TAKE, TAKEWHILE)
int[] Liste =
new int[10] { 5, 3, 7, 9, 18, 15, 4, 20, 33 ,89};
var Liste_Skip = Liste.Skip(2);
Console.WriteLine("Liste d'éléments à partir de
l’indice 2");
foreach (int n in Liste_Skip)
Console.Write("{0} ", n);
var Liste_SkipWhile = Liste.SkipWhile(n => n<10);
Console.WriteLine("\nListe d'éléments à partir du 1er
élément non inférieur à 10");
foreach (int n in Liste_SkipWhile)
Console.Write("{0} ", n);
var Liste_Take = Liste.Take(6);
Console.WriteLine("\nListe des 6 premiers éléments");
47
foreach (int n in Liste_Take)
Console.Write("{0} ", n);
PARTITIONNEMENT DES DONNÉES
(SKIP, SKIPWHILE, TAKE, TAKEWHILE)

var Liste_TakeWhile = Liste.TakeWhile(n => n < 10);


Console.WriteLine("\nListe d'éléments à partir du 1er
élément inférieurs à 10");
foreach (int n in Liste_TakeWhile)
Console.Write("{0} ", n);

48
CONCATÉNATION DES DONNÉES (CONCAT)
 La méthode Concat () ajoute deux séquences du même
type et renvoie une nouvelle séquence (collection).
int[] Liste1 = new int[10]
{ 5, 3, 7, 9, 18, 15, 4, 20, 33, 89 };
int[] Liste2 = new int[5]
{ 10, 5, 24, 67, 12 };
var Liste_Concat = Liste1.Concat(Liste2);
Console.WriteLine("\nListe d'éléments de la liste
concaténée");
foreach (int n in Liste_Concat)
Console.Write("{0} ", n);
49
L’ÉGALITÉ (SEQUENCEEQUAL)
 La méthode SequenceEqual vérifie si le nombre d'éléments,
la valeur de chaque élément et l'ordre des éléments dans
deux collections sont tous égaux ou non.
int[] Liste1 = new int[10]
{ 5, 3, 7, 9, 18, 15, 4, 20, 33, 89 };
int[] Liste2 = new int[5] { 10, 5, 24, 67, 12 };
int[] Liste3 = new int[5] { 10, 5, 24, 67, 12 };
bool Egalité_L1_L2 = Liste1.SequenceEqual(Liste2);
Console.WriteLine("Egalite Liste1 et Liste2 : {0}",
Egalité_L1_L2);
bool Egalité_L2_L3 = Liste2.SequenceEqual(Liste3);
Console.WriteLine("Egalite Liste2 et Liste3 : {0}",
Egalité_L2_L3);
Sortie :

50
Egalite Liste1 et Liste2 : False
Egalite Liste2 et Liste3 : True