Configurer la BD
Notions théoriques
Qu'est-ce qu'Entity Framework Core ?
Entity Framework Core (EF Core) est l'ORM (Object-Relational Mapper) officiel de Microsoft pour .NET. Il permet de manipuler une base de données MySQL (ou PostgreSQL, SQL Server...) en écrivant du C# pur, sans écrire de SQL à la main.
| Framework | ORM | Base de données |
|---|---|---|
| ASP.NET Core | Entity Framework Core | MySQL, SQL Server, PostgreSQL... |
| Symfony | Doctrine | MySQL, PostgreSQL... |
| Spring Boot | JPA / Hibernate | MySQL, PostgreSQL... |
EF Core joue le même rôle que Doctrine (PHP) ou JPA/Hibernate (Java).
Installer les packages NuGet
Pour utiliser EF Core avec MySQL, deux packages sont nécessaires :
# ORM EF Core + provider MySQL (Pomelo)
dotnet add package Pomelo.EntityFrameworkCore.MySql
dotnet add package Microsoft.EntityFrameworkCore.Tools
Pomelo.EntityFrameworkCore.MySql : driver MySQL compatible EF Core (open source, très utilisé). Microsoft ne fournit pas de driver MySQL officiel pour EF Core.
Microsoft.EntityFrameworkCore.Tools : outils CLI pour les migrations (dotnet ef migrations add, dotnet ef database update).
Il faut aussi installer l'outil global dotnet ef si ce n'est pas déjà fait :
dotnet tool install --global dotnet-ef
Le DbContext
DbContext est la classe centrale d'EF Core. Elle représente la connexion à la base de données et expose des collections d'entités (DbSet<T>) que vous interrogez comme des listes C# :
// Data/MonBlogContext.cs
using Microsoft.EntityFrameworkCore;
using MonBlog.Models;
public class MonBlogContext : DbContext
{
// Injection du DbContextOptions via le constructeur
public MonBlogContext(DbContextOptions<MonBlogContext> options)
: base(options)
{
}
// Chaque DbSet<T> correspond à une table en base de données
public DbSet<Article> Articles { get; set; }
public DbSet<Utilisateur> Utilisateurs { get; set; }
// Configuration optionnelle des mappings
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
// Configurations avancées : index, relations, contraintes...
}
}
// Doctrine (Symfony) : EntityManager
$em = $this->getDoctrine()->getManager();
$articles = $em->getRepository(Article::class)->findAll();
// JPA (Spring Boot) : EntityManager ou Repository
@Autowired ArticleRepository articleRepository;
List<Article> articles = articleRepository.findAll();
// EF Core (ASP.NET Core) : DbContext
_context.Articles.ToList();
La chaîne de connexion
La chaîne de connexion MySQL est stockée dans appsettings.json :
{
"ConnectionStrings": {
"DefaultConnection": "Server=localhost;Database=monblog;User=root;Password=secret;CharSet=utf8mb4;"
}
}
Et dans appsettings.Development.json (ignoré par Git — secrets locaux) :
{
"ConnectionStrings": {
"DefaultConnection": "Server=localhost;Database=monblog_dev;User=root;Password=motdepasse_local;"
}
}
Enregistrer le DbContext dans Program.cs
// Program.cs
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
// Lire la chaîne de connexion depuis appsettings.json
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
// Enregistrer MonBlogContext comme service injectable
builder.Services.AddDbContext<MonBlogContext>(options =>
options.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString))
);
builder.Services.AddControllersWithViews();
// ...
ServerVersion.AutoDetect() détecte automatiquement la version de MySQL. Vous pouvez aussi le spécifier : new MySqlServerVersion(new Version(8, 0, 36)).
Exemple pratique
Configuration complète d'EF Core avec MySQL pour MonBlog :
// Data/MonBlogContext.cs
using Microsoft.EntityFrameworkCore;
using MonBlog.Models;
namespace MonBlog.Data
{
public class MonBlogContext : DbContext
{
public MonBlogContext(DbContextOptions<MonBlogContext> options)
: base(options)
{
}
public DbSet<Article> Articles { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
// Configuration du nom de table explicite
modelBuilder.Entity<Article>().ToTable("articles");
}
}
}
// appsettings.Development.json (ignoré par Git)
{
"ConnectionStrings": {
"DefaultConnection": "Server=localhost;Database=monblog;User=root;Password=root;CharSet=utf8mb4;"
}
}
// Program.cs — enregistrement du contexte
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection")
?? throw new InvalidOperationException("Chaîne de connexion 'DefaultConnection' introuvable.");
builder.Services.AddDbContext<MonBlogContext>(options =>
options.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString))
);
Si la base de données monblog n'existe pas encore, EF Core la créera automatiquement lors de la première migration.
Test de mémorisation/compréhension
TP pour réfléchir et résoudre des problèmes
Vous allez configurer Entity Framework Core avec MySQL pour le projet MonBlog.
Étape 1 — Installer les packages NuGet
Après l'installation, vérifiez que la version de Pomelo.EntityFrameworkCore.MySql est compatible avec votre version d'EF Core et de .NET. En cas de conflit de version, des erreurs cryptiques peuvent apparaître au build.
Étape 2 — Créer le fichier Data/MonBlogContext.cs
Placez le DbContext dans un dossier Data/ (ou Infrastructure/), pas dans Models/. Cette séparation respecte le principe de séparation des responsabilités : Models/ pour les entités, Data/ pour l'accès aux données.
Étape 3 — Enregistrer le DbContext dans Program.cs
Ajoutez une vérification de la chaîne de connexion au démarrage pour éviter un message d'erreur cryptique en production :
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection")
?? throw new InvalidOperationException("Chaîne de connexion introuvable.");