public DbSet<Comments> Comments { get; set; }
public DbSet<BlogPost> BlogPosts { get; set; }
public DbSet<Category> Categories { get; set; }

public DbSet<Language> Languages { get; set; }


protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
    configurationBuilder
        .Properties<DateTimeOffset>()
        .HaveConversion<DateTimeOffsetConverter>();
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<BlogPost>(entity =>
    {
        entity.HasIndex(x => new { x.Slug, x.LanguageId });
        entity.HasIndex(x => x.ContentHash).IsUnique();
        entity.HasIndex(x => x.PublishedDate);

        entity.HasMany(b => b.Comments)
            .WithOne(c => c.BlogPost)
            .HasForeignKey(c => c.BlogPostId);

        entity.HasOne(b => b.Language)
            .WithMany(l => l.BlogPosts).HasForeignKey(x => x.LanguageId);

        entity.HasMany(b => b.Categories)
            .WithMany(c => c.BlogPosts)
            .UsingEntity<Dictionary<string, object>>(
                "BlogPostCategory",
                c => c.HasOne<Category>().WithMany().HasForeignKey("CategoryId"),
                b => b.HasOne<BlogPost>().WithMany().HasForeignKey("BlogPostId")
            );
    });

    modelBuilder.Entity<Language>(entity =>
    {
        entity.HasMany(l => l.BlogPosts)
            .WithOne(b => b.Language);
    });

    modelBuilder.Entity<Category>(entity =>
    {
        entity.HasKey(c => c.Id); // Assuming Category has a primary key named Id

        entity.HasMany(c => c.BlogPosts)
            .WithMany(b => b.Categories)
            .UsingEntity<Dictionary<string, object>>(
                "BlogPostCategory",
                b => b.HasOne<BlogPost>().WithMany().HasForeignKey("BlogPostId"),
                c => c.HasOne<Category>().WithMany().HasForeignKey("CategoryId")
            );
    });
}

}

</details>
Dans la méthode OnModelCreating, je définit les relations entre les tables. J'ai utilisé l'API Fluent pour définir les relations entre les tables. C'est un peu plus verbeux que l'utilisation des annotations de données, mais je le trouve plus lisible.

Vous pouvez voir que j'ai mis en place quelques index sur la table BlogPost. Ceci est pour aider avec les performances lors de la requête de la base de données; vous devez sélectionner les Indices en fonction de la façon dont vous allez interroger les données. Dans ce cas, le hash, le slug, la date et la langue publiées sont tous des champs sur lesquels je vais poser des questions.

### Configuration

Maintenant, nous avons nos modèles et DbContext mis en place nous devons l'accrocher à la DB. Ma pratique habituelle est d'ajouter des méthodes d'extension, ce qui permet de garder tout plus organisé:

```csharp
public static class Setup
{
    public static void SetupEntityFramework(this IServiceCollection services, string connectionString)
    {
        services.AddDbContext<MostlylucidDbContext>(options =>
            options.UseNpgsql(connectionString));
    }

    public static async Task InitializeDatabase(this WebApplication app)
    {
        try
        {
            await using var scope = 
                app.Services.CreateAsyncScope();
            
            await using var context = scope.ServiceProvider.GetRequiredService<MostlylucidDbContext>();
            await context.Database.MigrateAsync();
            
            var blogService = scope.ServiceProvider.GetRequiredService<IBlogService>();
            await blogService.Populate();
        }
        catch (Exception e)
        {
            Log.Fatal(e, "Failed to migrate database");
        }        
    }
}

Ici, j'ai mis en place la connexion de la base de données, puis j'ai lancé les migrations. J'appelle aussi une méthode pour remplir la base de données (dans mon cas, j'utilise toujours l'approche basée sur les fichiers, donc je dois remplir la base de données avec les messages existants).

Votre chaîne de connexion ressemblera à ceci :

 "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=Mostlylucid;port=5432;Username=postgres;Password=<PASSWORD>;"
  },

L'utilisation de l'approche d'extension signifie que mon fichier Program.cs est agréable et propre :

services.SetupEntityFramework(config.GetConnectionString("DefaultConnection") ??
                              throw new Exception("No Connection String"));

//Then later in the app section

await app.InitializeDatabase();

La section ci-dessous est chargée de gérer la migration et de mettre en place la base de données. Les MigrateAsync méthode créera la base de données si elle n'existe pas et exécutera les migrations qui sont nécessaires. C'est un excellent moyen de maintenir votre base de données en phase avec vos modèles.

     await using var scope = 
                app.Services.CreateAsyncScope();
            
            await using var context = scope.ServiceProvider.GetRequiredService<MostlylucidDbContext>();
            await context.Database.MigrateAsync();

Migrations

Une fois que vous avez tout cela mis en place, vous devez créer votre migration initiale. Il s'agit d'un instantané de l'état actuel de vos modèles et sera utilisé pour créer la base de données. Vous pouvez le faire en utilisant le Dotnet CLI (voir Ici. pour plus de détails sur l'installation de l'outil dotnet ef si nécessaire):

dotnet ef migrations add InitialCreate

Cela créera un dossier dans votre projet avec les fichiers de migration. Vous pouvez ensuite appliquer la migration à la base de données en utilisant :

dotnet ef database update

Cela créera la base de données et les tables pour vous.