Notions de base sur DbContext et DbSet
Configurez un DbContext, définissez des entités, paramétrez la chaîne de connexion et exécutez votre première requête.
Notions de base sur DbContext et DbSet est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.
Qu’est-ce qu’Entity Framework Core ?
EF Core est l’outil officiel de .NET pour le mappage objet-relationnel (ORM). Il associe les classes C#, appelées entités, aux tables de la base de données et vous permet d’interroger et d’enregistrer les données avec LINQ, sans écrire de SQL pour la plupart des opérations.
Définir une entité
Une entité est une simple classe C# dont les propriétés correspondent aux colonnes de la base de données. Par convention, une propriété nommée Id ou <TypeName>Id devient la clé primaire.
public class Product
{
public int Id { get; set; }
public string Name { get; set; } = "";
public decimal Price { get; set; }
public int Stock { get; set; }
public DateTime CreatedAt { get; set; }
}Créer un DbContext
DbContext est la passerelle vers la base de données. Il contient des propriétés DbSet<T> pour chaque entité et gère la connexion, le suivi des modifications et les transactions.
using Microsoft.EntityFrameworkCore;
public class AppDbContext : DbContext
{
public AppDbContext(DbContextOptions<AppDbContext> options)
: base(options) { }
public DbSet<Product> Products => Set<Product>();
public DbSet<Order> Orders => Set<Order>();
}Enregistrer DbContext avec DI
Appelez AddDbContext dans Program.cs pour enregistrer le contexte comme service à durée de vie limitée et configurer le fournisseur de base de données.
builder.Services.AddDbContext<AppDbContext>(options =>
options.UseSqlServer(
builder.Configuration.GetConnectionString("Default")));
// For SQLite (great for development/testing):
// options.UseSqlite("Data Source=app.db");Requêtes de base avec DbSet
DbSet<T> expose les opérateurs LINQ. Les requêtes ne sont exécutées qu’au moment de leur énumération (await ...ToListAsync()). C’est ce qu’on appelle l’exécution différée.
public class ProductService
{
private readonly AppDbContext _db;
public ProductService(AppDbContext db) => _db = db;
public async Task<List<Product>> GetExpensiveAsync(decimal minPrice)
{
return await _db.Products
.Where(p => p.Price >= minPrice)
.OrderBy(p => p.Name)
.ToListAsync();
}
}Recherche par clé primaire
FindAsync vérifie d’abord le cache local du suivi des modifications avant d’interroger la base de données. Utilisez-le pour effectuer une requête par clé primaire et éviter les allers-retours redondants.
var product = await _db.Products.FindAsync(42);
if (product is null)
throw new KeyNotFoundException("Product not found");
// For complex keys, pass all key values:
var orderLine = await _db.OrderLines.FindAsync(orderId, productId);Ajout de nouveaux enregistrements
Appelez Add pour mettre une entité en attente d’insertion, puis appelez SaveChangesAsync pour valider. EF Core génère le code SQL INSERT et renseigne l’Id généré automatiquement.
var product = new Product
{
Name = "Mechanical Keyboard",
Price = 149.99m,
Stock = 50,
CreatedAt = DateTime.UtcNow
};
_db.Products.Add(product);
await _db.SaveChangesAsync();
Console.WriteLine(product.Id); // Auto-generated PKMise à jour des enregistrements
Les entités chargées par EF Core font l’objet d’un suivi. Modifiez directement leurs propriétés et appelez SaveChangesAsync — EF Core détecte les changements et génère une instruction UPDATE optimisée.
var product = await _db.Products.FindAsync(42);
if (product is not null)
{
product.Price = 129.99m;
product.Stock -= 1;
await _db.SaveChangesAsync(); // UPDATE Products SET Price=...
}Suppression des enregistrements
Appelez Remove pour marquer une entité en vue de sa suppression, puis appelez SaveChangesAsync. Utilisez ExecuteDeleteAsync (.NET 7+) pour effectuer des suppressions en masse sans charger les entités.
// Delete a tracked entity
_db.Products.Remove(product);
await _db.SaveChangesAsync();
// Bulk delete without loading (EF Core 7+)
await _db.Products
.Where(p => p.Stock == 0)
.ExecuteDeleteAsync();Configuration avec l’API Fluent
Remplacez OnModelCreating pour configurer les entités à l’aide de l’API Fluent : noms des tables, types de colonnes, contraintes, index et relations.
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Product>(entity =>
{
entity.ToTable("products");
entity.Property(p => p.Name).IsRequired().HasMaxLength(200);
entity.Property(p => p.Price).HasColumnType("decimal(18,2)");
entity.HasIndex(p => p.Name);
});
}Cas concret : référentiel utilisant DbContext
Un référentiel classique encapsule DbContext afin de centraliser la logique d’accès aux données et de garder les détails des requêtes hors des classes de service.
public class ProductRepository : IProductRepository
{
private readonly AppDbContext _db;
public ProductRepository(AppDbContext db) => _db = db;
public async Task<Product?> GetByIdAsync(int id)
=> await _db.Products.AsNoTracking().FirstOrDefaultAsync(p => p.Id == id);
public async Task<List<Product>> SearchAsync(string query)
=> await _db.Products
.Where(p => p.Name.Contains(query))
.AsNoTracking()
.ToListAsync();
}Vérification rapide
Que fait AsNoTracking() lors d’une requête avec EF Core ?
Récapitulatif : notions de base sur DbContext et DbSet
Points essentiels :
- DbContext représente la session avec la base de données ; DbSet<T> représente une table
- Enregistrez-le avec
AddDbContextdans DI ; sa durée de vie est limitée par défaut - Les requêtes LINQ sont différées : exécutez-les avec
ToListAsyncouFirstOrDefaultAsync - Le suivi des modifications permet d’effectuer automatiquement UPDATE/DELETE via SaveChangesAsync
- Utilisez
AsNoTracking()pour les requêtes en lecture seule afin d’améliorer les performances
Questions Fréquemment Posées
La leçon « Notions de base sur DbContext et DbSet » est-elle gratuite ?
Oui — le texte complet de « Notions de base sur DbContext et DbSet » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Notions de base sur DbContext et DbSet » ?
Configurez un DbContext, définissez des entités, paramétrez la chaîne de connexion et exécutez votre première requête. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Notions de base sur DbContext et DbSet » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Notions de base sur DbContext et DbSet
- Migrations et gestion du schéma
- Opérations CRUD avec EF Core
- Relations : un-à-plusieurs et plusieurs-à-plusieurs