Delen via

Typen sleutelloze entiteiten

Opmerking

Deze functie is toegevoegd onder de naam van querytypen. De naam is later gewijzigd in sleutelloze entiteitstypen.

Naast reguliere entiteitstypen kan een EF Core-model sleutelloze entiteitstypen bevatten, die kunnen worden gebruikt om databasequery's uit te voeren op gegevens die geen sleutelwaarden bevatten.

Sleutelloze entiteitstypen definiëren

Sleutelloze entiteitstypen kunnen als volgt worden gedefinieerd:

[Keyless]
public class BlogPostsCount
{
    public string BlogName { get; set; }
    public int PostCount { get; set; }
}

Kenmerken van sleutelloze entiteitstypen

Sleutelloze entiteitstypen ondersteunen veel van dezelfde toewijzingsmogelijkheden als reguliere entiteitstypen, zoals overnametoewijzing en navigatie-eigenschappen. In relationele archieven kunnen ze de doeldatabaseobjecten en -kolommen configureren via fluent API-methoden of gegevensaantekeningen.

Ze verschillen echter van de typen reguliere entiteiten omdat ze:

  • Er kan geen sleutel zijn gedefinieerd.
  • Worden nooit bijgehouden voor wijzigingen in DbContext en worden daarom nooit ingevoegd, bijgewerkt of verwijderd in de database.
  • Nooit door conventie ontdekt.
  • Ondersteun alleen een subset van navigatiemogelijkheden, specifiek:
    • Zij kunnen nooit fungeren als het voornaamste doel van een relatie.
    • Het is mogelijk dat ze geen navigatie hebben naar entiteiten die ze bezitten.
    • Ze kunnen alleen referentienavigatie-eigenschappen bevatten die verwijzen naar reguliere entiteiten.
    • Entiteiten kunnen geen navigatie-eigenschappen bevatten voor sleutelloze entiteitstypen.
  • Moet worden geconfigureerd met een [Keyless] gegevensaantekening of een .HasNoKey() methodeaanroep.
  • Kan worden toegewezen aan een definiërende query. Een definitiequery is een query die in het model is gedeclareerd en fungeert als een gegevensbron voor een sleutelloos entiteitstype.
  • Kan een hiërarchie hebben, maar moet worden toegewezen als TPH.
  • Kan het splitsen van tabellen of het splitsen van entiteiten niet gebruiken.

Gebruiksscenario's

Enkele van de belangrijkste gebruiksscenario's voor sleutelloze entiteitstypen zijn:

  • Fungeren als het retourtype voor SQL-query's.
  • Toewijzing aan databaseweergaven die geen primaire sleutel bevatten.
  • Toewijzing aan tabellen waarvoor geen primaire sleutel is gedefinieerd.
  • Koppeling aan queries die zijn gedefinieerd in het model.

Toewijzing aan databaseobjecten

Het toewijzen van een sleutelloze entiteitstype aan een databaseobject wordt bereikt met behulp van de ToTable of ToView fluent-API. Vanuit het perspectief van EF Core is het databaseobject dat in deze methode is opgegeven een weergave, wat betekent dat het wordt behandeld als een alleen-lezen querybron en niet het doel kan zijn van update-, in- of verwijderbewerkingen. Dit betekent echter niet dat het databaseobject daadwerkelijk een databaseweergave moet zijn. Het kan ook een databasetabel zijn die als alleen-lezen wordt behandeld. Voor reguliere entiteitstypen gaat EF Core er echter van uit dat een databaseobject dat is opgegeven in de ToTable methode kan worden behandeld als een tabel, wat betekent dat het kan worden gebruikt als een querybron, maar ook gericht is op update-, verwijder- en invoegbewerkingen. U kunt zelfs de naam van een databaseweergave ToTable opgeven en alles werkt prima zolang de weergave zo is geconfigureerd dat deze kan worden bijgewerkt in de database.

Voorbeeld

In het volgende voorbeeld ziet u hoe u sleutelloze entiteitstypen gebruikt om een query uit te voeren op een databaseweergave.

Aanbeveling

U kunt het voorbeeld van dit artikel bekijken op GitHub.

Eerst definiëren we een eenvoudig blog- en postmodel:

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }
    public string Url { get; set; }
    public ICollection<Post> Posts { get; set; }
}

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

Vervolgens definiëren we een eenvoudige databaseweergave waarmee we een query kunnen uitvoeren op het aantal berichten dat aan elke blog is gekoppeld:

await db.Database.ExecuteSqlRawAsync(
    @"CREATE VIEW View_BlogPostCounts AS
                SELECT b.Name, Count(p.PostId) as PostCount
                FROM Blogs b
                JOIN Posts p on p.BlogId = b.BlogId
                GROUP BY b.Name");

Vervolgens definiëren we een klasse voor het opslaan van het resultaat uit de databaseweergave:

public class BlogPostsCount
{
    public string BlogName { get; set; }
    public int PostCount { get; set; }
}

Vervolgens configureren we het type sleutelloze entiteit in OnModelCreating met behulp van de HasNoKey API. We gebruiken de fluent configuration API om de toewijzing voor een entiteitstype zonder sleutel in te stellen.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder
        .Entity<BlogPostsCount>(
            eb =>
            {
                eb.HasNoKey();
                eb.ToView("View_BlogPostCounts");
                eb.Property(v => v.BlogName).HasColumnName("Name");
            });
}

Vervolgens configureren we DbContext om DbSet<T> op te nemen.

public DbSet<BlogPostsCount> BlogPostCounts { get; set; }

Ten slotte kunnen we de databaseweergave op de standaard manier opvragen:

var postCounts = await db.BlogPostCounts.ToListAsync();

foreach (var postCount in postCounts)
{
    Console.WriteLine($"{postCount.BlogName} has {postCount.PostCount} posts.");
    Console.WriteLine();
}

Aanbeveling

Houd er rekening mee dat we ook een query-eigenschap op contextniveau (DbSet) hebben gedefinieerd om te fungeren als basis voor query's tegen dit type.

Aanbeveling

Om sleutelloze entiteitstypen die aan weergaven zijn toegewezen te testen, gebruikt u de in-memoryprovider en wijst u ze toe aan een query via ToInMemoryQuery. Zie de documentatie voor de in-memory provider voor meer informatie.