Megosztás:

Kulcsok

A kulcsok egyedi azonosítóként szolgálnak az egyes entitáspéldányokhoz. Az EF legtöbb entitása egyetlen kulccsal rendelkezik, amely megfelel a relációs adatbázisokban az elsődleges kulcs fogalmának (kulcs nélküli entitások esetén lásd: Kulcs nélküli entitások). Az entitások az elsődleges kulcson kívül további kulcsokkal is rendelkezhetnek (további információt az Alternatív kulcsok című témakörben talál).

Elsődleges kulcs konfigurálása

Konvenció szerint egy Id vagy <type name>Id nevű tulajdonság lesz konfigurálva egy entitás elsődleges kulcsaként.

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

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

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

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

Megjegyzés:

A tulajdonos entitástípusok különböző szabályokat használnak a kulcsok definiálásához.

Egyetlen tulajdonságot konfigurálhat úgy, hogy az entitás elsődleges kulcsa legyen az alábbiak szerint:

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

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

Több tulajdonságot is konfigurálhat úgy, hogy egy entitás kulcsa legyen – ezt összetett kulcsnak nevezzük. A konvenciók csak bizonyos esetekben állíthatnak be összetett kulcsot – például egy saját típusú gyűjteményhez.

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

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

Értékgenerálás

Nem összetett numerikus és GUID elsődleges kulcsok esetén az EF Core konvenció szerint állítja be az értékgenerálást. Az SQL Server egyik numerikus elsődleges kulcsa például automatikusan identitásoszlopként van beállítva. További információkért tekintse meg az értékgenerálás dokumentációját és az egyes öröklési leképezési stratégiákra vonatkozó útmutatást.

Elsődleges kulcs neve

Konvenció szerint a relációs adatbázisokban az elsődleges kulcsok a névvel PK_<type name>jönnek létre. Az elsődleges kulcskényszer nevét az alábbiak szerint konfigurálhatja:

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

Kulcstípusok és értékek

Bár az EF Core támogatja a primitív típusú tulajdonságok elsődleges kulcsként való használatát, beleértve a string, Guidbyte[] és másokat is, nem minden adatbázis támogatja az összes típust kulcsként. Bizonyos esetekben a kulcsértékek automatikusan konvertálhatók támogatott típussá, ellenkező esetben a konvertálást manuálisan kell megadni.

A kulcstulajdonságoknak mindig nem alapértelmezett értékkel kell rendelkezniük, amikor új entitást ad hozzá a környezethez, de az adatbázis létrehoz néhány típust. Ebben az esetben az EF megpróbál létrehozni egy ideiglenes értéket, amikor az entitást nyomkövetési célokra hozzáadják. A SaveChanges neve után az ideiglenes érték helyébe az adatbázis által létrehozott érték lép.

Fontos

Ha egy kulcstulajdonság értékét az adatbázis hozza létre, és egy entitás hozzáadásakor nem alapértelmezett érték van megadva, akkor az EF feltételezi, hogy az entitás már létezik az adatbázisban, és megpróbálja frissíteni az új beszúrása helyett. Ennek elkerülése érdekében kapcsolja ki az értékgenerálást, vagy tekintse meg , hogyan adhat meg explicit értékeket a létrehozott tulajdonságokhoz.

Alternatív kulcsok

A másodlagos kulcs alternatív egyedi azonosítóként szolgál az egyes entitáspéldányokhoz az elsődleges kulcson kívül; kapcsolat céljaként használható. Relációs adatbázis használata esetén ez megfelel az alternatív kulcsoszlop(ok) egyedi indexének/kényszerének, valamint az oszlop(ok)ra hivatkozó egy vagy több idegenkulcs-korlátozás fogalmának.

Jótanács

Ha csak egy oszlop egyediségét szeretné kikényszeríteni, adjon meg egy egyedi indexet alternatív kulcs helyett (lásd : Indexek). Az EF-ben a másodlagos kulcsok írásvédettek, és további szemantikát biztosítanak az egyedi indexekhez, mivel idegen kulcs célként használhatók.

A másodlagos kulcsokat általában szükség esetén vezetik be, és nem kell manuálisan konfigurálnia őket. Konvenció szerint egy alternatív kulcs kerül bevezetésre az ön számára, amikor azonosít egy tulajdonságot, amely nem az elsődleges kulcs a kapcsolati viszony céljául szolgál.

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; }
}

Egyetlen tulajdonságot is konfigurálhat másodlagos kulcsként:

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

Több tulajdonságot is konfigurálhat alternatív kulcsként (más néven összetett alternatív kulcsként):

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

Végül konvenció szerint az alternatív kulcshoz bevezetett index és korlátozás neve el lesz nevezve AK_<type name>_<property name> (az összetett alternatív kulcsok <property name> esetében a tulajdonságnevek aláhúzásjelekkel tagolt listája lesz). Konfigurálhatja a másodlagos kulcs indexének nevét és egyedi korlátozását:

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