A kapcsolatok bemutatása

Ez a dokumentum egyszerű bevezetést nyújt az objektummodellekben és a relációs adatbázisokban lévő kapcsolatok ábrázolásához, beleértve azt is, hogy az EF Core hogyan térképezi le a kettőt.

Kapcsolatok objektummodellekben

A kapcsolat meghatározza, hogy két entitás hogyan viszonyul egymáshoz. Ha például egy blog bejegyzéseit modellezi, minden bejegyzés ahhoz a bloghoz kapcsolódik, amelyen közzé van téve, és a blog az adott blogon közzétett összes bejegyzéshez kapcsolódik.

A C#-hez hasonló objektumorientált nyelvben a blogot és a bejegyzést általában két osztály képviseli: Blog és Post. Például:

public class Blog
{
    public string Name { get; set; }
    public virtual Uri SiteUri { get; set; }
}

public class Post
{
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime PublishedOn { get; set; }
    public bool Archived { get; set; }
}

A fenti osztályokban semmi sem utal arra, hogy Blog és Post kapcsolódnak. Ez az objektummodellhez úgy adható hozzá, hogy egy hivatkozást adunk a Post-ról arra a Blog-re, amelyen közzé van téve.

public class Post
{
    public string Title { get; set; }
    public string Content { get; set; }
    public DateOnly PublishedOn { get; set; }
    public bool Archived { get; set; }

    public Blog Blog { get; set; }
}

Hasonlóképpen, ugyanannak a kapcsolatnak az ellenkező iránya minden egyes Blog-en Post objektumok gyűjteményeként jelenhet meg.

public class Blog
{
    public string Name { get; set; }
    public virtual Uri SiteUri { get; set; }

    public ICollection<Post> Posts { get; }
}

Az Blog és Post közötti, valamint az Post és Blog közötti kapcsolat az EF Core-ban "kapcsolatként" ismert.

Kapcsolatok relációs adatbázisokban

A relációs adatbázisok idegen kulcsokat használó kapcsolatokat jelölnek. Az SQL Server vagy az Azure SQL használatával például a következő táblák használhatók a Post és Blog osztályaink megjelenítésére:

CREATE TABLE [Posts] (
    [Id] int NOT NULL IDENTITY,
    [Title] nvarchar(max) NULL,
    [Content] nvarchar(max) NULL,
    [PublishedOn] datetime2 NOT NULL,
    [Archived] bit NOT NULL,
    [BlogId] int NOT NULL,
    CONSTRAINT [PK_Posts] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_Posts_Blogs_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [Blogs] ([Id]) ON DELETE CASCADE);

CREATE TABLE [Blogs] (
    [Id] int NOT NULL IDENTITY,
    [Name] nvarchar(max) NULL,
    [SiteUri] nvarchar(max) NULL,
    CONSTRAINT [PK_Blogs] PRIMARY KEY ([Id]));

Ebben a relációs modellben a Posts és Blogs táblák mindegyike egy "elsődleges kulcs" oszlopot kap. Az elsődleges kulcs értéke egyedileg azonosítja az egyes bejegyzéseket vagy blogokat. Emellett a Posts tábla egy "idegenkulcs" oszlopot is kap. Az Blogs elsődleges kulcs oszlopára Id a Posts tábla BlogId idegenkulcs-oszlopa hivatkozik. Ez az oszlop "korlátozott", így a PostsBlogId oszlopának minden értékének egyeznie kell a BlogsId oszlopában lévő értékkel. Ez a találat határozza meg, hogy melyik bloghoz kapcsolódik minden bejegyzés. Ha például a Posts tábla egyik sorában a BlogId értéke 7, akkor az adott sor által képviselt bejegyzés a blogban lesz közzétéve a 7. elsődleges kulccsal.

Kapcsolatok leképezése az EF Core-ban

Az EF Core-kapcsolatleképezés lényege, hogy a relációs adatbázisban használt elsődleges kulcs-/idegenkulcs-reprezentáció megfeleltethető az objektummodellben használt objektumok közötti hivatkozásoknak.

A legalapvetőbb értelemben ez a következőket foglalja magában:

• Elsődleges kulcstulajdonság hozzáadása minden entitástípushoz.
• Idegenkulcs-tulajdonság hozzáadása egy entitástípushoz.
• Az entitástípusok és az elsődleges és idegen kulcsok közötti hivatkozások társítása egyetlen kapcsolatkonfiguráció létrehozásához.

A leképezést követően az EF szükség szerint módosítja az idegenkulcs-értékeket, amikor az objektumok közötti hivatkozások megváltoznak, és szükség szerint módosítja az objektumok közötti hivatkozásokat, amikor az idegenkulcs-értékek megváltoznak.

A fent látható entitástípusok például frissíthetők elsődleges és idegen kulcstulajdonságokkal:

public class Blog
{
    public int Id { get; set; }
    public string Name { get; set; }
    public virtual Uri SiteUri { get; set; }

    public ICollection<Post> Posts { get; }
}

public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime PublishedOn { get; set; }
    public bool Archived { get; set; }

    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

A Blog, Blog.Idés a Postidegenkulcs-tulajdonságának elsődleges kulcstulajdonsága Post.BlogIdezután társítható az entitástípusok (Blog.Posts és Post.Blog) közötti hivatkozásokhoz ("navigációk"). Ezt az EF automatikusan elvégzi egy ilyen egyszerű kapcsolat létrehozásakor, de explicit módon is megadható a OnModelCreating metódusának felülírásakor a DbContext-ben. Például:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey(e => e.BlogId)
        .HasPrincipalKey(e => e.Id);
}

Most ezek a tulajdonságok egységesen fognak viselkedni, mint a Blog és a Postközötti egyetlen kapcsolat ábrázolása.

További információ

Az EF számos különböző típusú kapcsolatot támogat, és számos különböző módon ábrázolhatja és konfigurálhatja ezeket a kapcsolatokat. A különböző típusú kapcsolatok példáinak megtekintéséhez tekintse meg a következőt:

• egy-a-többhöz típusú kapcsolatok, amelyekben egyetlen entitás tetszőleges számú más entitáshoz van társítva.
• egy-az-egyhez kapcsolatok, amelyekben egyetlen entitás egy másik entitáshoz van társítva.
• több-a-többhöz viszonyok, amelyekben bármennyi entitás társítható bármennyi más entitáshoz.

Ha még nem ismerkedett az EF-sel, akkor a fenti felsoroláspontokban hivatkozott példák kipróbálása jó módszer a kapcsolatok működésének megismerésére.

A kapcsolatleképezésben részt vevő entitástípusok tulajdonságainak mélyebb megismeréséhez lásd:

• kapcsolatokban lévő külső és fő kulcsokat, amelyek azt ismertetik, hogy az idegen kulcsok hogyan képezik le az adatbázist.
• Kapcsolatnavigációk, amelyek azt írják le, hogyan vannak a navigációk egy idegen kulcsra rétegzve, hogy objektumorientált képet nyújtsanak a kapcsolatról.

Az EF-modellek három mechanizmus kombinációjával készülnek: konvenciók, leképezési attribútumok és a modellkészítő API. A legtöbb példa a modellkészítő API-t mutatja be. A többi lehetőséggel kapcsolatos további információkért lásd:

• kapcsolati konvenciók, amelyek felderítik az entitástípusokat, azok tulajdonságait és a típusok közötti kapcsolatokat.
• kapcsolatleképezési attribútumok, amelyek a kapcsolatkonfiguráció egyes aspektusaihoz használhatók a modellkészítő API alternatívaként.

A kapcsolatokhoz kapcsolódó egyéb témakörök a következők:

• Kaszkádolt törlés, amely leírja, hogyan törölhetők automatikusan a kapcsolódó entitások SaveChanges vagy SaveChangesAsync meghívásakor.
• tulajdonosi entitástípusok egy speciális típusú "tulajdonosi" kapcsolatot használnak, amely erősebb kapcsolatot feltételez a két típus között, mint az itt tárgyalt "normál" kapcsolatok. A normál kapcsolatokhoz itt ismertetett fogalmak közül sok a saját tulajdonú kapcsolatokra kerül át. A saját tulajdonú kapcsolatoknak azonban saját speciális viselkedésük is van.

Kapcsolatok használata

A modellben definiált kapcsolatok különböző módokon használhatók. Például:

• A kapcsolatok a kapcsolódó adatok lekérdezésének háromféle módon használhatók:
  • egy LINQ-lekérdezés részeként, Includehasználatával.
  • Lazily lazy-loading proxyk használatával, vagy lazy-loading proxyk nélkül.
  • kifejezetten a Load vagy LoadAsync metódusok használatával.
• Kapcsolatok használhatók adatbevetési a PK-értékek FK-értékekkel való egyeztetésével.
• A kapcsolatok segítségével nyomon követheti az entitások grafikonjait. A változáskövető ezután a következőhöz használja a kapcsolatokat:
  • Kapcsolatok változásainak észlelése és javítás
  • Külső kulcsfrissítések küldése az adatbázisbaSaveChanges vagy SaveChangesAsync