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>
I OnModelCreating metoden definierar jag sambanden mellan tabellerna. Jag har använt Fluent API för att definiera förhållandet mellan tabellerna. Detta är lite mer verbose än att använda Data Annotations men jag tycker att det är mer läsbart.

Du kan se att jag satte upp ett par index på bloggpost tabellen. Detta är för att hjälpa till med prestanda när du frågar i databasen; du bör välja index baserat på hur du kommer att fråga data. I det här fallet är hash, snigel, publicerat datum och språk alla fält jag kommer att fråga på.

### Ställ in

Nu har vi våra modeller och DbContext som vi behöver för att koppla in den i DB. Min vanliga praxis är att lägga till förlängningsmetoder, detta bidrar till att hålla allt mer organiserat:

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

Här sätter jag upp databasanslutningen och kör sedan migreringar. Jag kallar också en metod för att fylla databasen (i mitt fall använder jag fortfarande den filbaserade metoden så jag måste fylla databasen med befintliga inlägg).

Din anslutningssträng kommer att se ut ungefär så här:

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

Genom att använda förlängningen tillvägagångssätt innebär att min Program.cs-fil är trevlig och ren:

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

//Then later in the app section

await app.InitializeDatabase();

Nedanstående avsnitt ansvarar för att hantera migreringen och faktiskt upprätta databasen. I detta sammanhang är det viktigt att se till att MigrateAsync metoden kommer att skapa databasen om den inte finns och köra några migreringar som behövs. Detta är ett bra sätt att hålla din databas i synk med dina modeller.

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

Flyttningar

När du har allt detta som du behöver för att skapa din första migration. Detta är en ögonblicksbild av det aktuella tillståndet för dina modeller och kommer att användas för att skapa databasen. Du kan göra detta med hjälp av dotnet CLI (se här För detaljer om installation av verktyget dotnet ef vid behov:

dotnet ef migrations add InitialCreate

Detta skapar en mapp i ditt projekt med migreringsfilerna. Du kan sedan tillämpa migreringen till databasen med hjälp av:

dotnet ef database update

Detta kommer att skapa databasen och tabeller för dig.