Académique Documents
Professionnel Documents
Culture Documents
CHAPITRE 3:
LE LANGAGE DE REQUETES LINQ
ENSEIGNANT :
MALEK ZRIBI
INTRODUCTION
4
SYNTAXE DE REQUÊTE LINQ
Créer la requête.
Exécutez la requête.
5
EXEMPLE : SYNTAXE DE REQUETE LINQ
7
LAMBDA EXPRESSION
Une expression lambda est composée de trois parties :
Une liste de paramètres
Le signe =>
Une expression
Paramètres Expression
8
SYNTAXE DE MÉTHODE LINQ
9
SYNTAXE DE MÉTHODE LINQ - EXEMPLE
10
LES OPÉRATEURS DE REQUÊTES
11
LES OPÉRATEURS DE REQUÊTES
Classification Opérateur de requête standard
Filtrage Where, OfType
Tri OrderBy, OrderByDescending, ThenBy, Reverse, ThenByDescending
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.
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)
19
L’OPÉRATEUR WHERE
22
TRI DES DONNÉES
OrderByDescending,
ThenBy,
ThenByDescending
23
L’OPÉRATEUR ORDERBY
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
27
LE GROUPEMENT AVEC LA CLAUSE GROUPBY
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
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.
35
L’AGRÉGATION
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
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)
Sortie :
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)
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