Partager via

Types d’entités sans clé

Remarque

Cette fonctionnalité a été ajoutée sous le nom des types de requête. Il a ensuite été renommé en types d’entités sans clé.

En plus des types d’entités standard, un modèle EF Core peut contenir des types d’entités sans clé, qui peuvent être utilisés pour effectuer des requêtes de base de données sur des données qui ne contiennent pas de valeurs de clé.

Définition des types d’entités sans clé

Les types d’entités sans clé peuvent être définis comme suit :

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

Caractéristiques des types d’entités sans clé

Les types d’entités sans clé prennent en charge la plupart des mêmes fonctionnalités de mappage que les types d’entités standard, comme le mappage d’héritage et les propriétés de navigation. Sur les magasins relationnels, ils peuvent configurer les objets et colonnes de base de données cibles via des méthodes d’API Fluent ou des annotations de données.

Toutefois, ils sont différents des types d’entités standard en ce qu’ils :

  • Impossible d’avoir une clé définie.
  • Ne sont jamais suivies pour les modifications dans DbContext et ne sont donc jamais insérées, mises à jour ou supprimées sur la base de données.
  • Ne sont jamais découverts par convention.
  • Prend uniquement en charge un sous-ensemble de fonctionnalités de mappage de navigation, en particulier :
    • Ils ne peuvent jamais agir comme la fin principale d’une relation.
    • Ils peuvent ne pas avoir de navigation vers des entités appartenant à quelqu’un
    • Ils peuvent uniquement contenir des propriétés de navigation de référence pointant vers des entités régulières.
    • Les entités ne peuvent pas contenir de propriétés de navigation vers des types d’entités sans clé.
  • Cela doit être configuré soit avec une [Keyless] annotation de données, soit avec un .HasNoKey() appel de méthode.
  • Peut être mappé à une requête de définition. Une requête de définition est une requête déclarée dans le modèle qui agit comme une source de données pour un type d’entité sans clé.
  • Peut avoir une hiérarchie, mais elle doit être cartographiée comme TPH.
  • Impossible d’utiliser le fractionnement de table ou le fractionnement d’entité.

Scénarios d’usage

Voici quelques-uns des principaux scénarios d’utilisation pour les types d’entités sans clé :

  • Servir de type de retour pour les requêtes SQL.
  • Mappage vers des vues de base de données qui ne contiennent pas de clé primaire.
  • Cartographie des tables qui n’ont pas de clé primaire définie.
  • Mappage aux requêtes définies dans le modèle.

Mappage à des objets de base de données

Le mappage d’un type d’entité sans clé à un objet de base de données est réalisé à l'aide de l’API fluent ToTable ou ToView. Du point de vue d’EF Core, l’objet de base de données spécifié dans cette méthode est une vue, ce qui signifie qu’elle est traitée comme une source de requête en lecture seule et ne peut pas être la cible des opérations de mise à jour, d’insertion ou de suppression. Toutefois, cela ne signifie pas que l’objet de base de données est réellement requis pour être une vue de base de données. Il peut également s’agir d’une table de base de données qui sera traitée en lecture seule. À l’inverse, pour les types d’entités standard, EF Core suppose qu’un objet de base de données spécifié dans la ToTable méthode peut être traité comme une table, ce qui signifie qu’il peut être utilisé comme source de requête, mais également ciblé par les opérations de mise à jour, de suppression et d’insertion. En fait, vous pouvez spécifier le nom d’une vue de base de données et ToTable tout doit fonctionner correctement tant que l’affichage est configuré pour être pouvant être mis à jour sur la base de données.

Exemple :

L’exemple suivant montre comment utiliser des types d’entités sans clé pour interroger une vue de base de données.

Conseil / Astuce

Vous pouvez afficher l’exemple de cet article sur GitHub.

Tout d’abord, nous définissons un modèle de blog et de publication simple :

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

Ensuite, nous définissons une vue de base de données simple qui nous permettra d’interroger le nombre de billets associés à chaque blog :

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

Ensuite, nous définissons une classe pour contenir le résultat de la vue de base de données :

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

Ensuite, nous configurons le type d’entité sans clé dans OnModelCreating à l’aide de l’API HasNoKey . Nous utilisons l’API de configuration Fluent pour configurer le mappage pour le type d’entité sans clé :

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

Ensuite, nous configurons le DbContext pour inclure le DbSet<T>.

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

Enfin, nous pouvons interroger la vue de base de données de la manière standard :

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

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

Conseil / Astuce

Notez que nous avons également défini une propriété de requête au niveau du contexte (DbSet) pour agir en tant que point de départ pour les requêtes sur ce type.

Conseil / Astuce

Pour tester les types d’entités sans clé associés aux vues à l’aide du fournisseur en mémoire vive, associez-les à une requête via ToInMemoryQuery. Pour plus d’informations, consultez la documentation du fournisseur en mémoire .