Nycklar

En nyckel fungerar som en unik identifierare för varje entitetsinstans. De flesta entiteter i EF har en enda nyckel som mappar till begreppet primärnyckel i relationsdatabaser (för entiteter utan nycklar, se Nyckellösa entiteter). Entiteter kan ha ytterligare nycklar utöver den primära nyckeln (se Alternativa nycklar för mer information).

Konfigurering av en primärnyckel

Enligt konventionen konfigureras en egenskap med namnet Id eller <type name>Id som primärnyckel för en entitet.

internal class Car
{
    public string Id { get; set; }

    public string Make { get; set; }
    public string Model { get; set; }
}

internal class Truck
{
    public string TruckId { get; set; }

    public string Make { get; set; }
    public string Model { get; set; }
}

Du kan konfigurera en enskild egenskap som primärnyckel för en entitet på följande sätt:

internal class Car
{
    [Key]
    public string LicensePlate { get; set; }

    public string Make { get; set; }
    public string Model { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Car>()
        .HasKey(c => c.LicensePlate);
}

Du kan också konfigurera flera egenskaper för att vara nyckeln för en entitet – detta kallas för en sammansatt nyckel. Konventioner konfigurerar endast en sammansatt nyckel i specifika fall , till exempel för en samling av ägd typ.

[PrimaryKey(nameof(State), nameof(LicensePlate))]
internal class Car
{
    public string State { get; set; }
    public string LicensePlate { get; set; }

    public string Make { get; set; }
    public string Model { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Car>()
        .HasKey(c => new { c.State, c.LicensePlate });
}

Värdegenerering

För icke-sammansatta numeriska nycklar och GUID-primärnycklar konfigurerar EF Core värdegenerering för dig enligt konvention. Till exempel konfigureras en numerisk primärnyckel i SQL Server automatiskt som en identitetskolumn. Mer information finns i dokumentationen om värdegenerering och vägledning för specifika strategier för arvsmappning.

Primärnyckelnamn

Enligt konventionen skapas primära nycklar för relationsdatabaser med namnet PK_<type name>. Du kan konfigurera namnet på den primära nyckelbegränsningen på följande sätt:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasKey(b => b.BlogId)
        .HasName("PrimaryKey_BlogId");
}

Nyckeltyper och värden

Även om EF Core stöder användning av egenskaper av valfri primitiv typ som primärnyckel, inklusive string, Guidbyte[] och andra, stöder inte alla databaser alla typer som nycklar. I vissa fall kan nyckelvärdena konverteras till en typ som stöds automatiskt, annars bör konverteringen anges manuellt.

Nyckelegenskaper måste alltid ha ett icke-standardvärde när du lägger till en ny entitet i kontexten, men vissa typer genereras av databasen. I så fall försöker EF generera ett tillfälligt värde när entiteten läggs till i spårningssyfte. När SaveChanges har anropats ersätts det tillfälliga värdet av det värde som genereras av databasen.

Alternativa nycklar

En alternativ nyckel fungerar som en alternativ unik identifierare för varje entitetsinstans utöver den primära nyckeln. den kan användas som mål för en relation. När du använder en relationsdatabas mappar detta till begreppet unikt index/villkoret för de alternativa nyckelkolumnerna och en eller flera begränsningar för främmande nycklar som refererar till kolumnerna.

Alternativa nycklar introduceras vanligtvis för dig när det behövs och du behöver inte konfigurera dem manuellt. Enligt konventionen introduceras en alternativ nyckel för dig när du identifierar en egenskap som inte är den primära nyckeln som mål för en relation.

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .HasForeignKey(p => p.BlogUrl)
            .HasPrincipalKey(b => b.Url);
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public string BlogUrl { get; set; }
    public Blog Blog { get; set; }
}

Du kan också konfigurera en enskild egenskap som en alternativ nyckel:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Car>()
        .HasAlternateKey(c => c.LicensePlate);
}

Du kan också konfigurera flera egenskaper som en alternativ nyckel (kallas för en sammansatt alternativ nyckel):

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Car>()
        .HasAlternateKey(c => new { c.State, c.LicensePlate });
}

Slutligen namnges AK_<type name>_<property name> indexet och begränsningen som introduceras för en alternativ nyckel (för sammansatta alternativa nycklar <property name> blir en understrecksavgränsad lista över egenskapsnamn). Du kan konfigurera namnet på den alternativa nyckelns index och unika villkor:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Car>()
        .HasAlternateKey(c => c.LicensePlate)
        .HasName("AlternateKey_LicensePlate");
}