Entitástípusok

Ha belefoglal egy DbSetet a kontextusába, az azt jelenti, hogy az szerepel az EF Core modelljében; általában entitásként hivatkozunk ilyen típusra. Az EF Core képes entitáspéldányok olvasására és írására az adatbázisból vagy az adatbázisba, és ha relációs adatbázist használ, az EF Core migrálással létrehozhat táblákat az entitásokhoz.

A modellben szereplő típusok

Konvenció szerint a környezet dbSet-tulajdonságaiban közzétett típusok entitásokként szerepelnek a modellben. A metódusban OnModelCreating megadott entitástípusok is bekerülnek, ahogy az egyéb felderített entitástípusok navigációs tulajdonságainak rekurzív feltárásával talált típusok is.

Az alábbi kódmintában minden típus megtalálható:

  • Blog azért van jelen, mert elérhetővé van téve a kontextus egy DbSet tulajdonságában.
  • Post szerepel benne, mert a Blog.Posts navigációs tulajdonságon keresztül lett észlelve.
  • AuditEntry mert a megadott érték a következőben van megadva: OnModelCreating.
internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<AuditEntry>();
    }
}

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 Blog Blog { get; set; }
}

public class AuditEntry
{
    public int AuditEntryId { get; set; }
    public string Username { get; set; }
    public string Action { get; set; }
}

Típusok kizárása a modellből

Ha nem szeretné, hogy egy típus szerepeljen a modellben, kizárhatja azt:

[NotMapped]
public class BlogMetadata
{
    public DateTime LoadedFromDatabase { get; set; }
}

Kizárás a migrálásból

Néha hasznos, ha ugyanazt az entitástípust több DbContext típusban is leképezték. Ez különösen igaz határolókeretes környezetek használatakor, amelyek esetében gyakori, hogy minden egyes határos környezethez más DbContext típus tartozik.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<IdentityUser>()
        .ToTable("AspNetUsers", t => t.ExcludeFromMigrations());
}

Ezzel a konfigurációs migrálás nem hozza létre a AspNetUsers táblát, de IdentityUser továbbra is szerepel a modellben, és normál módon használható.

Ha újra el kell kezdenie a tábla migrálással történő kezelését, akkor létre kell hoznia egy új migrálást, ahol AspNetUsers nincs kizárva. A következő migrálás tartalmazni fogja a tábla módosításait.

Tábla neve

Konvenció szerint minden entitástípus úgy lesz beállítva, hogy egy adatbázistáblára képezze le az entitást elérhetővé tevő DbSet tulajdonsággal megegyező nevű adatbázistáblát. Ha az adott entitáshoz nincs dbSet, a rendszer az osztálynevet használja.

Manuálisan konfigurálhatja a tábla nevét:

[Table("blogs")]
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
}

Táblaséma

Relációs adatbázis használatakor a táblák konvenció szerint jönnek létre az adatbázis alapértelmezett sémájában. A Microsoft SQL Server például a sémát dbo fogja használni (az SQLite nem támogatja a sémákat).

A táblákat az alábbiak szerint konfigurálhatja egy adott sémában való létrehozáshoz:

[Table("blogs", Schema = "blogging")]
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
}

Az egyes táblák sémájának megadása helyett az alapértelmezett sémát modellszinten is megadhatja a fluent API-val:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.HasDefaultSchema("blogging");
}

Vegye figyelembe, hogy az alapértelmezett séma beállítása más adatbázis-objektumokat, például szekvenciákat is érint.

Térkép megtekintése

Az entitástípusok a Fluent API használatával leképezhetők adatbázisnézetekbe.

Megjegyzés:

Az EF feltételezi, hogy a hivatkozott nézet már létezik az adatbázisban, nem hozza létre automatikusan az áttelepítés során.

modelBuilder.Entity<Blog>()
    .ToView("blogsView", schema: "blogging");

A nézetre való leképezés eltávolítja az alapértelmezett táblaleképezést, de az entitástípust explicit módon is hozzárendelheti egy táblához. Ebben az esetben a nézetleképezés lesz használva a lekérdezésekhez, a táblaleképezés pedig a frissítésekhez.

Jótanács

A memóriabeli szolgáltatóval leképezett nézetekre leképezett kulcs nélküli entitástípusok teszteléséhez lekérdezéshez kell őket leképezni ToInMemoryQuery. További információt a memórián belüli szolgáltató dokumentációjában talál.

Táblaértékű függvényleképezés

Egy entitástípus megfeleltethető táblaértékű függvényhez (TVF) az adatbázisban lévő táblázat helyett. Ennek szemléltetéséhez definiáljunk egy másik entitást, amely több bejegyzést tartalmazó blogot jelöl. A példában az entitás kulcs nélküli, de nem kell.

public class BlogWithMultiplePosts
{
    public string Url { get; set; }
    public int PostCount { get; set; }
}

Ezután hozza létre a következő táblaértékű függvényt az adatbázisban, amely csak a több bejegyzést tartalmazó blogokat, valamint az egyes blogokhoz társított bejegyzések számát adja vissza:

CREATE FUNCTION dbo.BlogsWithMultiplePosts()
RETURNS TABLE
AS
RETURN
(
    SELECT b.Url, COUNT(p.BlogId) AS PostCount
    FROM Blogs AS b
    JOIN Posts AS p ON b.BlogId = p.BlogId
    GROUP BY b.BlogId, b.Url
    HAVING COUNT(p.BlogId) > 1
)

Az entitás BlogWithMultiplePosts most a következő módon képezhető le erre a függvényre:

modelBuilder.Entity<BlogWithMultiplePosts>().HasNoKey().ToFunction("BlogsWithMultiplePosts");

Megjegyzés:

Ahhoz, hogy egy entitást táblaértékű függvényhez rendelhessen, a függvénynek paraméter nélkülinek kell lennie.

Az entitás tulajdonságai hagyományosan a TVF által visszaadott egyező oszlopokhoz lesznek megfeleltetve. Ha a TVF által visszaadott oszlopok neve eltér az entitástulajdonságtól, akkor az entitás oszlopai metódussal HasColumnName konfigurálhatók, ugyanúgy, mint egy normál táblára való leképezéskor.

Ha az entitástípus egy táblaértékű függvényre van leképezve, a lekérdezés:

var query = from b in context.Set<BlogWithMultiplePosts>()
            where b.PostCount > 3
            select new { b.Url, b.PostCount };

A következő SQL-t hozza létre:

SELECT [b].[Url], [b].[PostCount]
FROM [dbo].[BlogsWithMultiplePosts]() AS [b]
WHERE [b].[PostCount] > 3

Táblázat megjegyzései

Beállíthat egy tetszőleges szöveges megjegyzést, amely be lesz állítva az adatbázistáblában, így dokumentálhatja a sémát az adatbázisban:

[Comment("Blogs managed on the website")]
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
}

Megosztott típusú entitástípusok

Az azonos CLR-típust használó entitástípusokat megosztott típusú entitástípusoknak nevezzük. Ezeket az entitástípusokat egyedi névvel kell konfigurálni, amelyet a CLR-típus mellett a megosztott típusú entitástípus használatakor is meg kell adni. Ez azt jelenti, hogy a DbSet hívást használva kell megvalósítani a megfelelő Set tulajdonságot.

internal class MyContext : DbContext
{
    public DbSet<Dictionary<string, object>> Blogs => Set<Dictionary<string, object>>("Blog");

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.SharedTypeEntity<Dictionary<string, object>>(
            "Blog", bb =>
            {
                bb.Property<int>("BlogId");
                bb.Property<string>("Url");
                bb.Property<DateTime>("LastUpdated");
            });
    }
}
  • Last updated on