RESUME: COURS ARCHITECTURE NTIERS .

NET
Tarek Ayari

TAREK AYARI 1
ORM: ENTITYFRAMEWORK

TAREK AYARI 2
LES DIFFÉRENTES APPROCHES ENTITY FRAMEWORK
L’approche Model First
L’approche Model First est une approche qui est issue des méthodes de conception classique. Vous l’utiliserez le plus
souvent lorsque quelqu’un qui a des connaissances en base de données, notamment la méthode MERISE1.

Cette approche se base sur l’existence de diagramme de base de données parfois appelés Modèle Logique de Données.
Ces diagrammes présentent les entités comme des classes possédant des attributs et notamment une clef primaire et
les relient avec de simples traits.

TAREK AYARI 3
LES DIFFÉRENTES APPROCHES ENTITY FRAMEWORK
L’approche Database First
Comme son nom l’indique, cette méthode implique que vous créiez votre base de données de A à Z en SQL puis que vous
l’importiez dans votre code. C’est une nouvelle fois le Modèle Logique de Données qui fera le lien entre la base de
données et l’ORM. La seule différence c’est que cette fois-ci c’est Visual Studio qui va générer le schéma par une
procédure de rétro ingénierie.

TAREK AYARI 4
LES DIFFÉRENTES APPROCHES ENTITY FRAMEWORK
L’approche Code First
Cette dernière approche, qui est celle que nous avons choisi, part d’un constat : ce qu’un développeur sait faire de mieux,
c’est coder.

Cette approche, qui est la plus commune dans le monde des ORM consiste à vous fournir trois outils pour que vous,
développeur, n’ayez qu’à coder des classes comme vous le feriez habituellement et en déduire le modèle qui doit être
généré.

TAREK AYARI 5
COMMENT CHOISIR SON APPROCHE

TAREK AYARI 6
LA CLASSE DBCONTEXT

TAREK AYARI 7
CONTEXT CLASS
La classe DbContext est la classe principale utilisée pour interagir avec la base de données , elle définit les entités qui
vont être converties à des tables dans notre base de données, elle permet d'effectuer les tâches suivantes :

• Gérer la connexion à la base de données

• Configurer le modèle et la relation
• Interroger la base de données
• Sauvegarde des données dans la base de données
• Configurer le suivi des changements
• Mise en cache
• Gérer les transactions

TAREK AYARI 8
DATABASE INITIALIZATION: DATABASE NAME
• Vous pouvez également spécifier le nom de la base de données comme paramètre dans
un constructeur de base de la classe de contexte.
• Si vous spécifiez un paramètre de nom de base de données, alors Code First crée une
base de données avec le nom que vous avez spécifié dans le constructeur de base du
serveur de base de données local SQLEXPRESS.
namespace SchoolDataLayer
{
public class Context: DbContext
{
public Context(): base("MySchoolDB")
{

}
}
} TAREK AYARI 9
DATABASE INITIALIZATION: CONNECTIONSTRING NAME
Vous pouvez également définir la chaîne de connexion dans app.config ou web.config et
spécifier le nom de la chaîne de connexion commençant par "name=" dans le constructeur
de base de la classe de contexte.

namespace SchoolDataLayer <?xml version="1.0" encoding="utf-8" ?>

{ <configuration>
public class Context: DbContext <connectionStrings>
{ <add name="SchoolDBConnectionString"
public SchoolDBContext() : connectionString= "Data Source=.;Initial Catalog=SchoolDB-
base("name=SchoolDBConnectionString") ByConnectionString;Integrated Security=true"
{ providerName="System.Data.SqlClient"/>
} </connectionStrings>
} </configuration>
}

TAREK AYARI 10
ENTITY FRAMEWORK - HÉRITAGE

TAREK AYARI 11
TABLE PER HIERARCHY (TPH)
• Dans ce modèle il y a une seule table qui représente toutes les classes dans la
hiérarchie d'héritage. C’est la stratégie de mappage d'héritage par défaut dans Entity
Framework.
• Cela rend l'accès aux données très simple, mais repose sur l'utilisation de NULLs dans
de nombreuses colonnes puisque la table finit par avoir l'ensemble complet de toutes
les propriétés pour toutes les classes impliquées.

TAREK AYARI 12
TABLE PER TYPE (TPT)
• Ce modèle utilise une table différente pour chaque classe (y compris les classes de
base abstraites) dans la hiérarchie. Les propriétés héritées se trouvent dans la table
"classe de base", et les propriétés des sous-classes sont dans leurs propres tables.
• Ces tables "dérivées" ont des colonnes de clés primaires ID qui sont une clé étrangère
à la clé primaire de la table de la classe de base...

TAREK AYARI 13
TABLE PER CONCRETE TYPE (TPC)
• Ce motif final utilise d'abord une table de base de données pour chaque classe non
abstraite (concrète) dans la hiérarchie.
• Chaque table est autonome, ayant toutes les propriétés requises par une classe, y compris
ses propriétés héritées.
• Il n'y a pas de relations entre les tables de la base de données (elles semblent simplement
liées parce qu'elles ont des noms de colonnes communs).

TAREK AYARI 14
STRATÉGIES D'INITIALISATION DES BASES DE DONNÉES

TAREK AYARI 15
DATABASE INITIALIZATION STRATEGIES
Il existe quatre stratégies d'initialisation de base de données différentes :
• CreateDatabaseIfNotExists : C'est l'initialiseur par défaut. Comme son nom l'indique, il créera la base de
données s'il n'en existe aucune selon la configuration. Cependant, si vous changez la classe de modèle et exécutez
ensuite l'application avec cet initialiseur, alors une exception sera levée.

• DropCreateDatabaseIfModelChanges : Cet initialiseur supprime une base de données existante et en crée une
nouvelle, si vos classes de modèle (classes d'entités) ont été modifiées. Ainsi, vous n'avez pas à vous soucier de la
maintenance de votre schéma de base de données, lorsque vos classes de modèle changent.

TAREK AYARI 16
DATABASE INITIALIZATION STRATEGIES
Il existe quatre stratégies d'initialisation de base de données différentes :
• DropCreateDatabaseAlways : Comme son nom l'indique, cet initialiseur supprime une base de données
existante chaque fois que vous exécutez l'application, que vos classes de modèle aient changé ou non. Ceci sera utile
lorsque vous voulez une nouvelle base de données chaque fois que vous exécutez l'application, par exemple lorsque
vous développez l'application.

• Initialiseur de base de données personnalisé : Vous pouvez également créer votre propre initialiseur
personnalisé, si ce qui précède ne répond pas à vos exigences ou si vous souhaitez effectuer un autre processus qui
initialise la base de données en utilisant l’initialiseur ci-dessus.

TAREK AYARI 17
DATABASE INITIALIZATION STRATEGIES
Pour utiliser l'une des stratégies d'initialisation de base de données ci-dessus, vous devez définir l'initialiseur de base
de données en utilisant la classe Database dans une classe de contexte, comme indiqué ci-dessous :
public class SchoolDBContext: DbContext
{
public SchoolDBContext(): base("SchoolDBConnectionString")
{
Database.SetInitializer<SchoolDBContext>(new CreateDatabaseIfNotExists<SchoolDBContext>());

//Database.SetInitializer<SchoolDBContext>(new DropCreateDatabaseIfModelChanges<SchoolDBContext>());
//Database.SetInitializer<SchoolDBContext>(new DropCreateDatabaseAlways<SchoolDBContext>());
//Database.SetInitializer<SchoolDBContext>(new SchoolDBInitializer());
}

public DbSet<Student> Students { get; set; }

public DbSet<Standard> Standards { get; set; }
}
TAREK AYARI 18
ENTITY FRAMEWORK MIGRATION

TAREK AYARI 19
ENTITY FRAMEWORK INTRODUCED A MIGRATION
Entity Framework a introduit un outil de migration qui met automatiquement à jour le schéma de
base de données lorsque votre modèle change sans perdre aucune donnée existante ou
d'autres objets de base de données. Il utilise un nouvel initialiseur de base de données appelé

Il existe deux types de migration :

1. Migration automatisée

2. Migration basée sur le code

TAREK AYARI 20
AUTOMATED MIGRATION IN ENTITY FRAMEWORK 6:
• Entity Framework a introduit la migration automatisée afin que vous n'ayez pas à traiter
manuellement la migration des bases de données pour chaque changement que vous
apportez à vos classes de domaines.

• Les migrations automatisées peuvent être implémentées en exécutant la commande

enable-migrations dans la console Package Manager.

• Ouvrez la console du gestionnaire de paquets à partir de Outils → Library Package

Manager → Package Manager Console puis exécutez la commande
enable-migrations -EnableAutomaticMigration:$true (assurez-vous que le projet par défaut
est le projet où est votre classe de contexte).

TAREK AYARI 21
AUTOMATED MIGRATION IN ENTITY FRAMEWORK 6:
- Cependant, cela ne fonctionne que si vous ajoutez de nouvelles classes de domaine ou
supprimez des classes, mais cela ne fonctionnera pas lorsque vous ajoutez, modifiez ou
supprimez des propriétés dans les classes de domaine.
- Pour ce faire, supprimez toute propriété d'une classe
de domaine et exécutez l'application. Vous obtiendrez
l'exception suivante.
- Donc, pour gérer ce type de scénario, vous devez définir AutomaticMigrationDataLossAllowed
à true dans le constructeur de classe Configuration, avec AutomaticMigrationsEnabled = true ;

TAREK AYARI 22
MANUAL MIGRATION IN ENTITY FRAMEWORK 6
Pour utiliser la migration basée sur le code, vous devez exécuter les commandes suivantes dans
la console du Package Manager Console de Visual Studio :

1. Activer-Migrations : Permet la migration dans votre projet en créant une classe de

configuration.

2. Ajouter-Migration : Crée une nouvelle classe de migration selon le nom spécifié avec les
méthodes Up() et Down().

3. Mise à jour de la base de données : Exécute le dernier fichier de migration créé par la
commande Ajouter-Migration et applique les modifications au schéma de la base de
données.

TAREK AYARI 23
ENTITY FRAMEWORK - DATA ANNOTATIONS

TAREK AYARI 24
DATA ANNOTATIONS ATTRIBUTES IN EF 6
• Les attributs d'annotations de données sont des attributs.NET qui peuvent être appliqués à une
classe ou à des propriétés d'entité pour remplacer les conventions par défaut dans EF
• Les attributs d'annotation des données sont inclus dans les espaces de noms
System.ComponentModel.DataAnnotations et System.ComponentModel.DataAnnotations.Schema
dans EF.
• System.ComponentModel.DataAnnotations: inclut les attributs suivants qui ont un impact sur la
nullité ou la taille de la colonne: (Key, Required, MinLength, MaxLength, StringLength)
• System.ComponentModel.DataAnnotations.Schema: inclut les attributs suivants qui ont un impact
sur le schéma de la base de données: (Table, Column, Index, ForeignKey, NotMapped)

TAREK AYARI 25
 DATA ANNOTATIONS ATTRIBUTES IN EF 6
System.ComponentModel.DataAnnotations Attributes
Attribute Description
Key Peut être appliqué à une propriété pour spécifier une propriété clé dans une entité et faire de la colonne correspondante
une colonne PrimaryKey dans la base de données.
Timestamp Peut être appliqué à une propriété pour spécifier le type de données d'une colonne correspondante dans la base de
données en tant que Timestamp .
Required Peut être appliqué à une propriété pour spécifier que la colonne correspondante doit être incluse dans le contrôle des
champs obligatoires.
MinLength Peut être appliqué à une propriété pour spécifier la longueur minimale autorisée dans la colonne correspondante , Il peut
être appliqué aux propriétés string ou byte[].
MaxLength Peut être appliqué à une propriété pour spécifier la longueur maximale autorisée dans la colonne , Il peut être appliqué
aux propriétés string ou byte[].
StringLength Peut être appliqué à une propriété pour spécifier la longueur maximale de la chaîne autorisée dans la colonne
correspondante de la base de données..
DataType Cet attribut permet de spécifier le type de données du modèle
Compare Comparer avec d'autres champs .
Range Spécifie une plage de valeurs numériques pour un nombre.
Display Utilisée pour changer le nom d une colonne dans l'interface utilisateur. TAREK AYARI 26
 DATA ANNOTATIONS ATTRIBUTES IN EF 6
System.ComponentModel.DataAnnotations.Schema Attributes
Attribute Description
Table Peut être appliqué à une classe d'entité pour configurer le nom de table et le schéma
correspondants dans la base de données.
Column Peut être appliqué à une propriété pour configurer le nom de colonne, l'ordre et le
type de données correspondants dans la base de données.
Index Peut être appliqué à une propriété pour configurer que la colonne correspondante doit
avoir un index dans la base de données. (EF 6.1 et suivants uniquement)
ForeignKey Peut être appliqué à une propriété pour la marquer comme une propriété de clé
étrangère.
NotMapped Peut être appliqué à une classe de propriété ou d'entité qui doit être exclue du modèle
et ne doit pas générer une colonne ou une table correspondante dans la base de
données.
DatabaseGenerated Peut être appliqué à une propriété pour configurer comment la base de données doit
générer la valeur de la colonne correspondante, par exemple l'identité, calculée ou
non. TAREK AYARI 27
ENTITY FRAMEWORK FLUENT API

TAREK AYARI 28
ENTITY FRAMEWORK FLUENT API
• L'API Entity Framework Fluent est utilisée pour configurer les classes de domaine afin de remplacer les conventions.
• En utilisant la classe DbModelBuilder nous pouvons configurer de nombreuses choses différentes.
• Il offre plus d'options de configuration que les « DataAnnotation » de données.
• Pour écrire des configurations API fluent , remplacez la méthode OnModelCreating() de DbContext, comme indiqué ci-
dessous.
public class SchoolContext: DbContext
{

public DbSet<Student> Students { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{
//Write Fluent API configurations here

}
}
TAREK AYARI 29
 ENTITY FRAMEWORK FLUENT API
Le tableau suivant énumère les principales méthodes Fluent API.
Configurations Fluent API Methods Usage
ComplexType() Configure la classe en tant que type complexe.
Configurations des HasIndex() Configure la propriété d'index pour le type d'entité.
entités HasKey() Configure la propriété de la clé primaire pour le type d'entité.
HasMany() Configure la relation Nombreux pour les relations d'un à plusieurs ou
de plusieurs à plusieurs.
HasOptional() Configure une relation optionnelle qui créera une clé étrangère
nullable dans la base de données.
HasRequired() Configure la relation requise qui créera une colonne de clé étrangère
non nullable dans la base de données.
Ignore() Configure que la classe ou la propriété ne doit pas être mappée à
une table ou à une colonne.
Map() Permet une configuration avancée liée à la façon dont l'entité est
mappée au schéma de la base de données.
ToTable() Configure le nom de la table pour l'entité.

TAREK AYARI 30
 ENTITY FRAMEWORK FLUENT API
Le tableau suivant énumère les principales méthodes Fluent API.

Configurations IsRequired() Configure la propriété qui sera requise sur SaveChanges().

des propriétés
IsOptional() Configure la propriété pour être optionnelle ce qui créera une colonne nullable
dans la base de données.
HasDatabaseGeneratedOption() Configure la façon dont la valeur sera générée pour la colonne correspondante
dans la base de données, par exemple calculée, identité ou aucune.

HasColumnOrder() Configure l'ordre de la colonne de la base de données utilisée pour stocker la

propriété.
HasColumnType() Configure le type de données de la colonne correspondante d'une propriété dans
la base de données.
HasColumnName() Configure le nom de colonne correspondant d'une propriété dans la base de
données.

TAREK AYARI 31
CONFIGURE PRIMARY KEY: HASKEY()
public class SchoolContext: DbContext
{
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
//Configure primary key
modelBuilder.Entity<Student>().HasKey(s => s.StudentKey);
modelBuilder.Entity<Classroom>().HasKey(s => s.ClassroomKey);

//Configure composite primary key

modelBuilder.Entity<Student>().HasKey(s => new { s.StudentKey, s.StudentName });
}
}

TAREK AYARI 32
 CONFIGURE COLUMN NAME, TYPE AND ORDER
La convention par défaut Code-First crée une colonne pour une propriété ayant le même nom, le
même ordre et le même type de données.
public class SchoolContext: DbContext
{
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
//Configure Column
modelBuilder.Entity<Student>()
.Property(p => p.DateOfBirth)
.HasColumnName("DoB")
.HasColumnOrder(3)
.HasColumnType("datetime2");
}
}
TAREK AYARI 33
 CONFIGURE A ONE-TO-ZERO-OR-ONE RELATIONSHIP
L'exemple suivant définit une relation de un à zéro ou une relation entre Student et StudentAddress
en utilisant Fluent API
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
// Configure Student & StudentAddress entity
modelBuilder.Entity<Student>()
.HasOptional(s => s.Address)
.WithRequired(ad => ad.Student);
}

La méthode HasOptional() configure la propriété de navigation Adresse dans l'entité Student comme
optionnelle (non requise lors de l'enregistrement de l'entité Student).
Ensuite, la méthode WithRequired() fait de la navigation Student la propriété de StudentAddress
comme requis
TAREK AYARI 34
 CONFIGURE A ONE-TO-ONE RELATIONSHIP
Nous pouvons configurer une relation one-to-One entre des entités utilisant Fluent API où les deux
extrémités sont requises, ce qui signifie que l'objet d'entité Student doit inclure l'objet d'entité
StudentAddress et l'entité StudentAddress doit inclure l'objet d'entité Student afin de le
sauvegarder.
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
// Configure StudentId as FK for StudentAddress
modelBuilder.Entity<Student>()
.HasRequired(s => s.Address)
.WithRequiredPrincipal(ad => ad.Student);

TAREK AYARI 35
 CONFIGURE A ONE-TO-MANY RELATIONSHIP
public class SchoolContext : DbContext
{
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
// configures one-to-many relationship
modelBuilder.Entity<Student>()
.HasRequired<Grade>(s => s.CurrentGrade)
.WithMany(g => g.Students)
.HasForeignKey<int>(s => s.CurrentGradeId); }
}
}

- .HasRequired<Grade>(s => s.CurrentGrade) : spécifie que l'entité Student a requis la propriété CurrentGrade. Ceci créera
une colonne de clé étrangère NotNull dans la base de données.
- WithMany(g => g.Students) : spécifie que la classe d'entité Grade comprend plusieurs entités Student. Ici, beaucoup
déduisent la propriété de type ICollection.
- .HasForeignKey<int>(s => s.CurrentGradeId) : spécifie la propriété de clé étrangère dans l'entité Student.
TAREK AYARI 36
 CONFIGURE A MANY-TO-MANY RELATIONSHIP
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<Student>()
.HasMany<Course>(s => s.Courses)
.WithMany(c => c.Students)
.Map(cs =>
{
cs.MapLeftKey("StudentRefId");
cs.MapRightKey("CourseRefId");
cs.ToTable("StudentCourse");
});
}
• Dans l'exemple ci-dessus, les méthodes HasMany() et WithMany() sont utilisées pour configurer une relation à
plusieurs entre les entités Student et Course.
• Nous pouvons spécifier le nom de propriété PK de Student dans MapLeftKey() (nous avons commencé avec l'entité
Student, ce sera donc la table de gauche) et le PK de la table Course dans la méthode MapRightKey().
• La méthode ToTable() spécifie le nom d'une table d'assemblage (StudentCourse dans ce cas). TAREK AYARI 37
USING SEPARATE CONFIGURATION CLASS
Maintenant, vous pouvez déplacer toutes les configurations relatives à l'entité Etudiant dans une classe séparée qui dérive de
EntityTypeConfiguration<TEntity>.
public class StudentEntityConfiguration: EntityTypeConfiguration<Student>
{
public StudentEntityConfiguration()
{
this.ToTable("StudentInfo");

this.HasKey<int>(s => s.StudentKey);

this.Property(p => p.DateOfBirth) this.HasMany<Course>(s => s.Courses)

.HasColumnName("DoB") .WithMany(c => c.Students)
.HasColumnOrder(3) .Map(cs =>
.HasColumnType("datetime2"); {
cs.MapLeftKey("StudentId");
this.Property(p => p.StudentName) cs.MapRightKey("CourseId");
.HasMaxLength(50); cs.ToTable("StudentCourse");
});
this.Property(p => p.StudentName) }
.IsConcurrencyToken(); }
TAREK AYARI 38
USING SEPARATE CONFIGURATION CLASS
Maintenant, vous devez ajouter cette classe de configuration personnalisée en utilisant Fluent API, comme indiqué ci-dessous.
public class SchoolDBContext: DbContext
{

public DbSet<Student> Students { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{
// Moved all Student related configuration to StudentEntityConfiguration class
modelBuilder.Configurations.Add(new StudentEntityConfiguration());
}
}

TAREK AYARI 39
CONFIGURATION CONVENTION
• Vous pouvez définir une convention de configuration dans la méthode OnModelCreating() et aussi dans une classe
personnalisée, comme vous le feriez avec Fluent API.
• Ce qui suit définit une convention pour les propriétés des chaînes de caractères.
• Il créera des colonnes nvarchar de taille 50 dans SQL Server pour toutes les propriétés de type chaîne d'une entité.

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{
modelBuilder
.Properties()
.Where(p => p.PropertyType.Name == "String")
.Configure(p => p.HasMaxLength(50));

base.OnModelCreating(modelBuilder);
}

TAREK AYARI 40
 DEFINE A CUSTOM CLASS FOR CONVENTION
• Vous pouvez également définir une classe personnalisée pour cette convention en dérivant la classe Convention,
comme indiqué ci-dessous :
public class PKConvention : Convention
{
public PKConvention()
{
.Properties()
.Where(p => p.PropertyType.Name == "String")
.Configure(p => p.HasMaxLength(50));
}
}
• Après avoir créé une classe de convention personnalisée, ajoutez-la dans les conventions comme indiqué ci-dessous :
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Conventions.Add<PKConvention>();
}
TAREK AYARI 41
ASP.NET– MVC

TAREK AYARI 42
ARCHITECTURE D’UNE APPLICATION MVC
RÔLES DES COMPOSANTS : MVC – M
• Le modèle représente le cœur de l’application. Il est la partie qui va manipuler
les données et/ou information d’une Base de données. Il permet de mettre à
jour ces données comme par exemple les supprimer, modifier leur valeur etc…

• La partie Modèle d’une architecture MVC encapsule la logique métier (business

logic) ainsi que l’accès aux données. Il peut s’agir d’un ensemble de fonctions
(Modèle procédural) ou de classes (Modèle orienté objet).
RÔLES DES COMPOSANTS : MVC – V
• La vue est toute la partie graphique de notre application. Son but premier est
d’afficher les données du Modèle. Mais elle est également celle qui va recevoir
tous les évènements que vas produire l’utilisateur (Clic de souris, mouvement,
case cochée etc).

• Plusieurs vues peuvent afficher différentes informations du même modèle.

• Par exemple, un entier pourras être affiché de différentes sortes: En binaire, en

Hexadécimal, avec des curseurs…
 RÔLES DES COMPOSANTS : MVC – C
• Le contrôleur va, en fonctions des évènements produits par l’utilisateur, mettre à
jour la vue ou le modèle et synchroniser ceux-ci.

• Il va, en fonction des actions de l’utilisateur effectuer diverses actions. Si, par les
évènements de l’utilisateur, la vue doit être modifiée, le contrôleur va lui
signaler. Inversement, si des données doivent être modifiées le contrôleur vas le
signaler au modèle qui va s’en charger.

• La partie Contrôleur gère la dynamique de l’application. Elle fait le lien entre

l’utilisateur et le reste de l’application
PATRON DE CONCEPTION

TAREK AYARI 47
 DISPOSE PATTERN
• Dans la programmation orientée objet, le pattern « Dispose » est un modèle de
conception pour la gestion des ressources mémoires.
• Dans ce modèle, une ressource est détenue par un objet, et libérée en appelant
une méthode - généralement appelée dispose - qui libère toutes les ressources
auxquelles l'objet est retenu.
• De nombreux langages proposent des mécanismes pour éviter d'avoir à appeler
explicitement la méthode dispose dans des situations courantes.

TAREK AYARI 48
 DISPOSE PATTERN: LE GARBAGE COLLECTOR (GC)
• Le garbage collector (GC) de .NET est une partie du Common Language Runtime (CLR)
de .NET et est disponible pour tous les langages de programmation .NET.
• Le GC a été conçu pour gérer l'allocation de mémoire, et il fait un excellent travail
pour gérer la mémoire allouée directement aux objets.NET natifs.
• Les ressources non managées sont tout ce que le garbage collector ne peut pas gérer,
par exemple : les fichiers ouverts, les connexions de base de données ...
• L’utilisation principale de ce « design pattern » est de libérer des ressources non
managées. Cela réduit la dépendance à l'égard du GC et fournit aux utilisateurs un
moyen de récupérer les ressources de façon déterministe.
TAREK AYARI 49
 FACTORY PATTERN
• Les principes d’une bonne conception objet recommandent l’utilisation d’interfaces
plutôt que des implémentations dans le but de découpler au maximum l’appelant et les
classes concrètes (ce qui permet de remplacer facilement une implémentation par une
autre sans tout modifier)
• Le design pattern Factory, ou Fabrique est un design pattern permettant de séparer la
création d'objets dérivant d'une classe mère de leur utilisation. De ce fait, on a alors la
possibilité de créer plusieurs objets issue d'une même classe mère.
• Ce pattern est très utile dans le cas ou il n’est pas possible de savoir à l’avance quelle
implémentation concrète sera utilisée

TAREK AYARI 50
 FACTORY PATTERN
• Voici le diagramme UML du design pattern Factory :

Définissez une interface pour créer un objet, mais laissez les sous-classes décider
de la classe à instancier. Factory Method permet à une classe de différer
l'instanciation des sous-classes.

TAREK AYARI 51
 REPOSITORY PATTERN
• Ce pattern répond à un besoin d'accès aux données stockées en base. Son but
principal est d'isoler la couche d'accès aux données de la couche métier.
• Il expose diverses méthodes s'appuyant sur un modèle CRUD (Create, Read,
Update, Delete).
• Ce modèle fournis une centralisation de transaction aux données.
• Ils visent à créer une couche d'abstraction entre la couche d'accès aux données et
la couche logique métier d'une application.

TAREK AYARI 52
 REPOSITORY PATTERN : CRÉATION
• Un repository est de manière générale, basé sur cinq méthodes nécessaires à
l'accès aux données :

• La sélection d'un enregistrement d'une table via son ID

• La sélection de tous les enregistrements
• La mise à jour
• L'insertion
• La suppression

Cette liste est cependant loin d'être exhaustive, vous pouvez l'étendre à votre
convenance afin d'implémenter des méthodes répondant à vos besoins.

TAREK AYARI 53
 UNIT OF WORK PATTERN
Le pattern Unit of work a deux tâches importantes :
• Conserver la liste de demandes d’écriture à la base de
donnée au même endroit (la liste peut contenir plusieurs
demandes d'insertion, de mise à jour et de suppression)
• Envoyer ces demandes en une seule transaction
à la base de données.
• Toutes les transactions telles que l'insertion / mise à jour /
supprimer et ainsi de suite sont fait en une seule transaction,
plutôt que de faire des transactions de bases de données
multiples. TAREK AYARI 54
ARCHITECTURE DE L APPLICATION
Le schéma suivant montre l’architecture de l’application:

TAREK AYARI 55
CORRECTION QCM

https://forms.gle/EqAiLS2bHb4pK8L76

TAREK AYARI 56
QUIZ

TAREK AYARI 57