Entity Framework Core de Microsoft est une version multiplateforme, légère et flexible de son prédécesseur, Entity Framework. EF Core est un outil de mappage objet-relationnel (ORM) qui offre un moyen standardisé de stocker et de récupérer des données vers et depuis diverses sources de données.
En programmant selon un modèle conceptuel plutôt que relationnel. Par conséquent, il n'y a pas de décalage d'impédance entre la manière dont les données sont représentées dans l'application et la manière dont elles sont stockées dans la base de données.
L'héritage est une fonctionnalité de la programmation orientée objet qui vous permet de créer des sous-classes à partir d'une classe de base, étendant ainsi les fonctionnalités de la classe de base. Entity Framework Core offre une excellente prise en charge de l'héritage. Cet article explique comment nous pouvons implémenter l'héritage dans Entity Framework Core. Nous profiterons d'EntityDeveloper pour parler à la base de données.
Pré-requis
Pour pouvoir travailler avec les exemples de code présentés dans cet article, les éléments suivants doivent être installés sur votre système :
- Visual Studio 2019 Community Edition (téléchargement)
- dotConnect pour PostgreSQL (téléchargement)
- Développeur d'entités
Vous pouvez télécharger une copie d'Entity Developer (version d'essai) à partir d'ici :https://www.devart.com/entitydeveloper/download.html.
Créer une base de données
Maintenant que le projet API Web ASP.NET Core a été créé dans Visual Studio 2019; l'étape suivante consiste à créer la base de données. Notez que par souci de simplicité, nous utiliserons une base de données avec quelques deux tables avec des conceptions simples dans cet exemple. Créez une base de données appelée Demo et créez-y trois tables (Person, User et Manager). Les champs de ces tables doivent correspondre aux propriétés des classes de modèles présentées plus loin dans cet article.
Créer un nouveau projet d'API Web ASP.NET Core
En supposant que le logiciel nécessaire a été installé sur votre ordinateur pour pouvoir travailler avec le développeur d'entités, suivez les étapes décrites ci-dessous pour créer un nouveau projet d'API Web ASP.NET Core.
1. Tout d'abord, ouvrez l'IDE Visual Studio 2019.
2. Ensuite, cliquez sur Créer un nouveau projet une fois l'IDE chargé.
3. Cliquez sur Créer un nouveau projet .
4. Ensuite, sélectionnez Application Web ASP.NET Core .
5. Cliquez sur Suivant .
6. Spécifiez le nom et l'emplacement du projet – où il doit être stocké dans votre système.
7. Facultativement, cliquez sur Placer la solution et le projet dans le même répertoire case à cocher.
8. Ensuite, cliquez sur Créer .
9. Dans le Créer une nouvelle application Web ASP.NET Core fenêtre de dialogue qui s'affiche ensuite, sélectionnez API comme modèle de projet.
10. Sélectionnez ASP.NET Core 3.1 ou version ultérieure comme version.
11. Vous devez désactiver la Configuration pour HTTPS et activer la prise en charge de Docker options en désactivant les cases à cocher respectives.
12. Puisque nous n'utiliserons pas l'authentification dans cet exemple, spécifiez l'authentification comme Aucune authentification .
13. Enfin, cliquez sur Créer bouton pour terminer le processus.
Créer un modèle de données d'entité
La prochaine chose que vous devez faire est de créer un modèle de données d'entité. Lorsque vous créez un modèle dans Entity Developer, vous avez le choix entre deux options :la base de données d'abord (sélectionnée par défaut) et le modèle d'abord. Dans cet exemple, nous tirerons parti de l'approche Database First. N'oubliez pas de sélectionner Générer à partir de la base de données possibilité de générer votre modèle à partir de la base de données et de sélectionner les objets de base de données que vous souhaitez intégrer à votre modèle de données d'entité.
Suivez ces étapes décrites ci-dessous pour créer un modèle de données d'entité dans Entity Developer en utilisant l'approche basée sur la base de données.
1. Sélectionnez votre projet dans l'Explorateur de solutions Fenêtre.
2. Faites un clic droit et sélectionnez Ajouter>Nouvel élément .
3. Sélectionnez Devart EF Core Model comme modèle comme indiqué ci-dessous.
4. Spécifiez un nom pour votre modèle de données d'entité et cliquez sur Ajouter .
5. Spécifiez les propriétés de connexion et testez la connexion.
6. Cliquez sur Suivant continuer.
7. Par défaut, l'option "Générer à partir de la base de données" sera sélectionnée. Puisque nous voulons que le modèle soit créé à partir de la base de données, cliquez sur Suivant continuer.
8. Désélectionnez toutes les options, puis spécifiez uniquement les objets de base de données que vous souhaitez intégrer au modèle. C'est ici que vous devez sélectionner les tables Produits et Catégories.
9. Dans la Configuration règles de nommage écran, vous pouvez éventuellement spécifier des règles de nommage pour vos entités.
10. Dans l'écran suivant, vous pouvez éventuellement spécifier les propriétés du modèle.
11. Dans l'écran suivant, vous pouvez éventuellement choisir le contenu du diagramme du modèle.
12. Dans l'écran suivant, vous pouvez éventuellement spécifier des modèles de génération de code.
13. Spécifiez le modèle de génération de code de votre choix.
14. Enfin, cliquez sur Terminer pour terminer le processus.
Votre modèle de données d'entité ADO.NET utilisant Entity Developer sera créé avec le contexte de données et les classes de modèle.
Héritage dans Entity Framework Core
Entity Framework Core (EF Core) vous permet de mapper une hiérarchie de classes .NET à une base de données. Par conséquent, vous pouvez créer vos entités .NET représentées en tant que types de base et dérivés, et EF Core peut générer le schéma de base de données pour vous. Cependant, comme EF Core ne recherche pas automatiquement les classes de base ou dérivées, vous devez explicitement déclarer un type CLR sur votre modèle si vous souhaitez qu'il soit mappé. Il convient de noter que spécifier uniquement le type de base ne suffira pas, c'est-à-dire qu'il ne forcera pas automatiquement EF Core à inclure tous les sous-types.
La liste de code suivante illustre comment vous pouvez créer un contexte de données personnalisé pour une classe ainsi que sa sous-classe.
public class DemoDbContext : DbContext {
public DbSet<Person> Person { get; set; }
public DbSet<Author> Authors { get; set; }
}
public class Person {
public int PersonId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
}
public class Author : Person {
public string SubjectArea { get; set; }
}Table par hiérarchie (TPH)
Dans le type d'héritage Table Per Hierarchy (TPH) (il s'agit du type d'héritage par défaut dans EF Core), vous n'auriez qu'une seule table pour toute la hiérarchie afin de représenter toutes les classes. Pour différencier les différents types, une colonne « discriminateur » est utilisée. Par défaut, la table porte le nom de la classe de base ou d'un champ DbSet lié à celle-ci. Le nom de la table serait le nom de la classe de base ou son attribut DbSet correspondant par défaut.
L'extrait de code suivant illustre comment la table par hiérarchie peut être représentée :
public abstract class Person {
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
}
public class User : Person {
public string UserName { get; set; }
public string Password { get; set; }
}
public class Manager : Person {
public string Department { get; set; }
}Tableau par type (TPT)
Les relations d'héritage de l'approche table par type (TPT) sont représentées sous forme de clés étrangères. Dans cette approche, une table séparée représente chaque type (y compris les types abstraits) de la chaîne d'héritage. Les clés étrangères sont utilisées pour lier des tables qui représentent des types de types dérivés avec leur type de base. Dans cette stratégie, EF Core crée une table de base dans la base de données et plusieurs tables spécifiques à chaque type dérivé.
La liste de code suivante montre comment l'approche Table Per Type (TPT) peut être implémentée :
public abstract class Person {
public int Id { get; set; }
public string FullName { get; set; }
}
[Table("Users")]
public class User : Person {
public string UserName { get; set; }
public string Password { get; set; }
}
[Table("Managers")]
public class Manager : Person {
public string Department { get; set; }
}Tableau par type de béton (TPC)
Dans l'approche Table Per Concrete Type (TPC), chaque type concret de la chaîne d'héritage est représenté par une table distincte dans la base de données mais pas par la classe abstraite. Les propriétés de tout type de base abstrait sont créées sous forme de champs dans la table de chaque type concret.
La conception de la classe sera la même que celle du TPH. Voici comment spécifier une table pour chacune des sous-classes :
public class MyDbContext : DbContext {
public DbSet<Person> Person { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder) {
modelBuilder.Entity<User>().Map(m => {
m.MapInheritedProperties();
m.ToTable("Users");
});
modelBuilder.Entity<Author>().Map(m => {
m.MapInheritedProperties();
m.ToTable("Managers");
});
}
}Résumé
Entity Framework Core peut être exécuté sur n'importe quelle plate-forme prenant en charge .NET Standard 2.1. Cela inclut .NET Core 3.1 ainsi que .NET 5. Cependant, il ne s'exécutera pas sur .NET Standard 2.0, ce qui implique qu'à partir d'EF Core 5.0, vous ne pourrez pas exploiter EF Core avec .NET Framework. Bonne lecture !
