Dela via

Egenskaper för skugg- och indexerare

Skuggegenskaper är egenskaper som inte definieras i .NET-entitetsklassen, men som definieras för den entitetstypen i EF Core-modellen. Värdet och tillståndet för dessa egenskaper behålls enbart i Ändringsspåraren. Skuggegenskaper är användbara när det finns data i databasen som inte ska exponeras för de mappade entitetstyperna.

Indexerarens egenskaper är egenskaper av entitetstyp som backas upp av en indexerare i entitetsklassen .NET. De kan nås med hjälp av indexeraren på .NET-klassinstanserna. Du kan också lägga till ytterligare egenskaper i entitetstypen utan att ändra CLR-klassen.

Skuggegenskaper för utländsk nyckel

Skuggegenskaper används oftast för sekundärnyckelegenskaper, där de läggs till i modellen enligt konvention när ingen sekundärnyckelegenskap har hittats av konventionen eller konfigurerats explicit. Relationen representeras av navigeringsegenskaper, men i databasen framtvingas den av en sekundärnyckelbegränsning och värdet för kolumnen sekundärnyckel lagras i motsvarande skuggegenskap.

Egenskapen kommer att namnges <navigation property name><principal key property name> (navigeringen på den beroende entiteten, som pekar på huvudentiteten, används för namngivningen). Om nyckelns primära egenskapsnamn börjar med navigeringsegenskapens namn, då kommer namnet bara vara <principal key property name>. Om det inte finns någon navigeringsegenskap för den beroende entiteten används huvudnamntypen som sammanfogats med det primära eller alternativa nyckelegenskapsnamnet i stället <principal type name><principal key property name>.

Följande kodlista resulterar till exempel i att en BlogId skuggegenskap introduceras för Post entiteten:

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

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

    // Since there is no CLR property which holds the foreign
    // key for this relationship, a shadow property is created.
    public Blog Blog { get; set; }
}

Konfigurera skuggegenskaper

Du kan använda Api:et Fluent för att konfigurera skuggegenskaper. När du har anropat strängöverbelastningen för Property<TProperty>(String)kan du länka alla konfigurationsanrop som du skulle göra för andra egenskaper. Eftersom Blog inte har någon CLR-egenskap med namnet LastUpdated, skapas en skuggegenskap.

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .Property<DateTime>("LastUpdated");
    }
}

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

Om namnet som anges i Property metoden matchar namnet på en befintlig egenskap (en skuggegenskap eller en som definierats i entitetsklassen) konfigurerar koden den befintliga egenskapen i stället för att införa en ny skuggegenskap.

Åtkomst till skuggegenskaper

Värden för skuggegenskap kan hämtas och ändras via API:et ChangeTracker :

context.Entry(myBlog).Property("LastUpdated").CurrentValue = DateTime.Now;

Skuggegenskaper kan refereras till i LINQ-frågor via den EF.Property statiska metoden:

var blogs = context.Blogs
    .OrderBy(b => EF.Property<DateTime>(b, "LastUpdated"));

Det går inte att komma åt skuggegenskaper efter en fråga utan spårning eftersom de entiteter som returneras inte spåras av ändringsspåraren.

Konfigurera indexeraregenskaper

Du kan använda Fluent API för att konfigurera indexeraregenskaper. När du har anropat metoden IndexerPropertykan du länka alla konfigurationsanrop som du skulle göra för andra egenskaper. I följande exempel Blog har en indexerare definierats och används för att skapa en indexeraregenskap.

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>().IndexerProperty<DateTime>("LastUpdated");
    }
}

public class Blog
{
    private readonly Dictionary<string, object> _data = new Dictionary<string, object>();
    public int BlogId { get; set; }

    public object this[string key]
    {
        get => _data[key];
        set => _data[key] = value;
    }
}

Om namnet som anges i IndexerProperty metoden matchar namnet på en befintlig indexerareegenskap konfigurerar koden den befintliga egenskapen. Om entitetstypen har en egenskap som backas upp av en egenskap i entitetsklassen genereras ett undantag eftersom indexerarens egenskaper endast får nås via indexeraren.

Indexerarens egenskaper kan refereras till i LINQ-frågor via den EF.Property statiska metoden enligt ovan eller med hjälp av egenskapen CLR-indexerare.

Entitetstyper för egenskapspåse

Entitetstyper som endast innehåller indexeraregenskaper kallas egenskapsuppsättningsentitetstyper. Dessa entitetstyper har inte skuggegenskaper och EF skapar indexeraregenskaper i stället. För närvarande stöds endast Dictionary<string, object> som en egenskapsuppsättningsentitetstyp. Den måste konfigureras som en entitetstyp av delad typ med ett unikt namn och motsvarande DbSet egenskap måste implementeras med hjälp av ett Set anrop.

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

Entitetstyper för egenskapspåse kan användas varhelst en normal entitetstyp används, inklusive som en ägd entitetstyp. De har dock vissa begränsningar:

  • Last updated on