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 der Methode OnModelCreating definiere ich die Beziehungen zwischen den Tabellen. Ich habe die Fluent API benutzt, um die Beziehungen zwischen den Tabellen zu definieren. Dies ist ein bisschen wörtlicher als die Verwendung von Data Annotations, aber ich finde es lesbarer.

Sie können sehen, dass ich ein paar Indexe auf der BlogPost Tabelle eingerichtet. Dies soll bei der Abfrage der Datenbank helfen; Sie sollten die Indizes entsprechend der Art und Weise auswählen, wie Sie die Daten abfragen. In diesem Fall sind Hash, Schnecke, veröffentlichtes Datum und Sprache alle Felder, an denen ich nachfragen werde.

### Einrichtung

Jetzt haben wir unsere Modelle und DbContext eingerichtet, die wir in die DB einbinden müssen. Meine übliche Praxis ist es, Erweiterungsmethoden hinzuzufügen, dies hilft, alles mehr organisiert zu halten:

```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 habe ich die Datenbankverbindung eingerichtet und dann die Migrationen gestartet. Ich rufe auch eine Methode auf, um die Datenbank zu bevölkern (in meinem Fall verwende ich immer noch den dateibasierten Ansatz, so dass ich die Datenbank mit den vorhandenen Beiträgen bevölkern muss).

Deine Verbindungskette wird so ähnlich aussehen:

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

Mit der Erweiterung Ansatz bedeutet, dass meine Program.cs-Datei ist schön und sauber:

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

//Then later in the app section

await app.InitializeDatabase();

Der folgende Abschnitt ist für die Durchführung der Migration und die Einrichtung der Datenbank verantwortlich. Das MigrateAsync Die Methode erstellt die Datenbank, wenn sie nicht existiert und führt alle erforderlichen Migrationen aus. Dies ist eine großartige Möglichkeit, Ihre Datenbank mit Ihren Modellen synchron zu halten.

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

Wanderungsbewegungen

Sobald Sie all dies eingerichtet haben, müssen Sie Ihre erste Migration erstellen. Dies ist eine Momentaufnahme des aktuellen Zustands Ihrer Modelle und wird verwendet, um die Datenbank zu erstellen. Sie können dies mit dem dotnet CLI (siehe Hierher Einzelheiten zur Installation des dotnet ef-Tools bei Bedarf):

dotnet ef migrations add InitialCreate

Dadurch wird ein Ordner in Ihrem Projekt mit den Migrationsdateien erstellt. Anschließend können Sie die Migration auf die Datenbank anwenden:

dotnet ef database update

Dadurch werden die Datenbank und Tabellen für Sie erstellt.