EF Core : la base de données

// 1. Les entités : des classes ordinaires
public class Blog
{
    public int Id { get; set; }                        // clé primaire par convention
    public required string Nom { get; set; }
    public List<Billet> Billets { get; set; } = [];    // relation un-à-plusieurs
}

public class Billet
{
    public int Id { get; set; }
    public required string Titre { get; set; }
    public DateTime Publie { get; set; }
    public int BlogId { get; set; }                    // clé étrangère
    public Blog? Blog { get; set; }                    // navigation inverse
}

// 2. Le contexte : ta session de travail avec la base
public class AppDb(DbContextOptions<AppDb> options) : DbContext(options)
{
    public DbSet<Blog> Blogs => Set<Blog>();
    public DbSet<Billet> Billets => Set<Billet>();

    protected override void OnModelCreating(ModelBuilder mb)
    {
        mb.Entity<Blog>().Property(b => b.Nom).HasMaxLength(200).IsRequired();
        mb.Entity<Billet>().HasIndex(b => b.Publie);
    }
}

// 3. L'enregistrement (Program.cs)
builder.Services.AddDbContext<AppDb>(o =>
    o.UseSqlServer(builder.Configuration.GetConnectionString("Defaut")));

# Installation de l'outil, une fois par machine
dotnet tool install --global dotnet-ef

# Cycle de travail habituel
dotnet ef migrations add AjoutTableBillets     # génère le code de migration (à relire !)
dotnet ef database update                      # applique à la base
dotnet ef migrations list                      # état des migrations
dotnet ef migrations remove                    # annule la DERNIÈRE, si non appliquée

# Production : ne jamais lancer « database update » depuis un poste de développement
dotnet ef migrations script --idempotent -o migration.sql   # script relisable et validable
dotnet ef migrations bundle                                  # exécutable autonome pour la CI/CD

public partial class AjoutReference : Migration
{
    protected override void Up(MigrationBuilder mb)
    {
        mb.AddColumn<string>("Reference", "Produits", maxLength: 20, nullable: true);

        // Ajouté à la main : remplir l'existant AVANT de rendre la colonne obligatoire
        mb.Sql("UPDATE Produits SET Reference = 'LEGACY-' + CAST(Id AS nvarchar(10))");
        mb.AlterColumn<string>("Reference", "Produits", maxLength: 20, nullable: false);

        mb.CreateIndex("IX_Produits_Reference", "Produits", "Reference", unique: true);
    }

    protected override void Down(MigrationBuilder mb)      // le retour arrière doit fonctionner
        => mb.DropColumn("Reference", "Produits");
}

// Lecture seule : AsNoTracking évite de construire le suivi des modifications (~30 % plus rapide)
var billets = await db.Billets
    .AsNoTracking()
    .Where(b => b.Publie > DateTime.UtcNow.AddDays(-7))
    .OrderByDescending(b => b.Publie)
    .Select(b => new BilletDto(b.Id, b.Titre, b.Blog!.Nom))   // projection : seules 3 colonnes lues
    .Take(20)
    .ToListAsync(ct);

// Une entité par sa clé (utilise le cache du contexte s'il l'a déjà chargée)
var blog = await db.Blogs.FindAsync([id], ct);

// Charger les données liées explicitement
var avecBillets = await db.Blogs
    .Include(b => b.Billets.OrderByDescending(p => p.Publie).Take(5))   // filtre dans l'Include
        .ThenInclude(p => p.Etiquettes)
    .FirstOrDefaultAsync(b => b.Id == id, ct);

// Voir le SQL généré (précieux en débogage)
var sql = db.Billets.Where(b => b.BlogId == 1).ToQueryString();

builder.Services.AddDbContext<AppDb>(o => o
    .UseSqlServer(chaine)
    .LogTo(Console.WriteLine, LogLevel.Information)   // affiche chaque requête SQL
    .EnableSensitiveDataLogging()                     // avec les paramètres — JAMAIS en production
    .EnableDetailedErrors());

// Si la console affiche 200 SELECT identiques pour un seul appel HTTP : N+1 trouvé.

// Un blog, 100 billets, 50 abonnés → 100 × 50 = 5 000 lignes ramenées pour 151 objets
var blog = await db.Blogs
    .Include(b => b.Billets)
    .Include(b => b.Abonnes)
    .FirstAsync(b => b.Id == id);

// Solution : plusieurs requêtes, une par collection
var blog = await db.Blogs
    .Include(b => b.Billets)
    .Include(b => b.Abonnes)
    .AsSplitQuery()                 // ← 3 requêtes simples au lieu d'une monstrueuse
    .FirstAsync(b => b.Id == id);

// Le contexte photographie l'état initial, puis calcule la différence à l'enregistrement
var billet = await db.Billets.FirstAsync(b => b.Id == 42, ct);
billet.Titre = "Nouveau titre";                  // aucune requête ici
await db.SaveChangesAsync(ct);                   // → UPDATE Billets SET Titre=… WHERE Id=42

// Créer
db.Billets.Add(new Billet { Titre = "Bonjour", BlogId = 1 });

// Supprimer
db.Billets.Remove(billet);

// Un SEUL SaveChanges pour tout : c'est une transaction implicite (tout ou rien)
await db.SaveChangesAsync(ct);

// ❌ charge 50 000 entités en mémoire pour les modifier une par une
foreach (var p in await db.Produits.Where(p => p.Categorie == "solde").ToListAsync())
    p.Prix *= 0.8m;
await db.SaveChangesAsync();

// ✅ un seul UPDATE côté serveur, rien en mémoire
await db.Produits
    .Where(p => p.Categorie == "solde")
    .ExecuteUpdateAsync(s => s.SetProperty(p => p.Prix, p => p.Prix * 0.8m), ct);

await db.Sessions.Where(s => s.Expiration < DateTime.UtcNow).ExecuteDeleteAsync(ct);

public class Produit
{
    public int Id { get; set; }
    public decimal Prix { get; set; }

    [Timestamp]                       // colonne rowversion gérée par la base
    public byte[]? Version { get; set; }
}

try
{
    produit.Prix = 42m;
    await db.SaveChangesAsync(ct);
}
catch (DbUpdateConcurrencyException ex)
{
    // Quelqu'un a modifié la ligne entre ta lecture et ton écriture
    var actuel = await ex.Entries.Single().GetDatabaseValuesAsync(ct);
    return Results.Conflict(new { message = "Modifié entre-temps", valeurActuelle = actuel });
}

protected override void OnModelCreating(ModelBuilder mb)
{
    // EF 10 : filtres NOMMÉS, donc désactivables individuellement
    mb.Entity<Billet>()
      .HasQueryFilter("SuppressionLogique", b => !b.EstSupprime)
      .HasQueryFilter("Locataire", b => b.LocataireId == _contexte.LocataireId);
}

// Toutes les requêtes sont filtrées automatiquement…
var billets = await db.Billets.ToListAsync();       // WHERE EstSupprime = 0 AND LocataireId = @id

// …et on peut lever un seul filtre quand c'est légitime (page d'administration)
var corbeille = await db.Billets
    .IgnoreQueryFilters(["SuppressionLogique"])
    .Where(b => b.EstSupprime)
    .ToListAsync();