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>
In de OnModelCreating methode definieer ik de relaties tussen de tabellen. Ik heb de Fluent API gebruikt om de relaties tussen de tabellen te definiëren. Dit is een beetje meer werkboos dan het gebruik van Data Annotaties, maar ik vind het leesbaarder.

U kunt zien dat ik een paar Indexen op de BlogPost tafel. Dit is om te helpen met de prestaties bij het opvragen van de database; u moet de indexen selecteren op basis van hoe u de gegevens zult opvragen. In dit geval hash, slak, gepubliceerde datum en taal zijn alle gebieden die ik zal opzoeken.

### Instellen

Nu hebben we onze modellen en DbContext opgezet moeten we het aansluiten op de DB. Mijn gebruikelijke praktijk is om uitbreidingsmethoden toe te voegen, dit helpt om alles meer georganiseerd te houden:

```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");
        }        
    }
}

Hier heb ik de database verbinding opgezet en vervolgens de migraties uitgevoerd. Ik bel ook een methode om de database te bevolken (in mijn geval gebruik ik nog steeds de file based aanpak, dus ik moet de database te bevolken met de bestaande berichten).

Uw verbinding string zal er ongeveer zo uitzien:

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

Met behulp van de extensie aanpak betekent dat mijn Program.cs bestand is mooi en schoon:

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

//Then later in the app section

await app.InitializeDatabase();

De onderstaande sectie is verantwoordelijk voor het beheren van de migratie en het daadwerkelijk opzetten van de database. De MigrateAsync methode zal de database te maken als het niet bestaat en uitvoeren van alle migraties die nodig zijn. Dit is een geweldige manier om uw database te synchroniseren met uw modellen.

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

Migratie

Zodra je dit alles hebt ingesteld, moet je je eerste migratie maken. Dit is een momentopname van de huidige staat van uw modellen en zal worden gebruikt om de database te maken. U kunt dit doen met behulp van de dotnet CLI (zie Hier. voor details over de installatie van de dotnet ef tool indien nodig:

dotnet ef migrations add InitialCreate

Dit maakt een map aan in uw project met de migratiebestanden. U kunt de migratie vervolgens toepassen op de database met behulp van:

dotnet ef database update

Dit zal de database en tabellen voor u maken.