Maîtrisez la solution de Mappage Entity Framework Core ...€¦ · Maîtrisez la solution de Mappage Objet-Relationnel de Microsoft Entity Framework Core Chaque fournisseur de données

ISBN

: 978

-2-4

09-0

0629

-6

39 €

Entity Framework Core Maîtrisez la solution de Mappage Objet-Relationnel de Microsoft

Consultant et formateur depuis plu-sieurs années, Sébastien PUTIER est aujourd’hui expert technique au sein de la société Ai3 et apporte ses compétences dans la mise en œuvre de solutions Windows, Web et mo-biles avec la plateforme .Net depuis ses premières versions. Il est certifié techniquement (MCPD - MCSD) et pédagogiquement (MCT) par Micro-soft. À travers les pages de ce livre, il transmet toute son expérience sur Entity Framework Core pour que le lecteur en maîtrise les fondamentaux et tire parti des possibilités étendues de cette librairie.

Ce livre sur la solution de Mappage Objet-Relationnel Entity Framework Core s’adresse à tout développeur souhaitant dé-couvrir et explorer la dernière version de cette librairie. Il couvre ses différentes facettes, des aspects les plus simples jusqu’aux mécanismes internes les plus complexes.

Le premier chapitre du livre montre l’évolution des techniques d’accès aux données utilisées avec le framework .NET depuis sa première version jusqu’à .NET Core. Ensuite, l’auteur présente les aspects principaux de la modélisation objet avec Entity Framework Core et les liens qui existent entre le modèle et la source de données. Le troisième chapitre détaille l’utilisation des opérateurs de requêtage de LINQ ainsi que la génération du code SQL qui leur est associé. Certains scénarios de modéli-sation plus avancés sont ensuite exposés à l’aide d’exemples concrets, issus de problématiques fréquemment rencontrées lors de développements importants. Enfin, le dernier chapitre du livre évoque les capacités d’extensibilité d’Entity Framework Core, d’abord d’un point de vue généraliste, puis jusque dans les arcanes de la librairie par l’implémentation d’un fournisseur de données minimal pour MongoDB.

L’ensemble des exemples proposés tout au long de ce livre est disponible sur le site www.editions-eni.fr.

Pour plus d’informations :

Téléchargementwww.editions-eni.fr.fr

Sur www.editions-eni.fr :b Le code source des exemples

traités dans le livre. Sébastien PUTIER

Enti

ty F

ram

ewor

k C

ore

Maî

tris

ez la

sol

utio

n de

Map

page

Obj

et-R

elat

ionn

el d

e M

icro

soft Entity Framework Core

Maîtrisez la solution de Mappage Objet-Relationnel de Microsoft

Avant-propos • .NET et l’accès aux données • Modélisation • Des objets au SQL • Modélisation avancée • Création d’un fournisseur de données

Les chapitres du livre

1Table des matières

Avant-propos

Chapitre 1

.NET et l’accès aux données

1. ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2. Mappage objet-relationnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3. LINQ to SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4. Entity Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.1 Database First et Model First. . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.2 Code First . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

5. D'Entity Framework 7 à Entity Framework Core . . . . . . . . . . . . . . . 275.1 Genèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275.2 Une véritable version 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285.3 Quand choisir Entity Framework Core ? . . . . . . . . . . . . . . . . . . 29

Chapitre 2

Modélisation

1. Installation d'Entity Framework Core . . . . . . . . . . . . . . . . . . . . . . . . 311.1 Dans une application .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321.2 Dans une application .NET Core. . . . . . . . . . . . . . . . . . . . . . . . . 39

1.2.1 Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391.2.2 Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411.2.3 OS X . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

Les éléments à télécharger sont disponibles à l'adresse suivante :http://www.editions-eni.fr

Saisissez la référence de l'ouvrage EIENT dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

2Maîtrisez la solution de Mappage Objet-Relationnel de Microsoft

Entity Framework Core

2. Deux approches pour deux cas d'utilisation . . . . . . . . . . . . . . . . . . . . 462.1 Model First . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462.2 Database First . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

3. Du modèle de données au modèle objet . . . . . . . . . . . . . . . . . . . . . . . 483.1 Point d'entrée : DbContext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

3.1.1 Patron de conception Unit of Work . . . . . . . . . . . . . . . . . 493.1.2 Configuration de l'objet DbContext . . . . . . . . . . . . . . . . . 49

3.2 Collections d'enregistrements : DbSet<T> . . . . . . . . . . . . . . . . 533.3 Les enregistrements, des objets comme les autres . . . . . . . . . . . 54

4. Configuration du modèle objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564.1 Trois manières de faire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

4.1.1 Conventions pour simplifier la modélisation . . . . . . . . . . 574.1.2 Data annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594.1.3 Fluent API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.1.4 Combiner les techniques de configuration . . . . . . . . . . . . 63

4.2 Inclusion/Exclusion de types d'entités . . . . . . . . . . . . . . . . . . . . 654.3 Inclusion/Exclusion de propriétés . . . . . . . . . . . . . . . . . . . . . . . . 694.4 Mappage des tables et colonnes. . . . . . . . . . . . . . . . . . . . . . . . . . 71

4.4.1 Types d'entités et tables. . . . . . . . . . . . . . . . . . . . . . . . . . . 714.4.2 Propriétés et colonnes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

4.5 Définition d'une clé primaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744.6 Relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 774.7 Configuration avancée des propriétés du modèle. . . . . . . . . . . . 86

4.7.1 Données obligatoires et facultatives . . . . . . . . . . . . . . . . . 864.7.2 Longueur maximale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884.7.3 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 894.7.4 Clés alternatives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 904.7.5 Valeurs générées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924.7.6 Colonnes calculées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 944.7.7 Valeurs par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95


5. Scaffolding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 965.1 Console du gestionnaire de package NuGet . . . . . . . . . . . . . . . . 97

5.1.1 Arguments obligatoires : Connection et Provider . . . . . . 995.1.2 OutputDir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015.1.3 Context . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025.1.4 Schémas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1035.1.5 Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1045.1.6 DataAnnotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055.1.7 Force . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1095.1.8 Project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

5.2 CLI .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105.2.1 Arguments obligatoires . . . . . . . . . . . . . . . . . . . . . . . . . . 1125.2.2 output-dir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1135.2.3 context . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1145.2.4 schema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1155.2.5 table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1155.2.6 data-annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165.2.7 force . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175.2.8 json . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175.2.9 verbose. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

6. Migrations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1196.1 Création d'une migration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1206.2 Mise à jour de la source de données . . . . . . . . . . . . . . . . . . . . . 1266.3 Suppression de migration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1286.4 Génération de scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

Chapitre 3

Des objets au SQL

1. Modèle d'étude . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

2. Fournisseurs de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141



3. Requêtage avec LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1433.1 API et extension à C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1443.2 Première requête LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

4. LINQ dans le détail. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1484.1 IEnumerable<T> et IQueryable<T> : les différences . . . . . . 1494.2 Opérateurs de projection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

4.2.1 Select . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1504.2.2 SelectMany . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

4.3 Opérateurs de partitionnement. . . . . . . . . . . . . . . . . . . . . . . . . 1544.3.1 Take. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1554.3.2 Skip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

4.4 Opérateurs de tri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1574.4.1 OrderBy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1574.4.2 OrderByDescending . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1634.4.3 ThenBy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1654.4.4 ThenByDescending . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

4.5 Opérateur de regroupement. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1684.6 Opérateurs d'ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

4.6.1 Distinct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1704.6.2 Except . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1724.6.3 Union . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1744.6.4 Intersect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

4.7 Opérateur de filtrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1774.8 Opérateurs d'agrégation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

4.8.1 Count . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1804.8.2 LongCount . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1824.8.3 Min . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1834.8.4 Max . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1854.8.5 Sum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1864.8.6 Average . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

4.9 Opérateurs de jointure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1884.9.1 Join . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1884.9.2 GroupJoin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191


4.10 Opérateurs de conversion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1944.10.1Manipulation du type des enregistrements . . . . . . . . . . 1944.10.2Manipulation du type

des collections d'enregistrements . . . . . . . . . . . . . . . . . . 2014.10.3Conversion de type de collection : les écueils à éviter . . 205

4.11 Opérateurs de quantification. . . . . . . . . . . . . . . . . . . . . . . . . . . 2064.11.1Any . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2064.11.2All . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2074.11.3Contains . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

4.12 Opérateurs d'élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2084.12.1First et FirstOrDefault . . . . . . . . . . . . . . . . . . . . . . . . . . . 2094.12.2Last et LastOrDefault. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2104.12.3Single et SingleOrDefault . . . . . . . . . . . . . . . . . . . . . . . . 212

5. Cycle de vie des entités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2145.1 Cinq types de manipulations, cinq états . . . . . . . . . . . . . . . . . 2145.2 Détection des changements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

5.2.1 Détection automatique : AutoDetectChangesEnabled . 2205.2.2 Détection manuelle : DetectChanges . . . . . . . . . . . . . . . 2255.2.3 Stratégies de détection des changements . . . . . . . . . . . . 226

5.3 Attacher et détacher des entités . . . . . . . . . . . . . . . . . . . . . . . . 239

6. Validation des changements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

7. Assurer l’intégrité des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2477.1 Accès concurrents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

7.1.1 Loi du plus fort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2487.1.2 Contrôle d'accès concurrents optimiste . . . . . . . . . . . . . 2507.1.3 Contrôle d'accès concurrents pessimiste. . . . . . . . . . . . . 255

7.2 Transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2557.2.1 Implicites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2567.2.2 Explicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

8. Visualisation du code SQL généré . . . . . . . . . . . . . . . . . . . . . . . . . . . 260



Chapitre 4

Modélisation avancée

1. Séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

2. Héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

3. Utilisation des procédures stockées. . . . . . . . . . . . . . . . . . . . . . . . . . 275

4. Shadow properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2794.1 Utilisation au cœur d'Entity Framework . . . . . . . . . . . . . . . . . 2794.2 Cas d'utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282

4.2.1 Ajout de propriétés à un groupe d'entités . . . . . . . . . . . . 2834.2.2 Soft deletes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

5. Backing fields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

Chapitre 5

Création d’un fournisseur de données

1. Architecture modulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

2. Mise en place du fournisseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2982.1 Source de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3002.2 Informations importantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3022.3 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

2.3.1 Fournisseur de données . . . . . . . . . . . . . . . . . . . . . . . . . . 3022.3.2 Application de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

3. Éléments de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311

4. Services requis pour la sélection de données. . . . . . . . . . . . . . . . . . . 3184.1 QueryContextFactory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3184.2 ModelSource . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3204.3 Database . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3224.4 EntityQueryModelVisitorFactory . . . . . . . . . . . . . . . . . . . . . . . 3244.5 EntityQueryableExpressionVisitorFactory . . . . . . . . . . . . . . . . 328

5. Entity Framework et arbres d'expressions . . . . . . . . . . . . . . . . . . . . 331

6. Gestion des annotations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333


7. Expressions de description de requête MongoDB . . . . . . . . . . . . . . 347

8. Shaping (façonnage d’entités) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3568.1 Command builder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3588.2 Query generator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3618.3 Database connection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3658.4 Value buffers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3698.5 Materializer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3728.6 Shaper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3748.7 Création du shaper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3778.8 QueryContext et ShaperCommandContext . . . . . . . . . . . . . . 3818.9 QueryingEnumerable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3928.10 Expression de déclenchement initiale . . . . . . . . . . . . . . . . . . . . 396

9. ValueGeneratorCache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

10. Mappage des champs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415

9

Chapitre 1

.NET et l’accès aux données

.NET et l’accès aux données1. ADO.NET

Depuis sa toute première version, la bibliothèque de classes fournie par laplateforme .NET dispose d'une brique dédiée à la récupération d'informationsenregistrées en base de données, ainsi qu'à leur manipulation et à la persis-tance des modifications qui leur sont apportées. Cet ensemble d'API a pournom ADO.NET, en référence à l'API ADO (ActiveX Data Objects) utilisée enconjonction avec les technologies antérieures à la plateforme .NET.

Bien que leurs noms soient similaires, des différences fondamentales séparentces deux technologies. Une des plus importantes se trouve dans la manièredont sont définies les interactions entre le cœur de la librairie et les sources dedonnées extérieures. ADO utilise un mécanisme basé sur COM (ComponentObject Model) pour interagir avec des drivers natifs, installés sur la machine.Ceci implique que l'utilisation d'une source de données nécessite, au mieux,d'installer un pilote natif, et dans un cas moins glorieux, de l'écrire avec un lan-gage comme C ou C++, puis de l'installer. Les liens entre les sources dedonnées et le cœur d'ADO.NET sont logés dans des librairies écrites en codemanagé et respectant un contrat prédéfini : les fournisseurs de données. Cepoint permet à cette brique logicielle d'être facilement étendue pour supporterde nouvelles sources de données.

© E

dit

ions

EN

I -

All r

ights

rese

rved



Chaque fournisseur de données encapsule les différents éléments essentielspour les interactions avec une source de données au sein de quelques classescentrales. Pour le fournisseur de données SQL Server intégré au framework.NET, par exemple :

– Connexion : SqlConnection, classe héritée de DbConnection.

– Exécution de requêtes : SqlCommand, classe héritée de DbCommand.

– Paramètres de requêtes : SqlParameter, classe héritée de DbParameter.

– Transactions : SqlTransaction, classe héritée de DbTransaction.

– Curseur sur le résultat d'une requête SELECT : SqlDataReader, classehéritée de DbDataReader.

– Collection d'enregistrements : DataTable.

– Liaison directe entre la source de données et une DataTable :SqlDataAdapter, classe héritée de DbDataAdapter.

Considérons la table Clients définie à l'aide du script SQL suivant :

CREATE TABLE [dbo].[Clients]( [NumClient] [int] NOT NULL PRIMARY KEY, [Adresse1] [nvarchar](200) NULL, [Adresse2] [nvarchar](200) NULL, [Adresse3] [nvarchar](200) NULL, [CodePostal] [nvarchar](5) NULL, [Nom] [nvarchar](80) NOT NULL, [Prenom] [nvarchar](80) NOT NULL, [Ville] [nvarchar](100) NULL, [MontantTotalAchats] [decimal](12, 2) NULL)

Ce qui suit montre un exemple d'utilisation d'ADO.NET pour la lecture et lamise à jour de données en provenance de cette table. Le fournisseur de donnéeschoisi pour l'implémentation est SQL Server, aussi est-il nécessaire d'ajouterune clause using adaptée dans le fichier de code.

using System.Data.SqlClient;

public static void Main(string[] args)

{

string chaineConnexion = "<ma chaine de connexion>";

string requeteSelect = @"SELECT * FROM Clients";

11.NET et l’accès aux donnéesChapitre 1

string requeteUpdate = @"UPDATE Clients SET

MontantTotalAchats = MontantTotalAchats + @montant";

//Affichage de l'identifiant, du nom complet et

//du montant des achats de tous les clients

using (var connection = new SqlConnection(chaineConnexion))

using (var command = connection.CreateCommand())

{

command.CommandText = requeteSelect;

using (var dataReader = command.ExecuteReader())

{

while (dataReader.Read())

{

var numClient = dataReader.GetInt32(

dataReader.GetOrdinal("NumClient"));

var nom = dataReader.GetString(

dataReader.GetOrdinal("Nom"));

var prenom = dataReader.GetString(

dataReader.GetOrdinal("Prenom"));

var montantAchats = dataReader.GetDecimal(

dataReader.GetOrdinal("MontantTotalAchats"));

Console.WriteLine($"Client n° {numClient} -

{prenom} {nom} : {montantAchats}€");

}

}

}

//Augmentation de 10€ du montant pour tous les clients

using (var connection = new SqlConnection(chaineConnexion))

using (var command = connection.CreateCommand())

{

var paramMontant = command.CreateParameter();

paramMontant.DbType = System.Data.DbType.Decimal;

paramMontant.ParameterName = "@montant";

paramMontant.Value = 10;

command.CommandText = requeteUpdate;

command.ExecuteNonQuery();

}

}

© E

dit

ions

EN

I -

All r

ights

rese

rved



La complexité de ce code réside en partie dans la problématique de typage desdonnées remontées par l'objet dataReader, de type SqlDataReader. Pourmanipuler des données dont le type est plus précis qu'object, il faut passerpar une étape de transtypage, qu'il soit manuel ou encapsulé par les méthodesGetDecimal, GetString, etc. L'écriture de ce type de code, en plus d'appor-ter de la complexité, peut également engendrer des erreurs, particulièrementau niveau des chaînes de caractères (requête SQL et noms de champs). Deplus, il a peu d'intérêt d'un point de vue fonctionnel et accapare des ressourcesqui pourraient être utilisées pour apporter de la valeur métier aux applica-tions.

Avec ADO.NET, les développeurs ont les clés pour développer des applica-tions robustes faisant une utilisation intensive des bases de données. Lesopérations manuelles de typage fort des données issues de la base de donnéeset l'écriture de requêtes parfois complexes lors de l'ajout ou de la modificationd'enregistrements sont néanmoins problématiques. Ces éléments induisentun coût non négligeable en termes de temps de développement et de mainte-nance pour les projets basés sur cette technologie.

2. Mappage objet-relationnel

Les faiblesses du modèle traditionnel de manipulation des données, tel qu'il estimplémenté dans de nombreuses technologies (.NET, Java, PHP, etc.), ontpoussé de nombreux acteurs du monde du développement logiciel à l'élabora-tion d'un modèle différent, permettant de manipuler les données en suivant leparadigme de la programmation orientée objet (POO) : le mappage objet-relationnel (ORM ou Object/Relational Mapping).

Cette technique vise à transformer de manière automatique des données is-sues de sources de données externes, comme des bases de données, en objetsutilisables dans le langage cible. La manipulation de ces objets permet égale-ment de générer et d'exécuter de manière automatique les instructions néces-saires à la répercussion des modifications dans la source de données. Ainsi, lesactions associées à la source de données sont entièrement encapsulées derrièreune façade objet, simplifiant les traitements, et par là même, réduisant lescoûts associés au développement d'une solution logicielle couplée à une ouplusieurs sources de données.

13.NET et l’accès aux donnéesChapitre 1

Avec l'utilisation d'une solution de mappage objet-relationnel, l'ensemble desenregistrements d'une table peut être représenté par une collection d'objets.Cette collection ne contient en réalité aucune donnée, mais fait l'interface versla base de données : lorsque l'on effectue une recherche dans la liste, une re-quête SQL de sélection est générée et exécutée, et les enregistrements retour-nés sont automatiquement convertis en objets fortement typés.

Considérons le cas d'une table nommée Client dont la structure est définieà l'aide de l'instruction SQL suivante :

CREATE TABLE Client(

NumClient int PRIMARY KEY,

Prenom varchar(50) NOT NULL,

Nom varchar(50) NOT NULL,

Adresse1 varchar(100) NOT NULL,

Adresse2 varchar(100) NOT NULL,

CodePostal varchar(5) NOT NULL,

Ville varchar(50) NOT NULL,

DateNaissance date NULL,

MontantTotalAchats decimal(10, 2) NOT NULL

)

Chacun des enregistrements issus de la table Client pourrait avoir pourmodèle la classe C# suivante :

public class Client

{

public int NumClient { get; set; }

public string Prenom { get; set; }

public string Nom { get; set; }

public string Adresse1 { get; set; }

public string Adresse2 { get; set; }

public string CodePostal { get; set; }

public string Ville { get; set; }

public DateTime? DateNaissance { get; set; }

public decimal MontantTotalAchats { get; set; }

}

© E

dit

ions

EN

I -

All r

ights

rese

rved



En plus de simplifier la lecture des informations issues d'une source de don-nées, le mappage objet-relationnel permet également de faire remonter desmodifications (ainsi que des ajouts ou suppressions d'enregistrements) vers lasource de données en générant et en exécutant les requêtes SQL correspon-dantes. La technique de l'ORM offre ainsi au développeur la possibilité de sim-plifier le code d'accès aux données, tout en lui laissant la possibilité de seconcentrer sur les portions de code à forte valeur ajoutée.

3. LINQ to SQL

Consciente des défauts d'ADO.NET et de l'évolution en cours au niveau destechniques d'accès aux données, l'équipe en charge du langage C# a travaillésur la simplification de l'accès aux données par l'intégration du requêtage aulangage C#. Le résultat de cet effort est une librairie de mappage objet-rela-tionnel dévoilée à la fin de l'année 2005 sous le nom de DLINQ, et renomméepar la suite en LINQ to SQL, qui fait partie intégrante du framework .NETdepuis sa version 3.5.

LINQ to SQL tire son nom de la brique logicielle qui lui est associée pour l'écri-ture de requêtes de sélection : LINQ (Language-INtegrated Query). Cette librai-rie permet de manipuler des données par l'utilisation d'éléments intégrés aulangage C# (ou VB.NET), et de manière complètement agnostique : la sourcedes données pourrait aussi bien être un fichier CSV (Comma-Separated Values)ou XML, une collection .NET en mémoire ou une base de données.

LINQ to SQL se positionne justement sur ce dernier créneau en fournissantune infrastructure logicielle qui permet de retranscrire les instructions LINQen instructions SQL compréhensibles par une base de données SQL Server(uniquement).

Remarque

Nous reviendrons plus en détail sur LINQ et son fonctionnement au chapitreDes objets au SQL.

Documents

Maîtrisez la solution de Mappage Entity Framework Core ...€¦ · Maîtrisez la solution de Mappage Objet-Relationnel de Microsoft Entity Framework Core Chaque fournisseur de données