Chapitre 3 EF

Télécharger au format pdf ou txt
Télécharger au format pdf ou txt
Vous êtes sur la page 1sur 23

15/10/2021

Définition
• ORM (Object Relational Mapping, Mapping objet relationnel) officiel de .NET

Chapitre 3: Entity Framework développé par Microsoft en utilisant le langage C# permettant de


manipuler des objets C# . Proposé pour faciliter la tâche aux programmeurs en
leur permettant de ne plus écrire de requêtes SQL dans leurs codes et les

framework Core remplacer par des commandes très faciles.


• Un programme informatique qui joue le rôle d’un traducteur entre le monde
relationnel et le monde objet
ENSEIGNANTE: DR. ING. GHOFRANE FERSI
L’objectif : plus de requêtes SQL dans les classes.

1 2

Définition Définition
Dans les ORM, il y a deux composants : • Entity Framework (EF) était intégré dans .NET framework 3.5 depuis 2008
• Les entités (des classes à implémenter par le développeur) : qui représentent • La version d’EF incluse dans .NET framework est EF6
certaines tables •Version mature, qui supporte les modèles d’héritage complexes
•Le gestionnaire d’entités (une classe qui existe déjà) : à utiliser pour persister les •A partir de EF6.3 , EF est extrait de .NET framework et est devenu dans un
entités dans la base de données. package séparé
Dans le cas d’entity framework : • Il supporte désormais .Net Core 3.0 et les versions d’après incluant .NET5.
• Les entités : des classes décorées (annotées)
•Le gestionnaire d’entités : Linq to Entities

3 4

1
15/10/2021

Définition EF Core en comparaison à EF 6


•EF6 est considéré actuellement comme une version ancienne qui a des limites • EF Core est nouveau et par la suite n’est pas encore aussi mature que EF6
en l’appliquant dans cross-platform et il n’est pas possible d’ajouter de nouveaux
composants •EF Core continue à supporter les éléments suivants:
1. DbContext & DbSet
• Pour utiliser la version ancienne EF6 dans un projet .NET Core 3.0 ou après, 2. Data Model
vous devez ajouter une référence au package dans votre fichier de projet
3. Querying utilisant Linq-to-Entities
<package Reference Include ="Entity Framework" Version="6.4.4" /> 4. Suivi des modifications
Conseil: Il vaut mieux éviter d’utiliser l’ancienne version 5. Enregistrement des changements
6. Migrations

5 6

EF Core en comparaison à EF 6 EF Core en comparaison à EF 6


EF Core va inclure graduellement les fonctionnalités de EF6. Mais il y a des EF Core inclue de nouvelles fonctionnalités qui n’étaient pas supportées par les
fonctionnalités qui ne sont plus supportées par EF Core comme: versions antérieures:
•EDMX/ Graphical Visualization of Model • Many-to-Many sans join entity • Configuration facile des relations
• Entity Splitting
•Entity Data Model Wizard (pour DB-First approach) • Grouper les opérations d’insertion, mise à jour et suppression
• Spatial Data
•ObjectContext API • Lazy loading des données •Support d’inversion de contrôle (IOC)
•Querying using Entity SQL reliées •Contraintes uniques
• Stored procedure mapping
•Automated Migration with DbContext pour CUD • Propriétés de l'ombre (shadow properties)
•Inheritance: Table per type (TPT) operation • Filtre de requête global
• Seed data
•Inheritance: Table per concrete class (TPC) • De meilleurs modèles pour gérer les graphiques d'entités déconnectés
• Automatic migration
7 8

2
15/10/2021

Entity Framework Core EF Core: Fournisseur de base de données


• Entity Framework Core utilise un modèle de fournisseur pour accéder à de
nombreuses bases de données différentes.
• EF Core inclut des fournisseurs en tant que packages NuGet que vous devez
installer.
• Le tableau suivant répertorie les fournisseurs de bases de données et les
packages NuGet pour EF Core.

9 10

EF Core: Fournisseur de base de données Installer EF Core


Pour pouvoir utiliser Entity Framework Core avec le fournisseur de base de
données choisi, il faut faire les étapes suivantes: outils->Gestionnaire de packets
Nugets->Gérer les packages de Nuget pour la solution->parcourir->
Microsoft.EntityFrameworkCore
• Reproduire les mêmes étapes pour ajouter le package relatif à votre fournisseur
de base de données (pour notre cas Microsoft.EntityFrameworkCore.SqlServer)
•Ajouter également le package Microsoft.EntityFrameworkCore.Relational
Pour exécuter les commandes EF Core, il faut aussi ajouter le package
Microsoft.EntityFrameworkCore.Tools

11 12

3
15/10/2021

EF Core: Approches EF Core: Approches


Il existe deux approches :
Code First : L’API EF Core crée la base de données et les tables en utilisant les
migrations basées sur les conventions et les configurations fournies dans votre
domaine de classes.
Database First : EF Core crée le domaine et les classes de contexte en se basant
sur la base de données existante en utilisant les commandes EF Core.
EF Core vise essentiellement l’approche code first et donne un peu de support
pour le Database First approche car le visual designer ou wizard pour le DB
model sont non supportés par EF Core 2.0. Cette approche est bénéfique dans
Domain Driven Design (DDD).

13 14

Code First: Etapes à suivre Code First: Etapes à suivre

•Création d’un projet Console • Entity Framework Core a besoin d’un modèle (Entity Data Model) pour
communiquer avec la base de données
•Intégrer Entity Framework Core et Entity Framework Core SQL Server dans le
projet en utilisant Nuget Package manager • Il construit un modèle basé sur la forme de vos classes de domaine, les
annotations de données et les configurations de Fluent API.
• Créer le modèle (Entity Data Model)
•Le modèle EF comporte trois parties: le modèle conceptuel, le modèle de
• Créer les entités stockage et le mapping entre le modèle conceptuel et de stockage
• Générer la base de données et manipuler les données avec LINQ to Entities • Dans l'approche code-first, EF construit le modèle conceptuel basé sur vos
classes de domaine (classes d'entité), la classe de contexte et les configurations.
• EF Core crée le modèle de stockage et les mappages en fonction du fournisseur
que vous utilisez. Par exemple, le modèle de stockage sera différent pour SQL
Server par rapport à DB2.
15 16

4
15/10/2021

Code First: Etapes à suivre Code First: Etapes à suivre

• EF utilise ce modèle pour les opérations CRUD (Créer, Lire, Mettre à jour,
Supprimer) dans la base de données sous-jacente. Nous devons donc
d'abord créer des classes d'entités et des classes de contexte. Les éléments
suivants sont des classes d'entités simples pour Student et Course :
• Bouton droit sur notre solution (nommée ENISSchool), ajouter classe dans le
dossier modèle, la nommer Student.cs

17 18

Code First: Etapes à suivre Code First: Etapes à suivre


Nous allons de même créer la classe Course.cs

Maintenant, nous créons la classe de contexte. La classe ENISContext est aussi


appelée classe de contexte (context class)

19 20

5
15/10/2021

using Microsoft.EntityFrameworkCore;

using System;

using System.Collections.Generic;

using System.Linq;
Code First: Etapes à suivre
using System.Text;

using System.Threading.Tasks;

• La classe de contexte présentée inclue deux propriétés DbSet<Tentity> pour


Student et Course
namespace ENISSchool

class ENISContext: DbContext

{
• Ces deux vont être mappées à deux tables Students et Courses dans la base de
public DbSet<Student> Students { get; set; }
données ENIS
• Dans la méthode OnConfiguring(),une instance de DbContextOptionsBuilder est
public DbSet<Course> Courses { get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder utilisée pour spécifier quelle est la base de données à utiliser.
optionsBuilder)
{

optionsBuilder.UseSqlServer(@"Server=DESKTOP-
UM4MFE5;Database=SchoolDB;Trusted_Connection=True;");
}

21 22

Code First: Etapes à suivre


Code First: Etapes à suivre
•Le connection string "Server=DESKTOP- • Une fois les classes d’entité et de contexte crées, nous ajoutons une migration
UM4MFE5;Database=<ENISDB;Trusted_Connection=True;" dans la méthode pour créer la base de données
UseSqlServer fourni l’information base de données: Server= spécifie le serveur
•EF Core inclue plusieurs commandes de migration qui permettent de créer et
DB à utiliser (chacun doit mettre le nom de son serveur), Database= spécifie le
nom de la base de données à créer et Trusted_Connection=True spécifie mettre à jour la base de données sur le modèle. Actuellement, il n’y a pas la
base de données ENISDB.
Windows authentication mode. EF Core va utiliser cette connection string pour
créer une base de données quand nous lançons la migration. • Il faut ainsi créer la base de données à partir du modèle (Entités et contexte) en
ajoutant un migration
•La commande de migration peut être exécutée en utilisant Nuget ou bien dotnet
CLI (à travers la ligne de commande)

23 24

6
15/10/2021

Code First: Etapes à suivre Code First: Etapes à suivre

•Dans Vstudio, ouvrir Gestionnaire de Package Nuget, Console du gestionnaire de


package et entrez la commande suivante: add-migration CreateSchoolDB
Un nouveau dossier
•Si vous utilisez .NET CLI, entrez la commande suivante: dotnet ef migrations add Migrations est crée avec des
sous fichiers
CreateSchoolDB

25 26

Code First: Etapes à suivre Code First: Etapes à suivre

Maintenant il est temps de créer la base de données en utilisant la commande


update-database dans la console du package manager:
PM> update-database –verbose
Ou bien si vous utilisez la commande dans NET CLI
dotnet ef database update
• Ainsi, la base de données ENISDB est crée avec le nom et le chemin spécifiés
dans le chemin indiqué dans la connection String. Les tables Students et Courses
sont crées également.

27 28

7
15/10/2021

Code First: Etapes à suivre Code First: Etapes à suivre

• S’il y aura des modifications ou des ajouts dans les classes ou les configurations, Lire et écrire les données
nous avons besoin de synchroniser la base avec le modèle en utilisant les
commandes add-migration et update-database. Maintenant nous pouvons utiliser la classe context pour enregistrer et extraire
les données:
Dans Program.cs:

29 30

using System;
using System.Linq; using (var context = new ENISContext())
using ENISSchool; {
using Microsoft.EntityFrameworkCore;
namespace EnisSchool var std = new Student()
{ {
class Program Name = name,
{ SurName = surname,
static void Main(string[] args) Class=classEtd
{
string name, surname, classEtd; };
Console.WriteLine("The student name:"); context.Students.Add(std);
name = Console.ReadLine(); context.SaveChanges();
Console.WriteLine("The student Surname:"); }
surname = Console.ReadLine(); }
Console.WriteLine("The student class:"); }
classEtd = Console.ReadLine(); }

31 32

8
15/10/2021

Code First: Etapes à suivre Code First: Etapes à suivre

• Maintenant nous avons besoin d’exécuter des requêtes pour extraire les Dans Program.cs, nous ajoutons le code suivant pour afficher l’étudiant ayant un nom saisi par l’utilisateur

informations voulues de la base de données crée var studentsWithSameName = context.Students


.Where(s => s.Name == GetName())
L’interrogation (le querying) de la base de données dans EF Core est presque le
même que EF 6 avec une optimisation plus importante pour les requêtes SQL. .ToList();
if (studentsWithSameName.Count!=0)
• Avec EF Core, il est possible d’inclure des fonctions C# dans les requêtes LINQ-
to-Entities. {
foreach (var elt in studentsWithSameName)
Console.WriteLine($"{elt.Name}, {elt.SurName}, {elt.Class}");
}
else
Console.WriteLine("Not Found");
}
33 34
}

Code First: Etapes à suivre


Modification de données
public static string GetName() Il est possible de modifier les données après les avoir enregistrées dans la base
{ de données. Nous modifions ici le prénom d’un étudiant s’il existe:
string searchedName; Console.WriteLine("The name of the student that you want to modify");

Console.WriteLine("The name of the searched student"); string modif = Console.ReadLine();

searchedName = Console.ReadLine(); var studentsModif = context.Students

return searchedName; .Where(s => s.Name ==


modif)
}
.ToList();

•La fonction Getname() est une fonction C# dans la clause Where.

35 36

9
15/10/2021

Modification de données Suppression des données


if (studentsModif.Count != 0) Si nous voulons supprimer le premier étudiant ayant un certain nom saisi par l’utilisateur:
{ string rmv = Console.ReadLine();
var stdMod=studentsModif.First(); var studentsRemv = context.Students
Console.WriteLine("The new Surname"); .Where(s => s.Name ==
rmv)
string newSurName = Console.ReadLine();
.ToList();
stdMod.SurName = newSurName;
if (studentsRemv.Count != 0)
context.SaveChanges();
{
}
else var stdRemv = studentsRemv.First();
Console.WriteLine("Not Found");
context.Students.Remove(stdRemv);

37 38

Suppression des données Les conventions dans EFCore


Les conventions sont les règles par défaut appliquées par EF Core.
// or • Comme vous pouvez constater, en se basant sur les classes modèles et
// context.Remove<Student>(stdRemv); contexte, nous avons pu créer notre base de données sans être obligé à faire des
context.SaveChanges();
configurations supplémentaires
=> Parce que les classes domaines sont en train de suivre les conventions

39 40

10
15/10/2021

Les conventions dans EFCore Les conventions dans EFCore


Les tables: public class Student public class Grade
{
• EF Core va créer des tables de base de données pour chaque propriété { public int Id { get; set; }
Dbset<Tentity> dans la classe de contexte qui a le même nom que la propriété public int StudentId { get; set; } public int ClassNumber {
get; set; }
• EF Core crée aussi des tables de base de données sans qu’elles soient incluses public string Name { get; set; } public string Speciality {
dans la propriété Dbset mais qui sont accessibles via une propriété de référence public string SurName { get; set;
get; set; }
dans d’autres entités Dbset. } public IList<Student>
•Par exemple dans la classe Student nous pouvons faire référence à la classe public string Class { get; set; } Students { get; set; }
}
Grade public Grade Grade { get; set; }
}

41 42

public class Grade


{
public int Id { get; set; }

Les conventions dans EFCore


public int ClassNumber { get; set; }
public string Speciality { get; set; }

public IList<Student> Students { get;


set; }
•Faisons maintenant la migration et la mise à jour de la base de données pour }
que les modifications prennent effet.
•PM> add-migration MySecondMigration
public class Student
•PM> Update-Database
{
•Visitons maintenant notre base de données public int StudentId { get; set; }

public string Name { get; set; }

public string SurName { get; set; }


La table
public string Class { get; set; }
grade est
bien créee public int GradeId { get; set; }

public Grade Grade { get; set; }

43 44

11
15/10/2021

Type de données C# Mappage au type SQL


int int

Type de données des colonnes string


decimal
nvarchar(Max)
decimal(18,2)
float real
• Le type de données des colonnes de la table de base de données dépend de la
byte[] varbinary(Max)
façon dont le fournisseur de la base de données a mappé le type de données C#
datetime datetime
sur le type de données d'une base de données sélectionnée.
bool bit
• Le tableau suivant répertorie le mappage entre le type de données C# et le type
byte tinyint
de données de colonne SQL Server.
short smallint
long bigint
double float
char No mapping
sbyte No mapping (throws exception)
object No mapping

45 46

Type de données des colonnes Conventions sur la relation un à plusieurs


Clé primaire Afin de voir les conventions par défaut pour la relation un à plusieurs, nous
• EF Core va créer une colonne de clé primaire pour la propriété nommée Id ou <nom de la classe revenons à l’exemple suivant
public class Student public class Grade
entité>Id (non sensible à la casse). Donc si nous avons une propriété dans la classe Student {
nommée id, ID, iD, Id, studentid, StudentId, STUDENTID, or sTUdentID, EF Core va créer une { public int Id { get; set; }
public int ClassNumber { get; set; }
colonne clé primaire dans la table Students public int StudentId { get; set; }
public string Speciality { get; set; }
public string Name { get; set; }
Clé étrangère public IList<Student> Students { get; set; }
public string SurName { get; set; } }
Conformément à la convention de clé étrangère, EF Core API créera une colonne de clé étrangère public string Class { get; set; }
pour chaque propriété de navigation de référence dans une entité . public int GradeId { get; set; }
Dans notre exemple, les entités Student et Grade, EF Core créera une colonne de clé étrangère public Grade Grade { get; set; }
dans la table Students comme illustré dans la figure précédente }

47 48

12
15/10/2021

Conventions sur la relation un à plusieurs Conventions sur la relation un à plusieurs


Pour voir la relation par défaut, ouvrir SQL Server Management Studio->ENISDB- Convention 1:
>Database Diagrams->bouton droit->New Database Diagram-> Choisir Students
et Grades L’étudiant ne peut avoir qu’un SEUL grade, mais un grade peut inclure plusieurs
étudiants. Donc c’est une relation un à plusieurs où la table Students a une clé
étrangère GradeId.
Pour assurer ceci il faut inclure une propriété de navigation de référence dans
l’entité dépendante
• Ici l’entité Student est l’entité dépendante et Grade est l’entité principale

Nous remarquons bien que la relation est par défaut un à plusieurs

49 50

Conventions sur la relation un à plusieurs Convention 2


Convention1 Afin de voir les conventions par défaut pour la relation un à Une autre convention consiste à inclure une propriété de navigation de liste
plusieurs, nous revenons à l’exemple suivant dans l'entité principale, comme indiqué ci-dessous.
public class Student public class Grade public class Grade public class Student
{ {
{ public int Id { get; set; } public int Id { get; set; } {
public int ClassNumber { get; set; } public int ClassNumber { get; set; }
public int StudentId { get; set; } public int StudentId { get; set; }
public string Speciality { get; set; } public string Speciality { get; set; }
public string Name { get; set; } public string Name { get; set; }
} public IList<Student> Students { get; set; }
public string SurName { get; set; } } public string SurName { get; set; }

public string Class { get; set; } }


une propriété de navigation de référence qui permet de relier
Dans l'exemple ci-dessus, l'entité Grade inclut une propriété de navigation de
public Grade Grade { get; set; } le même grade à plusieurs entités Student
} =>Production d’une relation un à plusieurs entre Students et Grades collection de type Ilist<student>. Cela nous permettra d'ajouter plusieurs
EF Core créera une propriété shadow pour la clé étrangère nullable entités Student à une entité Grade, ce qui entraîne une relation un-à-
nommée GradeId dans le modèle conceptuel, qui sera mappée plusieurs entre les tables Students et Grades dans la base de données,
à la colonne de clé étrangère GradeId dans la table Students. comme dans la convention 1.
51 52

13
15/10/2021

Convention 3 Convention 3
• Une autre convention EF pour la relation un-à-plusieurs consiste à inclure une
propriété de navigation aux deux extrémités, ce qui entraînera également une
•Dans l'exemple ci-dessus, l'entité Student inclut une propriété de navigation de
relation un-à-plusieurs (convention 1 + convention 2).
référence de type Grade et la classe d'entité Grade inclut une propriété de
public class Student public class Grade
{
navigation de liste IList<Student>, ce qui entraîne une relation un-à-plusieurs entre
{ public int Id { get; set; } les tables de base de données correspondantes Students et Grades, même comme
public int ClassNumber { get; set; }
public int StudentId { get; set; }
public string Speciality { get; set; } dans la convention 1
public string Name { get; set; }
public IList<Student> Students { get; set; }
public string SurName { get; set; } }

public string Class { get; set; }

public Grade Grade { get; set; }

53 54

Convention 4 Convention 4
La définition complète de la relation aux deux extrémités avec la propriété de clé
étrangère dans l'entité dépendante crée une relation un-à-plusieurs.
public class Student public class Grade
{
{ public int Id { get; set; }
public int StudentId { get; set; }
public int ClassNumber { get; set; } • Dans l'exemple ci-dessus, l'entité Student inclut une propriété de clé étrangère GradeId
public string Speciality { get; set; }
public string Name { get; set; }
de type int et sa propriété de navigation de référence Grade. À l'autre extrémité, l'entité
public string SurName { get; set; } }
public IList<Student> Students { get; set; } Grade inclut également une propriété de navigation de liste IList<Student>. Cela créera
public string Class { get; set; }
une relation un-à-plusieurs avec la colonne de clé étrangère NotNull dans la table
public int GradeId { get; set; }
Étudiants, comme indiqué ci-dessous.
public Grade Grade { get; set; }
• Si vous souhaitez que la clé étrangère GradeId soit nullable, utilisez le type de
}
données int nullable (Nullable<int> ou int?), comme indiqué ci-dessous.
public int? GradeId { get; set; }

55 56

14
15/10/2021

Convention 4 Convention pour la relation un à un


• Par conséquent, ce sont les conventions qui créent automatiquement une • Entity Framework Core a introduit des conventions par défaut qui configurent
relation un-à-plusieurs dans les tables de base de données correspondantes. Si automatiquement une relation un-à-un entre deux entités (EF 6.x ou antérieur
les entités ne respectent pas les conventions ci-dessus, vous pouvez utiliser le ne prend pas en charge les conventions pour les relations un-à-un).
Fluent API pour configurer la relation un-à-plusieurs. • Dans EF Core, une relation un-à-un nécessite une propriété de navigation de
référence des deux côtés. Les entités Student et StudentAddress suivantes
suivent la convention de la relation un-à-un.

57 58

Convention pour la relation un à un Convention pour la relation un à un


public class Student public class StudentAddress
{ { Dans cet exemple, l'entité Student inclut une propriété de navigation de
public int StudentId { get; set; } public int StudentAddressId { get; set;
public string Name { get; set; } } public string Address { get; set; } référence de type StudentAddress et l'entité StudentAddress inclut une
public string SurName { get; set; } public string City { get; set; } propriété de clé étrangère StudentId et sa propriété de référence
public string Class { get; set; } public string State { get; set; } correspondante Student.
public int GradeId { get; set; } public string Country { get; set; }
public Grade Grade { get; set; } • Cela se traduira par une relation un-à-un dans les tableaux correspondants
public StudentAddress Address { get; set; } public int StudentId { get; set; } Student et StudentAddress dans la base de données, comme indiqué ci-
} public Student Student { get; set; } dessous.
}

Faisons une nouvelle migration et mise à jour de la base de données


59 60

15
15/10/2021

Convention pour la relation un à un


• EF Core crée un index unique sur la colonne de clé étrangère NotNull
StudentId dans la table StudentAddresses, comme indiqué ci-dessus.
• Cela garantit que la valeur de la colonne de clé étrangère StudentId doit être
unique dans la table StudentAddress, ce qui est nécessaire pour une relation
un-à-un.

61 62

Relation plusieurs à plusieurs


Relation plusieurs à plusieurs?? Une relation plusieurs à plusieurs existe entre Course et Student
Travail à faire Ajoutons à la classe Student: public IList<Course> Courses { get;
set; }
Et à la classe Course public IList<Student> Students { get; set; }
• Faisons maintenant une nouvelle migration et mise à jour à notre base de données
et visitons par la suite notre base de données dans Sql Server management Studio

63 64

16
15/10/2021

Configurations dans EF Core


• Souvent, nous souhaitons personnaliser le mappage entité-table et ne voulons
pas suivre les conventions par défaut.
• EF Core nous permet de configurer des classes de domaine afin de
personnaliser le modèle EF avec les mappages de base de données. Ce modèle
de programmation est appelé Convention sur Configuration.
• Il existe deux façons de configurer les classes de domaine dans EF Core (comme
dans EF 6).
-En utilisant des attributs d'annotation de données
- En utilisant Fluent API

65 66

Attributs d'annotation de données Attributs d'annotation de données


Ajouter:
• Les annotations de données sont une méthode de configuration simple basée
using System.ComponentModel.DataAnnotations;
sur des attributs où différents attributs .NET peuvent être appliqués aux classes using System.ComponentModel.DataAnnotations.Schema;
et propriétés de domaine pour configurer le modèle.
Le nom de la table devient
• Les attributs d'annotation de données ne sont pas dédiés à Entity Framework, [Table("StudentENIS")] StudentEnis
car ils sont également utilisés dans ASP.NET MVC. C'est pourquoi ces attributs public class Student

sont inclus dans un espace de noms séparé { StudentId est une


System.ComponentModel.DataAnnotations. [Key] clé
L'exemple suivant montre comment les attributs d'annotations de données public int StudentId { get; set; }
[Column("NameStd", TypeName = "ntext")]
peuvent être appliqués à une classe de domaine et à des propriétés pour Le nom de cette colonne est
[MaxLength(30)] NameStd, et sa longueur max
remplacer les conventions. public string Name { get; set; } est 30

67 68

17
15/10/2021

System.ComponentModel.DataAnnotations.Schema Attributes
System.ComponentModel.DataAnnotations Attributes

Attribut Description
System.ComponentModel.DataAnnotations Attributes Attribut Description
Key Peut être appliqué à une propriété pour spécifier une propriété de clé Table Peut être appliqué à une classe d'entité pour configurer le nom de table et le schéma
dans une entité et faire de la colonne correspondante une colonne correspondants dans la base de données.
PrimaryKey dans la base de données.
Column Peut être appliqué à une propriété pour configurer le nom de colonne correspondant,
Required Peut être appliqué à une propriété pour spécifier que la colonne l'ordre et le type de données dans la base de données.
correspondante est une colonne NotNull dans la base de données.
ForeignKey Peut être appliqué à une propriété pour la marquer comme propriété de clé étrangère.
MinLength Peut être appliqué à une propriété pour spécifier la longueur de
NotMapped Peut être appliqué à une propriété ou à une classe d'entités qui doit être exclue du
chaîne minimale autorisée dans la colonne correspondante de la base
modèle et ne doit pas générer de colonne ou de table correspondante dans la base de
de données.
données.
MaxLength Peut être appliqué à une propriété pour spécifier la longueur de
chaîne maximale autorisée dans la colonne correspondante de la base
de données.
StringLength Peut être appliqué à une propriété pour spécifier la longueur de
chaîne maximale autorisée dans la colonne correspondante de la base
de données.
69 70

Question Insérer les données relationnelles


• Ajoutez un nouvel étudiant en utilisant le même code que nous avons déjà écrit • Utilisez la méthode DbContext.Add ou DbSet.Add pour ajouter des entités
• Lancez l’exécution associées à la base de données.
• La méthode Add attache des entités à un contexte et définit l'état Added sur
• Qu’est ce que vous constatez? toutes les entités d'un graphe d'entités dont les propriétés Id (Key) sont vides,
• Selon vous, ce problème est dû à quoi? null ou la valeur par défaut du type de données
•Revenons à notre exemple:

71 72

18
15/10/2021

Insérer les données à une entité


déconnectée Insertion des données relationnelles
using (var context = new ENISContext()) var adr = new StudentAddress()
var grd=new Grade() using (var context = new ENISContext()) {
{
{ Address = " BP 208 route
{ //1. Attach an entity to var grd = new Grade() Gremda, Sfax",
ClassNumber = 88, context with Added EntityState City = "Sfax",
context.Add<Grade>(grd); { State = "Sfax",
Speciality = "GEE" Country = "Tunisia"
ClassNumber = 3,
context.SaveChanges(); };
} Speciality = "GI"
};
};

73 74

Insérer les données relationnelles Question


var std = new Student() context.Students.Add(std);

{ context.SaveChanges();

Name = name,
Comment insérer plusieurs enregistrements en même temps?
SurName = surname,
Class = classEtd,
Comment supprimer les données relationnelles
Grade = grd,
Address=adr

};

75 76

19
15/10/2021

Héritage Héritage
Héritage •Une seule table pour les trois classes : Table per Hierarchy (TPH)
Supposons que l’on a une classe mère Person et deux classes filles Student et • Une table pour chaque classe concrète : Table per Concrete Class (TPC)
Professor qui étendent Personne.
• Une table indépendante pour chaque classe : Table per Type (TPT)
Comment gérer cet héritage?

77 78

Table per Hierarchy Table per Hierarchy


Table per Hierarchy : commençons par créer l’entité Person
C’est le mapping par défaut de l’héritage avec le code First et c’est le seul type using System; public class Person
d’héritage supporté par EF Core {
using System.Collections.Generic; [Key]
using System.ComponentModel.DataAnnotations;
public int Id { get; set; }
using
System.ComponentModel.DataAnnotations.Schema
[MaxLength(20), MinLength(2)]
; public string Name { get; set; }
public string Surname { get; set;
using System.Linq; }
using System.Text; public int Age { get; set; }
}
using System.Threading.Tasks;

namespace Heritage
{

79
} 80

20
15/10/2021

Table per Hierarchy Dans FacContext.cs


Créons l’entité Student using
Et l’entité Professor Microsoft.EntityFrameworkCore; {
namespace Heritage namespace Heritage public DbSet<Person> Persons { get; set; }
using System;
{ public DbSet<Professor> Professors { get; set; }
{ using System.Collections.Generic; public DbSet<Student>Students { get; set; }
class Professor:Person
class Student:Person { using System.Linq; protected override void
public int UniqueId { get; set; } OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{ using System.Text; {
} using System.Threading.Tasks; optionsBuilder.UseSqlServer(@"Server=DESKTOP-
} UM4MFE5;Database=FacDb;Trusted_Connection=True;");
public int }
SubscriptionId { get; set; } namespace Heritage }
} { }
class FacContext: DbContext

81 82

context.Students.Add(std);
static void Main(string[] args) context.SaveChanges();

{ var per = new Person()


{
Name = "Ben Salah",
using (var context = new Surname = "Ali",
FacContext()) Age = 24

Après la migration et la mise à jour, visitons notre base de données {


};

var std = new Student() context.Persons.Add(per);


context.SaveChanges();
Une seule table {
générée var prof = new Professor()
Name = "Ben Salah", {
Surname = "Ali", Name = "Ben",
Surname = "Mohamed",
Age = 24, Age = 55,
UniqueId=122333
SubscriptionId =
2526666
};

Spécifique à }; context.Professors.Add(prof);
Professor context.SaveChanges();
Spécifique à }
Student }
}
}
83 84

21
15/10/2021

Table per Hierarchy Table per Hierarchy


• Allons voir la base de données, une seule table Personne a été crée. Cette table
a les colonnes Id, Name, Surname, Age, UniqueId, SubscriptionId et
Discriminator
•Discriminator va enregistrer une valeur pour informer Entity Framework Core
quelle est la classe à mapper (person, student ou professor)
•Nous constatons que TPH a un problème majeur: les colonnes des propriétés
déclarées dans les sous-classes vont être NULL dans la base de données:
• La personne Ben Mohamed a la valeur null dans SubscriptionId et la valeur
Professor dans Discriminator

85 86

Table per Hierarchy Table per Hierarchy


Pour récupérer et afficher la liste des personnes Table per Concrete Class et Table per Type sont supportés par EF6 mais ne sont
pas encore supportés par EF Core
var PersonName = from perso in context.Persons select perso;
foreach (var elt in PersonName)
Console.WriteLine($"{elt.Name}");

87 88

22
15/10/2021

Database first Database first


Génération du modèle Dans la commande ci-dessus, le premier paramètre est une chaîne de
1. Créer un nouveau projet. connexion qui comprend trois parties : le serveur de base de données, le nom
2. Ajouter via Nuget: EntityFramework.MicrosoftSqlServer.Design, de la base de données et les informations de sécurité. Ici, Server=DESKTOP-
Microsoft.EntityFrameworkCore.SqlServer et UM4MFE5 est mon serveur de base de données, SchoolDB ; spécifie le nom de
Microsoft.EntityFrameworkCore.Tools la base de données "SchoolDB" pour laquelle nous allons créer des classes.
3. Ecrire dans la console du gestionnaire du pckage: Trusted_Connection=True ; spécifie l'authentification Windows. Il utilisera les
Scaffold-DbContext "Server=DESKTOP- informations d'identification Windows pour se connecter au serveur SQL.
UM4MFE5;Database=ENISDB;Trusted_Connection=True;" •Le deuxième paramètre est le nom du fournisseur. Nous utilisons le
Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models fournisseur pour le serveur SQL, il s'agit donc de
Microsoft.EntityFrameworkCore.SqlServer. Le paramètre -OutputDir spécifie le
répertoire où nous voulons générer toutes les classes qui est le dossier Models
dans ce cas.
89 90

Database first
La commande Scaffold-DbContext ci-dessus crée des classes d'entités pour
chaque table de la base de données SchoolDB et une classe de contexte (en
dérivant DbContext) avec des configurations d'API Fluent pour toutes les entités
du dossier Models.

91

23

Vous aimerez peut-être aussi