ACCEDER AUX DONNEES AVEC ADO.NET : ENTITY FRAMEWORK 6, PARTIE 1

Sommaire Introduction ............................................................................................................................................ 2

Les prérequis ........................................................................................................................................... 2

Matériel ................................................................................................................................................... 2

Entity Framework 6 ................................................................................................................................. 2

Modèles EF .......................................................................................................................................... 3

Database First ......................................................................................................................................... 4

Linq to Entity ........................................................................................................................................... 7

Requêtes de sélection ......................................................................................................................... 7

Filtre ................................................................................................................................................ 8

Jointure ........................................................................................................................................... 8

Tri .................................................................................................................................................... 9

Regroupement ................................................................................................................................ 9

Agrégations ..................................................................................................................................... 9

Code First .............................................................................................................................................. 11

DbContext ......................................................................................................................................... 12

Conclusion ............................................................................................................................................. 13

Références EF6 ...................................................................................................................................... 14

Introduction Cet article fait suite à la première partie dédiée à l’accès aux données avec ADO.NET

Nous allons aborder un nouveau concept et un Framework de haut niveau appelé Entity Framework

6, permettant d’encapsuler ce que nous avons fait dans les 2 premiers cours.

Les prérequis Ce cours s’adresse à toutes les personnes désirant comprendre les mécanismes mis en jeu lors de

l’accès aux données.

Une connaissance de C# est conseillé pour bien appréhender tous les concepts.

La connaissance des 2 premiers cours est fortement conseillée.

Matériel Pour suivre ce tutorial, vous aurez besoin de :

1. Visual Studio 2013 / Express : Le cours est basé sur Visual Studio 2013 Ultimate, mais vous

pouvez utiliser Visual Studio Express : TODO

2. SQL Server 2014 / Express / LocalDB : La base de données sera hébergée sur un server SQL.

Vous pouvez utiliser la version SQL Server qui vous convient, SQL Server 2005 à 2014 ou SQL

Server Express / LocalDB pour les versions gratuites.

3. Base de données Northwind : Cette base de données contient quelques données exemples.

Vous pouvez la télécharger ici : http://northwind.codeplex.com

4. Solutions du tutorial : L’ensemble des sources de ce cours sont disponibles ici en annexe de

ce module.

5. MySQL : Serveur MySQL local ainsi que le connecteur .NET :

http://dev.mysql.com/downloads/installer/5.6.html

6. Editeur MySQL : http://www.heidisql.com/

Entity Framework 6 Entity Framework est un mappeur objet relationnel qui permet aux développeurs d’utiliser des

données relationnelles à l’aide d’objets .NET

Le diminutif d’Entity Framework est EF. Pour plus de simplicité nous utiliserons cette abréviation

pour la suite.

EF permet de s’abstraire de tout (ou presque) le code que l’on doit généralement écrire quand on

veut accéder à une source de données.

EF se veut agnostique à la source de données, comme nous l’avons fait dans le cours N°2, le même

code sert que l’on choisisse un fournisseur d’accès SQL ou Oracle ou encore MySQL.

EF est installé par défaut dans Visual Studio et vous donne accès à un designer, comme vous pouvez

le voir dans la copie d’écran suivante :

Lorsque l’on travaille avec Entity Framework, il est important de savoir que l’on a plusieurs choix /

solutions suivant le projet sur lequel on travaille :

Modèles EF

Créer un modèle EF s’effectue suivant 2 cas : Vous possédez ou non une base de données.

Vous possédez déjà une base de données. Il vous est possible d’utiliser le mode :

Database First : Vous générez tout le modèle .NET à partir de la base de données

Code First : Vous avez déjà des entités, et vous mappez ces entités sur votre table avec EF.

Vous ne possédez pas de base de données. Il vous est possible d’utiliser le mode :

Model First : Vous créez un modèle dans le concepteur EF, qui créera la base de données au

premier lancement

Code First : Vous créez des entités C#, et EF créera la base de données au premier lancement

Dans ce cours, nous allons voir comment utiliser EF avec une base de données existante sous SQL

Server avec le modèle Database First. Dans un second temps, nous ferons évoluer le code du cours

N°2 avec le modèle Code First.

Database First

L’ajout d’un élément de type EF se fait via le menu « Ajouter nouvel élément » à votre projet,

comme dans les copies d’écrans suivants :

Une fois la génération terminée, vous avez dans votre projet un élément supplémentaire nommé

dans notre cas Northwind.edmx.

Et cet élément correspond à ce modèle :

Si vous dépliez l’arborescence de l’élément Northwind.edmx, vous allez découvrir un ensemble de

classes générées par Visual Studio pour vous, et qui correspondent aux éléments de votre schéma

Si on ouvre le fichier Customer.cs , on retrouve une classe Customer, qui ressemble fortement à la

classe Customer que nous avions créé dans les précédents cours.

C’est un des avantages de Visual Studio associé avec Entity Framework, qui va générer pour vous

tout le code nécessaire !

public partial class Customer { public Customer() { this.Orders = new HashSet<Order>(); this.CustomerDemographics = new HashSet<CustomerDemographic>(); } public string CustomerID { get; set; } public string CompanyName { get; set; } public string ContactName { get; set; } public string ContactTitle { get; set; } public string Address { get; set; } public string City { get; set; } public string Region { get; set; } public string PostalCode { get; set; } public string Country { get; set; } public string Phone { get; set; } public string Fax { get; set; } public virtual ICollection<Order> Orders { get; set; } public virtual ICollection<CustomerDemographic> CustomerDemographics { get; set; } }

Dans le fichier de configuration, vous retrouvez de même la chaine de connexion, certes un peu plus

complexe que celles que nous avons déjà utilisées dans le cours N°2 :

<add name="NorthwindEntities" connectionString="metadata=res://*/Northwind.csdl|res://*/Northwind.ssdl|res://*/Northwind.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=.\SQL2014;initial catalog=Northwind;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework&quot;" providerName="System.Data.EntityClient" />

Linq to Entity Interroger la base de données via EF6 et le code généré (on parle de modèle généré) se fait via un

langage particulier appelé Linq to Entity (Language Integrated Query)

Ce langage va nous permettre d’écrire des requêtes qui seront ensuite transformés en langage SQL

(ou Oracle ou MySQL) à partir d’un langage typé.

Les requêtes LINQ s’exécutent toujours dans le contexte de votre modèle EF6. Un peu comme l’objet

SqlCommand qui a besoin de l’ouverture d’une connexion SqlConnection.

Voici un premier exemple de l’utilisation de votre contexte EF de votre modèle Northwind :

using (NorthwindEntities context = new NorthwindEntities()) { // Votre code LINQ }

Requêtes de sélection Une première requête LINQ qui permet de récupérer tous les objets Customer de votre base

Northwind :

var query = from c in context.Customers select c;

query représente la requête à exécuter sur votre base de données.

var allCustomers = query.ToList();

allCustomers représente la List<Customer> issu de l’exécution de votre requête.

Note : L’exécution de la requête se fait lors de l’appel de la méthode ToList() et non pas lors de la

déclaration de la requête !

Voici l’exemple complet :

using (NorthwindEntities context = new NorthwindEntities()) { var query = from c in context.Customers select c; var allCustomers = query.ToList(); foreach (var customer in allCustomers) Console.WriteLine(customer.CustomerID + " " + customer.ContactName); }

A l’exécution la requête générée et exécutée sur la base de données est bien :

SELECT [Extent1].[CustomerID] AS [CustomerID], [Extent1].[CompanyName] AS [CompanyName], [Extent1].[ContactName] AS [ContactName], [Extent1].[ContactTitle] AS [ContactTitle], [Extent1].[Address] AS [Address], [Extent1].[City] AS [City], [Extent1].[Region] AS [Region], [Extent1].[PostalCode] AS [PostalCode], [Extent1].[Country] AS [Country],

[Extent1].[Phone] AS [Phone], [Extent1].[Fax] AS [Fax] FROM [dbo].[Customers] AS [Extent1]

Quelques exemples de requêtes LINQ que vous aurez surement l’occasion d’utiliser :

Filtre L’idée ici est de passer une variable comme nous aurions passé un paramètre. EF va générer une

requête paramétrée et l’exécuter sur votre base :

String filtre = "Al"; using (NorthwindEntities context = new NorthwindEntities()) { var q = from c in context.Customers where c.ContactName.StartsWith(filtre) select c; foreach (var customer in q.ToList()) Console.WriteLine(customer.CustomerID + " " + customer.ContactName); }

Et voici la requête exécutée :

exec sp_executesql N'SELECT [Extent1].[CustomerID] AS [CustomerID], [Extent1].[CompanyName] AS [CompanyName], [Extent1].[ContactName] AS [ContactName], [Extent1].[ContactTitle] AS [ContactTitle], [Extent1].[Address] AS [Address], [Extent1].[City] AS [City], [Extent1].[Region] AS [Region], [Extent1].[PostalCode] AS [PostalCode], [Extent1].[Country] AS [Country], [Extent1].[Phone] AS [Phone], [Extent1].[Fax] AS [Fax] FROM [dbo].[Customers] AS [Extent1]

WHERE [Extent1].[ContactName] LIKE @p__linq__0 ESCAPE N''~''',N'@p__linq__0 nvarchar(4000)',@p__linq__0=N'Al%'

On voit bien que la syntaxe C# StartWith() est transformée en commande SQL Like et la variable de

type string est bien remplacée par un paramètre nvarchar() nommé @p__linq__0

Jointure L’idée ici est de récupérer des éléments suivants une jointure SQL en utilisant la syntaxe from from :

var query = from e in context.Employees from r in context.Regions from t in context.Territories where t.TerritoryDescription == "Seattle" select e;

Le gros avantage ici c’est qu’il est inutile de spécifier les jointures à utiliser car elles sont déjà

connues par le modèle Northwind.

Ce n’est pas le cas dans notre modèle, mais si votre base de données ne contient pas de relations (et

donc le modèle ne les connaissant pas) vous pouvez réaliser une relation explicite comme ceci :

var query = from t in context.Territories

join r in context.Regions on t.RegionID equals r.RegionID where t.TerritoryDescription == "Seattle" select r;

Notez l’utilisation de la syntaxe « join … in … on … equals » qui permet d’établir la relation explicite

entre deux entités (donc 2 tables)

Tri L’idée ici est de trier une liste

var query = from c in context.Customers orderby c.ContactName ascending select c;

Regroupement L’idée ici est de grouper les éléments dans une nouvelle structure. Nous allons utiliser un nouveau

concept qui est l’utilisation d’un type anonyme dans la requête LINQ.

Un type anonyme permet de créer un objet dynamiquement sans forcément avoir au préalable écrit

la classe correspondante.

Il s’écrit générale de la manière suivante (dans une requête Linq)

select new { Id = 1, Prénom = "Sébastien", Nom = "Pertus" }

Dans une fonction de regroupement on a souvent une structure différente de la structure de la table

d’où l’utilisation de type anonyme.

Voici un exemple sur la table Products où l’on souhaite avoir les CategoryId pour chaque SupplierId

var query = from p in context.Products group p by new { p.CategoryID, p.SupplierID } into productGroupbyCategory select new { CategoryId = productGroupbyCategory.Key.CategoryID, SupplierID = productGroupbyCategory.Key.SupplierID }; foreach (var p in query.ToList()) Console.WriteLine(p.CategoryId + " " + p.SupplierID);

Agrégations L’idée ici est de voir les fonctions d’agrégations avec LINQ :

Moyenne (Average) :

var query = from orderDetail in context.Order_Details group orderDetail by orderDetail.ProductID into groupProd select new { ProductId = groupProd.Key, AverageQuantity = groupProd.Average(od => od.Quantity) };

foreach (var p in query.ToList()) Console.WriteLine(p.ProductId + " " + p.AverageQuantity);

Cumul (Count) :

var query = from orderDetail in context.Order_Details group orderDetail by orderDetail.ProductID into groupProd join product in context.Products on groupProd.Key equals product.ProductID orderby product.ProductName ascending select new { ProductId = groupProd.Key, ProductName = product.ProductName, Quantity = groupProd.Count() }; foreach (var p in query.ToList()) Console.WriteLine(p.ProductName + " " + p.Quantity);

Notez l’utilisation d’une jointure explicite et d’un order by pour plus de clareté.

Maximum (Max) :

var query = from orderDetail in context.Order_Details group orderDetail by orderDetail.ProductID into groupProd select new { ProductId = groupProd.Key, MaxQuantity = groupProd.Max(od => od.Quantity) };

Premier élément (First) :

using (NorthwindEntities context = new NorthwindEntities()) { var query = from c in context.Customers select c; var customer = query.First(); Console.WriteLine(customer.CustomerID + " " + customer.ContactName); }

Notez que l’opération First se fait non pas depuis la requête Linq mais lors de l’exécution avec

l’appel de la méthode First()

L’objet retourné n’est pas une List<Customer> mais un objet Customer simple.

Attention : Si il n’existe pas de ligne en base, la méthode First() va lever une exception. Si vous n’êtes

pas sûr de récupérer un enregistrement, préférez utiliser la méthode FirstOrDefault() et la

vérification de la nullité via une instruction if :

using (NorthwindEntities context = new NorthwindEntities()) { var query = from c in context.Customers where c.ContactName.Contains("Lioooooo") select c; var customer = query.FirstOrDefault(); if (customer != null) Console.WriteLine(customer.CustomerID + " " + customer.ContactName); }

Code First Le mode Code First permet de créer un contexte EF avec des entités déjà existantes. Si nous

reprenons le code du cours n° 2, nous avons déjà les entités mappées de notre base de données.

Ce sont des entités que nous avons déjà écrites en code C#.

L’idée ici c’est de se passer de toute la tuyauterie Service que nous avons écrit (CustomerServices)

avec les appels aux objets ADO.NET bas niveau comme SqlConnection, SqlCommand, etc….

Première étape : Ajouter la référence à Entity Framework, via nuget :

Vous retrouvez la référence dans votre projet :

Note : Dans le modèle Database First, cet ajout a été réalisé automatiquement par Visual Studio

pendant l’assistant de sélection de votre base de données et de vos tables.

Une fois EF6 installé, nous pouvons créer un contexte

DbContext Un objet DbContext est très similaire à l’objet généré dans le modèle Database First.

Il hérite de DbContext et fédère toutes les entités que nous souhaitons mapper à notre base de

données.

Voici la classe NorthwindContext de notre projet :

public class NorthwindContext : DbContext { public NorthwindContext() : base("name=NorthwindProd") { } public virtual DbSet<Customer> Customers { get; set; } public virtual DbSet<Category> Categories { get; set; } public virtual DbSet<Employee> Employees { get; set; } public virtual DbSet<Order> Orders { get; set; } public virtual DbSet<Product> Products { get; set; } public virtual DbSet<Region> Regions { get; set; } public virtual DbSet<Shipper> Shippers { get; set; } public virtual DbSet<Supplier> Suppliers { get; set; } public virtual DbSet<Territory> Territories { get; set; } protected override void OnModelCreating(DbModelBuilder modelBuilder) { } }

La classe générique DbSet<T> permet de créer des collections d’objets, et rajoute des méthodes

comme l’ajout la suppression, la recherche par clé primaire etc ….

Voici une partie de la classe DbSet<T> pour information :

public class DbSet<TEntity> : DbQuery<TEntity>, IDbSet<TEntity>, IQueryable<TEntity>, IEnumerable<TEntity>, IQueryable, IEnumerable where TEntity : class { public virtual TEntity Add(TEntity entity); public virtual IEnumerable<TEntity> AddRange(IEnumerable<TEntity> entities); public virtual TEntity Attach(TEntity entity); // public virtual TEntity Create(); public virtual TEntity Find(params object[] keyValues); public virtual Task<TEntity> FindAsync(params object[] keyValues); public virtual Task<TEntity> FindAsync(CancellationToken cancellationToken, params object[] keyValues); // public virtual TEntity Remove(TEntity entity); public virtual IEnumerable<TEntity> RemoveRange(IEnumerable<TEntity> entities); public virtual DbSqlQuery<TEntity> SqlQuery(string sql, params object[] parameters); }

Conclusion Entity Framework permet notamment de simplifier l’accès aux données. Que ce soit en mode

Database First ou Code First, et l’apport de Visual Studio, vous avez l’opportunité de rapidement

vous dédouaner de toute la complexité et la tuyauterie quelque fois rébarbative de l’accès aux

données.

Dans un prochaine cours, nous allons approfondir l’utilisation d’Entity Framework pour résoudre des

problématiques liés à l’accès aux données en général.

Références EF6 Blog de l’équipe Entity Framework : http://blogs.msdn.com/b/adonet/

Site MSDN : http://msdn.microsoft.com/fr-fr/data/ef

Site Codeplex : http://entityframework.codeplex.com/