Erstellen und Konfigurieren eines Modells

EF Core verwendet ein Metadatenmodell , um zu beschreiben, wie die Entitätstypen der Anwendung der zugrunde liegenden Datenbank zugeordnet werden. Dieses Modell wird mit einer Reihe von Konventionen erstellt – Heuristiken, die nach allgemeinen Mustern suchen. Das Modell kann dann mithilfe von Zuordnungsattributen (auch als Datenanmerkungen bezeichnet) und/oder Aufrufen der ModelBuilder Methoden (auch als Fluent-API bezeichnet) angepasst werden, in OnModelCreatingdenen beide die konfiguration außer Kraft setzen, die von Konventionen ausgeführt wird.

Die meisten Konfigurationen können auf ein Modell angewendet werden, das auf einen beliebigen Datenspeicher ausgerichtet ist. Anbieter können auch eine konfiguration aktivieren, die für einen bestimmten Datenspeicher spezifisch ist, und sie können auch die Konfiguration ignorieren, die nicht unterstützt oder nicht zutreffend ist. Eine Dokumentation zur anbieterspezifischen Konfiguration finden Sie im Abschnitt "Datenbankanbieter ".

Tipp

Sie können die Beispiele dieses Artikels auf GitHub anzeigen.

Verwenden der Fluent-API zum Konfigurieren eines Modells

Sie können die OnModelCreating Methode in Ihrem abgeleiteten Kontext überschreiben und die Fluent-API verwenden, um Ihr Modell zu konfigurieren. Dies ist die leistungsstärkste Methode der Konfiguration und ermöglicht die Angabe der Konfiguration, ohne die Entitätsklassen zu ändern. Die Fluent-API-Konfiguration hat die höchste Priorität und überschreibt Konventionen und Datenanmerkungen. Die Konfiguration wird in der Reihenfolge angewendet, in der die Methoden aufgerufen werden, und wenn Konflikte auftreten, überschreibt der neueste Aufruf die zuvor angegebene Konfiguration.

using Microsoft.EntityFrameworkCore;

namespace EFModeling.EntityProperties.FluentAPI.Required;

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

    #region Required
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .Property(b => b.Url)
            .IsRequired();
    }
    #endregion
}

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

Tipp

Wenn Sie dieselbe Konfiguration auf mehrere Objekte im Modell anwenden möchten, lesen Sie die Massenkonfiguration.

Gruppierungskonfiguration

Um die Größe der OnModelCreating-Methode zu verringern, kann die gesamte Konfiguration für einen Entitätstyp in eine separate Klasse extrahiert werden, die IEntityTypeConfiguration<TEntity> implementiert.

public class BlogEntityTypeConfiguration : IEntityTypeConfiguration<Blog>
{
    public void Configure(EntityTypeBuilder<Blog> builder)
    {
        builder
            .Property(b => b.Url)
            .IsRequired();
    }
}

Rufen Sie dann einfach die Configure Methode von OnModelCreating.

new BlogEntityTypeConfiguration().Configure(modelBuilder.Entity<Blog>());

Anwenden aller Konfigurationen in einer Assembly

Es ist möglich, alle in Typen, die in einer bestimmten Assembly implementiert werden, angegebenen Konfigurationen anzuwenden.

modelBuilder.ApplyConfigurationsFromAssembly(typeof(BlogEntityTypeConfiguration).Assembly);

Hinweis

Die Reihenfolge, in der die Konfigurationen angewendet werden, ist nicht definiert, daher sollte diese Methode nur verwendet werden, wenn die Reihenfolge keine Rolle spielt.

Verwenden von EntityTypeConfigurationAttribute auf den Entitätstypen

Anstatt explizit aufzurufen Configure, kann eine EntityTypeConfigurationAttribute stattdessen für den Entitätstyp platziert werden, sodass EF Core die entsprechende Konfiguration finden und verwenden kann. Beispiel:

[EntityTypeConfiguration(typeof(BookConfiguration))]
public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Isbn { get; set; }
}

Dieses Attribut bedeutet, dass EF Core die angegebene IEntityTypeConfiguration Implementierung verwendet, wenn der Book Entitätstyp in einem Modell enthalten ist. Der Entitätstyp ist in einem Modell enthalten, das einen der normalen Mechanismen verwendet. Beispielsweise durch Erstellen einer DbSet<TEntity> Eigenschaft für den Entitätstyp:

public class BooksContext : DbContext
{
    public DbSet<Book> Books { get; set; }

    //...

Oder indem Sie es in OnModelCreating registrieren:

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

Hinweis

EntityTypeConfigurationAttribute Typen werden in einer Assembly nicht automatisch erkannt. Entitätstypen müssen dem Modell hinzugefügt werden, bevor das Attribut für diesen Entitätstyp ermittelt wird.

Verwenden von Datenanmerkungen zum Konfigurieren eines Modells

Sie können auch bestimmte Attribute (als Datenanmerkungen bezeichnet) auf Ihre Klassen und Eigenschaften anwenden. Datenanmerkungen überschreiben Konventionen, werden jedoch von der Fluent-API-Konfiguration außer Kraft gesetzt.

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Microsoft.EntityFrameworkCore;

namespace EFModeling.EntityProperties.DataAnnotations.Annotations;

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

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

    [Required]
    public string Url { get; set; }
}

Integrierte Konventionen

EF Core enthält viele Konventionen zum Erstellen von Modellen, die standardmäßig aktiviert sind. Alle finden Sie in der Liste der Klassen, die die IConvention Schnittstelle implementieren. Diese Liste enthält jedoch keine Konventionen, die von Drittanbietern und Plug-Ins eingeführt wurden.

Anwendungen können eine dieser Konventionen entfernen oder ersetzen sowie neue benutzerdefinierte Konventionen hinzufügen, die die Konfiguration für Muster anwenden, die von EF nicht sofort erkannt werden.

Tipp

Der unten gezeigte Code stammt aus ModelBuildingConventionsSample.cs.

Entfernen einer vorhandenen Konvention

Manchmal ist eine der integrierten Konventionen für Ihre Anwendung möglicherweise nicht geeignet, in diesem Fall kann sie entfernt werden.

Tipp

Wenn Ihr Modell keine Zuordnungsattribute (auch als Datenanmerkungen bezeichnet) für die Konfiguration verwendet, können alle Konventionen mit dem Endnamen AttributeConvention sicher entfernt werden, um die Modellerstellung zu beschleunigen.

Beispiel: Erstellen Sie keine Indizes für Fremdschlüsselspalten.

Normalerweise ist es sinnvoll, Indizes für FK-Spalten (Fremdschlüsselspalten) zu erstellen, und daher gibt es hierfür eine integrierte Konvention: ForeignKeyIndexConvention Beim Betrachten der Modelldebugansicht für einen Post Entitätstyp mit Beziehungen Blog zu und Authorsehen wir, dass zwei Indizes für das BlogId FK erstellt werden, und die andere für die AuthorId FK.

  EntityType: Post
    Properties:
      Id (int) Required PK AfterSave:Throw ValueGenerated.OnAdd
      AuthorId (no field, int?) Shadow FK Index
      BlogId (no field, int) Shadow Required FK Index
    Navigations:
      Author (Author) ToPrincipal Author Inverse: Posts
      Blog (Blog) ToPrincipal Blog Inverse: Posts
    Keys:
      Id PK
    Foreign keys:
      Post {'AuthorId'} -> Author {'Id'} ToDependent: Posts ToPrincipal: Author ClientSetNull
      Post {'BlogId'} -> Blog {'Id'} ToDependent: Posts ToPrincipal: Blog Cascade
    Indexes:
      AuthorId
      BlogId

Indizes haben jedoch Mehraufwand, und es ist möglicherweise nicht immer geeignet, sie für alle FK-Spalten zu erstellen. Um dies zu erreichen, kann dies ForeignKeyIndexConvention beim Erstellen des Modells entfernt werden:

protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
    configurationBuilder.Conventions.Remove(typeof(ForeignKeyIndexConvention));
}

In der Debugansicht des Modells Post sehen wir, dass die Indizes für FKs nicht erstellt wurden:

  EntityType: Post
    Properties:
      Id (int) Required PK AfterSave:Throw ValueGenerated.OnAdd
      AuthorId (no field, int?) Shadow FK
      BlogId (no field, int) Shadow Required FK
    Navigations:
      Author (Author) ToPrincipal Author Inverse: Posts
      Blog (Blog) ToPrincipal Blog Inverse: Posts
    Keys:
      Id PK
    Foreign keys:
      Post {'AuthorId'} -> Author {'Id'} ToDependent: Posts ToPrincipal: Author ClientSetNull
      Post {'BlogId'} -> Blog {'Id'} ToDependent: Posts ToPrincipal: Blog Cascade

Bei Bedarf können Indizes weiterhin explizit für Fremdschlüsselspalten erstellt werden, entweder mit der IndexAttribute oder mit der Konfiguration in OnModelCreating.

Debugansicht

Auf die Debugansicht des Modell-Generators kann im Debugger Ihrer IDE zugegriffen werden. Beispiel: mit Visual Studio:

Es kann auch direkt über Code zugegriffen werden, z. B. um die Debugansicht an die Konsole zu senden:

Console.WriteLine(context.Model.ToDebugString());

Die Debugansicht verfügt über ein kurzes Formular und ein langes Formular. Das lange Formular enthält auch alle Anmerkungen, die nützlich sein können, wenn Sie relationale oder anbieterspezifische Metadaten anzeigen müssen. Auf die lange Ansicht kann auch über Code zugegriffen werden:

Console.WriteLine(context.Model.ToDebugString(MetadataDebugStringOptions.LongDefault));