Language INtegrated QueryLINQ

1. Language INtegrated Query
LINQ
1

2. Plan:
Definition2
Introduction1
Linq To ADO.net4
Conclusion6
Linq To Object3
Linq To XML5
2

3. Introduction:
 la multiplication des sources de données :
 Les collections objets
 Les bases de données relationnelles
 Les frameworks Object Relational Mapping (Entity Framework chez
Microsoft)
 Les fichiers XML et ses déclinaisons (eXtensible Markup Language)
 Les autres fichiers structurés (CSV, tableurs, ...)
 ...
3

4. Problématique ?
 connaitre environ 3 à 4 ‘langages ’ de requête:
 SQL (Structured Query Language) : Requête des bases de données relationnelles
 XML : Pour construire des fichiers de données
 XPath : Requête des fichiers XML
 Les requêtes sont considérées comme de simples chaînes de caractères
pouvant contenir des erreurs et entrainer de grandes difficultés à les
corriger
4

5. LINQ
5

6. Définition de LINQ:
 LINQ (Language Integrated Query) est un ensemble de
fonctionnalités introduites dans Visual Studio 2008 qui étend les
fonctions de requête puissantes à la syntaxe des langages C# et
Visual Basic.
 LINQ propose des modèles standard et simples d'apprentissage pour
l'interrogation et la mise à jour des données, et la technologie peut
être étendue pour prendre en charge presque tout type de magasin
de données.
6

7. Définition de LINQ:
 Visual Studio inclut les assemblys de fournisseur LINQ qui
permettent l'utilisation de LINQ avec des collections dans le .NET
Framework, des bases de données SQL Server, des jeux de données
ADO.NET et des documents XML.
7

8. L‘Architecture de LINQ:
8

9. 9

10. LINQ To Object
 Il s'agit d'extensions permettant de faire des requêtes sur les
objets en mémoire et notamment sur toutes les listes ou
collections.
 Toutes les opérations de requête LINQ comportent trois actions
distinctes :
 Obtenir la source de données.
 Créer la requête.
 Exécuter la requête.
10

11. Exemple:
List<int> liste = new List<int> { 4, 6, 1, 9, 5, 15, 8, 3 };
foreach (int i in liste)
if (i > 5)
{ Console.WriteLine(i);
} }
List<int> liste = new List<int> { 4, 6, 1, 9, 5, 15, 8, 3 };
IEnumerable<int> requeteFiltree = from i in liste
where i > 5
select i;
foreach (int i in requeteFiltree)
{ Console.WriteLine(i); }
11

12. Quelque opérateurs de requête:
 Jointure on utilise le mot-clé join pour faire la jointure entre
deux listes puis on utilise le mot-clé on et le mot-clé equals pour
indiquer sur quoi on fait la jointure.
var liste = from commande in listeCommandes
join client in listeClients on commande.IdentifiantClient equals
client.Identifiant
select new { client.Nom, commande.Prix };
foreach (var element in liste)
{
Console.WriteLine("Le client {0} a payé {1}", element.Nom, element.Prix);
} 12

13. Quelque opérateurs de requête:
 Groupe By Il est intéressant de pouvoir regrouper les objets qui ont la
même valeur. Par exemple pour obtenir toutes les commandes,
groupées par client.
var liste = from commande in listeCommandes
group commande by commande.IdentifiantClient;
foreach (var element in liste)
{
Console.WriteLine("Le client : {0} a réalisé {1} commande(s)",
element.Key, element.Count());
foreach (Commande commande in element)
{
Console.WriteLine("tPrix : {0}", commande.Prix); }} 13

14. Quelque opérateurs de requête:
 Var :Il est assez fréquent de construire des objets anonymes à
l’intérieur d’une requête. Par exemple, plutôt que de renvoyer
uniquement le nom du client, je pourrais également renvoyer
l’Age, mais comme je n’ai pas besoin de l’identifiant, je peux
créer un objet anonyme juste avec ces deux propriétés .
14
var requete = from client in listeClients
where client.Age > 18
orderby client.Age , client.Nom
select new { client.Nom, client.Age };
foreach (var obj in requete)
{
Console.WriteLine("{0} a {1} ans", obj.Nom, obj.Age); }

15. Quelque opérateurs de requête:
 Where() Nous utilisons la méthode d’extensions Where() servant
de prédicat pour filtrer la liste.
IEnumerable<Commande> commandesFiltrees = listeCommandes.
Where(commande => commande.Prix > 100).
Where(commande => commande.NombreArticles >10).
OrderBy(commande => commande.Prix);
15

16. Quelque opérateurs de requête:
 Sum() qui permet de faire la somme des éléments d’une liste ou
la méthode Average() qui permet de faire la moyenne :
List<int> liste = new List<int> { 4, 6, 1, 9, 5, 15, 8, 3 };
Console.WriteLine("Somme : {0}", liste.Sum());
Console.WriteLine("Moyenne : {0}", liste.Average());
16

17. Quelque opérateurs de requête:
 Take() nous permet de récupérer les X premiers éléments d’une liste :
 First() pour obtenir le premier élément d’une liste :
IEnumerable<Client> extrait = listeClients.OrderByDescending(client =>
client.Age).Take(5);
list<int> liste = new List<int> { 4, 6, 1, 9, 5, 15, 8, 3 };
int premier = liste.Where(i => i > 5).First();
17

18. Tp de LINQ To Object
18

19. Linq To SQL
Linq To DataSet
Linq To Entity
19

20. Linq To SQL:
 Linq to SQL est une implémentation de ORM inclus dans le Framework .Net
depuis sa version 3.5.
 Un ORM permet de faire la correspondance entre le monde de la
programmation orienté objet et celui des bases de données relationnelles.
 La manipulation d’une base de données se fait donc via des objets au sens
POO du terme.
20

21. Avantages :
1. La simplicité des requêtes :
La syntaxe de Linq est, bien qu’elle soit simple à appréhender, très puissante. Elle
permet d’effectuer dans certains cas des requêtes plus simplement qu’avec le
langage SQL en un nombre réduit de lignes, tout en restant compréhensibles pour
n’importe quel développeur novice
2. les noms d'objets sont totalement qualifiés sans que le développeur ait à
s’en préoccupé:
Lorsque les classes d’entités sont générées à partir d’un schéma relationnel, Linq
to SQL fait automatiquement la correspondance des types du langage SQL et T-SQL
pour chaque attribut des tables avec leurs pendants dans les langages .Net
3. La détection rapide des erreurs syntaxiques et sémantiques,
contrairement aux requêtes SQL.
4. Linq to SQL ne se limite pas aux requêtes Linq:
il offre aussi la possibilité d’exécuter directement une requête SQL ou bien
d’appeler une procédure stockée 21

22. Inconvénients :
1. Un administrateur de base de données ne voudra pas forcément se plonger
dans le code pour y effectuer des modifications…
2. La durée d’exécution de certain requêtes Linq to SQL est légèrement
supérieur à la même requête en SQL.
22

23. Linq To DataSet :
 Il est impossible d’effectuer des requêtes LINQ to SQL sur une base de
données inconnue jusqu’à l’exécution
 LINQ to DataSet permettent d’exécuter des requêtes LINQ sur des DataSet
 Un DataSet peut être récupéré par une requête SQL ADO.NET
 LINQ to DataSet permet d’effectuer des requêtes sur toute base de données
accessible via ADO.NET
 Ce qui offre un dynamisme bien plus grand que si vous utilisiez LINQ to SQL
23

24. Linq To Entity:
« une application orientée objet ne devrait pas dépendre des mécanismes de
persistance ».
 LINQ to SQ s’agit d’une approche centrée sur les données (ORM)
 LINQ to Entities les données sources ne sont plus des tables ou des objets
mappés sur ces dernières, les sources sont purement conceptuelles
 LINQ to Entities utilise un modèle conceptuel de base de données (EDM)
 Grâce à LINQ to Entities, les applications vont pouvoir fonctionner avec des
données sous forme d’entité ou d’objets dans l’environnement .NET.
24

25. Tp LINQ TO ADO.NET
25

26. 26

27. Rappel
Le format XML est apparu vers 1998, bien qu’il ai eu des
prédécesseurs. Ce format existe pour pouvoir faire transiter
des informations entre différents types de systèmes entre
autre.
Il est donc déjà bien connu dans le milieu informatique et
nous avons de nombreux outils pour le manipuler.

28. Un exemple de structure de fichier XML est celui-ci :

29. Problématique :
De nos jours, l'XML est très utilisé dans les différentes
applications. Il est utilisé pour permettre l'échange des
données entre des applications, pour sauvegarder une
configuration, pour sauvegarder des données (temporaires
ou non), pour générer des rapports, ...etc. Donc on peut le
trouver à peu près par tout.

30. 30
Xml est cependant une technologie difficile à interfacer avec
les langages orientés objet, en particulier lorsque ceux-ci
désirent créer du contenu Xml.
L’approche classique utilise DOM qui oblige à créer
l’ensemble des éléments avant de les rassembler.
DOM se révèle trop complexe lorsqu’il s’agit de manipuler
quelques lignes de XML.

31. Après plusieurs années d’utilisation de l’API W3C DOM XML, il
est apparu clairement qu’une amélioration s’imposait.
Linq To XML

32. Définitions :
 LINQ to XML est le nom de l’API dédiée au travail sur les
données XML (cette interface était précédemment appelée
XLINQ).
LINQ to XML propose un modèle particulier pour accéder
aux données XML, les sources pouvant être un flux (stream),
un fichier ou du XML en mémoire. En réalité il y très peu de
choses à savoir pour utiliser le modèle LINQ to XML, il suffit
de connaître les types les plus courants de ce dernier qui
sont : XDocument, XElement et XAttribute.

33.  L’un des gros avantages de LINQ to XML est de permettre
l’interrogation et la création de documents XML en se
passant totalement d’API plus ou moins complexes, et même
de XPath, XQuery!
 LINQ to XML n’a pas vocation à remplacer ces technologies,
il se place juste au-dessus pour donner au développeur un
niveau d’abstraction supérieur et simplifier la manipulation
des sources XML.

34. Le modèle d’objet LINQ to XML :

35.  LINQ n’est pas juste une nouvelle librairie que vous ajoutez à vos
projets. Il s’agit d’une tout autre approche pour interroger vos
données, consistant en plusieurs composants qui dépendent de la
source de données à interroger.
 On peut utiliser LINQ pour interroger des collections de données
en mémoire avec LINQ to Objects, des fichiers XML avec LINQ to
XML, des DataSets avec LINQ to DataSets et des bases de données
SQL Server avec LINQ to SQL.
Conclusion:

36. Références:
 http://msdn.microsoft.com/fr-fr/library/system.linq.aspx
 http://www.developpez.net/forums/f484/dotnet/langages/csharp/
 http://code.google.com/p/dblinq2007
 www.e-naxos.com
 http://webcourse.cs.technion.ac.il/234319/Spring2009/ho/WCFiles/09%20LI
NQ.pdf
36

37. 37