Fließende Eigenschaften und Typen für die API-Konfiguration und-ZuordnungFluent API - Configuring and Mapping Properties and Types

Beim Arbeiten mit Entity Framework Code First das Standardverhalten das Zuordnen Ihrer poco-Klassen zu Tabellen mithilfe eines Satzes von Konventionen, die in EF gebacken werden.When working with Entity Framework Code First the default behavior is to map your POCO classes to tables using a set of conventions baked into EF. Manchmal ist es jedoch nicht möglich, diese Konventionen einzuhalten, und die Entitäten müssen einem anderen als dem von den Konventionen vorgegeben werden.Sometimes, however, you cannot or do not want to follow those conventions and need to map entities to something other than what the conventions dictate.

Es gibt zwei Hauptmethoden zum Konfigurieren von EF, um etwas anderes als Konventionen zu verwenden, nämlich Anmerkungen oder eine EFS-fließende API.There are two main ways you can configure EF to use something other than conventions, namely annotations or EFs fluent API. Die Anmerkungen decken nur eine Teilmenge der Funktionen der fließenden API ab, daher gibt es zuordnungsszenarien, die mithilfe von Anmerkungen nicht erreicht werden können.The annotations only cover a subset of the fluent API functionality, so there are mapping scenarios that cannot be achieved using annotations. In diesem Artikel wird veranschaulicht, wie Sie die fließende API zum Konfigurieren von Eigenschaften verwenden.This article is designed to demonstrate how to use the fluent API to configure properties.

Der Zugriff auf die Code First-fließend-API wird am häufigsten durch Überschreiben der onmodelcreating -Methode für den abgeleiteten dbcontexterreicht.The code first fluent API is most commonly accessed by overriding the OnModelCreating method on your derived DbContext. Die folgenden Beispiele veranschaulichen, wie verschiedene Aufgaben mit der fließend-API ausgeführt werden können und wie Sie den Code kopieren und an Ihr Modell anpassen können. Wenn Sie sehen möchten, wie das Modell, mit dem Sie arbeiten können, unverändert verwendet werden kann, wird es am Ende dieses Artikels bereitgestellt.The following samples are designed to show how to do various tasks with the fluent api and allow you to copy the code out and customize it to suit your model, if you wish to see the model that they can be used with as-is then it is provided at the end of this article.

Model-Wide EinstellungenModel-Wide Settings

Standard Schema (EF6 oder höher)Default Schema (EF6 onwards)

Beginnend mit EF6 können Sie mit der hasdefaultschema-Methode von dbmodelbuilder das Datenbankschema angeben, das für alle Tabellen, gespeicherten Prozeduren usw. verwendet werden soll. Diese Standardeinstellung wird für alle Objekte, für die Sie explizit ein anderes Schema konfigurieren, überschrieben.Starting with EF6 you can use the HasDefaultSchema method on DbModelBuilder to specify the database schema to use for all tables, stored procedures, etc. This default setting will be overridden for any objects that you explicitly configure a different schema for.

modelBuilder.HasDefaultSchema("sales");

Benutzerdefinierte Konventionen (EF6 oder höher)Custom Conventions (EF6 onwards)

Beginnend mit EF6 können Sie eigene Konventionen erstellen, um die in Code First enthaltenen Konventionen zu ergänzen.Starting with EF6 you can create your own conventions to supplement the ones included in Code First. Weitere Informationen finden Sie unter benutzerdefinierte Code First Konventionen.For more details, see Custom Code First Conventions.

EigenschaftszuordnungProperty Mapping

Die Property -Methode wird verwendet, um Attribute für jede Eigenschaft zu konfigurieren, die zu einer Entität oder einem komplexen Typ gehört.The Property method is used to configure attributes for each property belonging to an entity or complex type. Die-Eigenschaften Methode wird verwendet, um ein Konfigurationsobjekt für eine bestimmte Eigenschaft abzurufen.The Property method is used to obtain a configuration object for a given property. Die Optionen für das Konfigurationsobjekt sind spezifisch für den konfigurierten Typ. Isunicode ist beispielsweise nur für Zeichen folgen Eigenschaften verfügbar.The options on the configuration object are specific to the type being configured; IsUnicode is available only on string properties for example.

Konfigurieren eines PrimärschlüsselsConfiguring a Primary Key

Die Entity Framework Konvention für Primärschlüssel lautet wie folgt:The Entity Framework convention for primary keys is:

  1. Ihre Klasse definiert eine Eigenschaft mit dem Namen "ID" oder "ID".Your class defines a property whose name is “ID” or “Id”
  2. oder einen Klassennamen, gefolgt von "ID" oder "ID".or a class name followed by “ID” or “Id”

Um explizit eine Eigenschaft als Primärschlüssel festzulegen, können Sie die Haskey-Methode verwenden.To explicitly set a property to be a primary key, you can use the HasKey method. Im folgenden Beispiel wird die Haskey-Methode verwendet, um den "InstructorID"-Primärschlüssel für den officezuweisungstyp zu konfigurieren.In the following example, the HasKey method is used to configure the InstructorID primary key on the OfficeAssignment type.

modelBuilder.Entity<OfficeAssignment>().HasKey(t => t.InstructorID);

Konfigurieren eines zusammengesetzten PrimärschlüsselsConfiguring a Composite Primary Key

Im folgenden Beispiel werden die Eigenschaften "DepartmentID" und "Name" als zusammengesetzter Primärschlüssel des Abteilungs Typs konfiguriert.The following example configures the DepartmentID and Name properties to be the composite primary key of the Department type.

modelBuilder.Entity<Department>().HasKey(t => new { t.DepartmentID, t.Name });

Ausschalten der Identität für numerische PrimärschlüsselSwitching off Identity for Numeric Primary Keys

Im folgenden Beispiel wird die DepartmentID-Eigenschaft auf System. ComponentModel. DataAnnotations. databasegeneratedoption. None festgelegt, um anzugeben, dass der Wert nicht von der Datenbank generiert wird.The following example sets the DepartmentID property to System.ComponentModel.DataAnnotations.DatabaseGeneratedOption.None to indicate that the value will not be generated by the database.

modelBuilder.Entity<Department>().Property(t => t.DepartmentID)
    .HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);

Angeben der maximalen Länge für eine EigenschaftSpecifying the Maximum Length on a Property

Im folgenden Beispiel sollte die Name-Eigenschaft nicht länger als 50 Zeichen sein.In the following example, the Name property should be no longer than 50 characters. Wenn Sie den Wert länger als 50 Zeichen machen, wird eine dbentityvalidationexception -Ausnahme ausgelöst.If you make the value longer than 50 characters, you will get a DbEntityValidationException exception. Wenn Code First eine Datenbank aus diesem Modell erstellt, wird auch die maximale Länge der Spalte Name auf 50 Zeichen festgelegt.If Code First creates a database from this model it will also set the maximum length of the Name column to 50 characters.

modelBuilder.Entity<Department>().Property(t => t.Name).HasMaxLength(50);

Konfigurieren der Eigenschaft als erforderlichConfiguring the Property to be Required

Im folgenden Beispiel ist die Name-Eigenschaft erforderlich.In the following example, the Name property is required. Wenn Sie den Namen nicht angeben, wird eine dbentityvalidationexception-Ausnahme ausgelöst.If you do not specify the Name, you will get a DbEntityValidationException exception. Wenn Code First eine Datenbank aus diesem Modell erstellt, ist die Spalte, die zum Speichern dieser Eigenschaft verwendet wird, in der Regel keine NULL-Werte zulässig.If Code First creates a database from this model then the column used to store this property will usually be non-nullable.

Hinweis

In einigen Fällen ist es möglicherweise nicht möglich, dass die Spalte in der Datenbank keine NULL-Werte zulässt, auch wenn die-Eigenschaft erforderlich ist.In some cases it may not be possible for the column in the database to be non-nullable even though the property is required. Wenn z. b. eine TPH-Vererbungs Strategie verwendet wird, werden Daten für mehrere Typen in einer einzelnen Tabelle gespeichert.For example, when using a TPH inheritance strategy data for multiple types is stored in a single table. Wenn ein abgeleiteter Typ eine erforderliche Eigenschaft enthält, kann die Spalte nicht auf NULL festleg Bare Werte festgelegt werden, da nicht alle Typen in der Hierarchie über diese Eigenschaft verfügen.If a derived type includes a required property the column cannot be made non-nullable since not all types in the hierarchy will have this property.

modelBuilder.Entity<Department>().Property(t => t.Name).IsRequired();

Konfigurieren eines Indexes für eine oder mehrere EigenschaftenConfiguring an Index on one or more properties

Hinweis

Nur ab EF 6.1 : das Index Attribut wurde in Entity Framework 6,1 eingeführt.EF6.1 Onwards Only - The Index attribute was introduced in Entity Framework 6.1. Wenn Sie eine frühere Version verwenden, gelten die Informationen in diesem Abschnitt nicht.If you are using an earlier version the information in this section does not apply.

Das Erstellen von Indizes wird von der fließenden API nicht nativ unterstützt, aber Sie können die Unterstützung von Indexattribute über die fließende API nutzen.Creating indexes isn't natively supported by the Fluent API, but you can make use of the support for IndexAttribute via the Fluent API. Index Attribute werden verarbeitet, indem eine Modell Anmerkung in das Modell eingeschlossen wird, die dann später in der Pipeline in einen Index in der Datenbank umgewandelt wird.Index attributes are processed by including a model annotation on the model that is then turned into an Index in the database later in the pipeline. Sie können dieselben Anmerkungen mithilfe der fließend-API manuell hinzufügen.You can manually add these same annotations using the Fluent API.

Die einfachste Möglichkeit hierfür ist das Erstellen einer Instanz von Indexattribute , die alle Einstellungen für den neuen Index enthält.The easiest way to do this is to create an instance of IndexAttribute that contains all the settings for the new index. Anschließend können Sie eine Instanz der Indexnotation erstellen, bei der es sich um einen EF-spezifischen Typ handelt, der die Indexattribute -Einstellungen in eine Modell Anmerkung konvertiert, die im EF-Modell gespeichert werden kann.You can then create an instance of IndexAnnotation which is an EF specific type that will convert the IndexAttribute settings into a model annotation that can be stored on the EF model. Diese können dann an die hascolumnannotation -Methode für die fließende API weitergegeben werden, wobei der namens Index für die Anmerkung angegeben wird.These can then be passed to the HasColumnAnnotation method on the Fluent API, specifying the name Index for the annotation.

modelBuilder
    .Entity<Department>()
    .Property(t => t.Name)
    .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute()));

Eine umfassende Liste der in " Indexattribute" verfügbaren Einstellungen finden Sie im Abschnitt " Index " der Code First Daten Anmerkungen.For a complete list of the settings available in IndexAttribute, see the Index section of Code First Data Annotations. Dies umfasst das Anpassen des Index namens, das Erstellen eindeutiger Indizes und das Erstellen von mehrspaltigen Indizes.This includes customizing the index name, creating unique indexes, and creating multi-column indexes.

Sie können mehrere Index Anmerkungen für eine einzelne Eigenschaft angeben, indem Sie ein Array von " Indexattribute " an den Konstruktor von " indexannotation" übergeben.You can specify multiple index annotations on a single property by passing an array of IndexAttribute to the constructor of IndexAnnotation.

modelBuilder
    .Entity<Department>()
    .Property(t => t.Name)
    .HasColumnAnnotation(
        "Index",  
        new IndexAnnotation(new[]
            {
                new IndexAttribute("Index1"),
                new IndexAttribute("Index2") { IsUnique = true }
            })));

Angeben, dass eine CLR-Eigenschaft einer Spalte in der Datenbank nicht zugeordnet werden sollSpecifying Not to Map a CLR Property to a Column in the Database

Im folgenden Beispiel wird gezeigt, wie angegeben wird, dass eine Eigenschaft eines CLR-Typs keiner Spalte in der Datenbank zugeordnet ist.The following example shows how to specify that a property on a CLR type is not mapped to a column in the database.

modelBuilder.Entity<Department>().Ignore(t => t.Budget);

Mapping einer CLR-Eigenschaft zu einer bestimmten Spalte in der DatenbankMapping a CLR Property to a Specific Column in the Database

Im folgenden Beispiel wird die Name CLR-Eigenschaft der DepartmentName-Daten Bank Spalte zugeordnet.The following example maps the Name CLR property to the DepartmentName database column.

modelBuilder.Entity<Department>()
    .Property(t => t.Name)
    .HasColumnName("DepartmentName");

Umbenennen eines fremd Schlüssels, der nicht im Modell definiert istRenaming a Foreign Key That Is Not Defined in the Model

Wenn Sie keinen Fremdschlüssel für einen CLR-Typ definieren, aber angeben möchten, welcher Name in der Datenbank enthalten sein soll, gehen Sie wie folgt vor:If you choose not to define a foreign key on a CLR type, but want to specify what name it should have in the database, do the following:

modelBuilder.Entity<Course>()
    .HasRequired(c => c.Department)
    .WithMany(t => t.Courses)
    .Map(m => m.MapKey("ChangedDepartmentID"));

Konfigurieren, ob eine Zeichen folgen Eigenschaft Unicode-Inhalt unterstütztConfiguring whether a String Property Supports Unicode Content

Standardmäßig sind Zeichen folgen Unicode (nvarchar in SQL Server).By default strings are Unicode (nvarchar in SQL Server). Sie können die isunicode-Methode verwenden, um anzugeben, dass eine Zeichenfolge vom Typ varchar sein soll.You can use the IsUnicode method to specify that a string should be of varchar type.

modelBuilder.Entity<Department>()
    .Property(t => t.Name)
    .IsUnicode(false);

Konfigurieren des Datentyps einer Daten Bank SpalteConfiguring the Data Type of a Database Column

Die hascolumntype -Methode ermöglicht die Zuordnung zu verschiedenen Darstellungen desselben Basistyp.The HasColumnType method enables mapping to different representations of the same basic type. Wenn Sie diese Methode verwenden, können Sie die Daten nicht zur Laufzeit konvertieren.Using this method does not enable you to perform any conversion of the data at run time. Beachten Sie, dass isunicode die bevorzugte Methode zum Festlegen von Spalten auf varchar ist, da dies Daten Bank agnostisch ist.Note that IsUnicode is the preferred way of setting columns to varchar, as it is database agnostic.

modelBuilder.Entity<Department>()   
    .Property(p => p.Name)   
    .HasColumnType("varchar");

Konfigurieren von Eigenschaften für einen komplexen TypConfiguring Properties on a Complex Type

Es gibt zwei Möglichkeiten, skalare Eigenschaften für einen komplexen Typ zu konfigurieren.There are two ways to configure scalar properties on a complex type.

Sie können die-Eigenschaft für complextypeconfiguration aufzurufen.You can call Property on ComplexTypeConfiguration.

modelBuilder.ComplexType<Details>()
    .Property(t => t.Location)
    .HasMaxLength(20);

Sie können auch die Punkt Notation verwenden, um auf eine Eigenschaft eines komplexen Typs zuzugreifen.You can also use the dot notation to access a property of a complex type.

modelBuilder.Entity<OnsiteCourse>()
    .Property(t => t.Details.Location)
    .HasMaxLength(20);

Konfigurieren einer Eigenschaft, die als Token für die vollständige Parallelität verwendet werden sollConfiguring a Property to Be Used as an Optimistic Concurrency Token

Um anzugeben, dass eine Eigenschaft in einer Entität ein Parallelitäts Token darstellt, können Sie entweder das Attribut "-Attribut" oder die iskonaccesscytoken-Methode verwenden.To specify that a property in an entity represents a concurrency token, you can use either the ConcurrencyCheck attribute or the IsConcurrencyToken method.

modelBuilder.Entity<OfficeAssignment>()
    .Property(t => t.Timestamp)
    .IsConcurrencyToken();

Sie können auch die IsRowVersion-Methode verwenden, um die Eigenschaft als Zeilen Version in der Datenbank zu konfigurieren.You can also use the IsRowVersion method to configure the property to be a row version in the database. Wenn die Eigenschaft auf eine Zeilen Version festgelegt wird, wird Sie automatisch als Token für die vollständige Parallelität konfiguriert.Setting the property to be a row version automatically configures it to be an optimistic concurrency token.

modelBuilder.Entity<OfficeAssignment>()
    .Property(t => t.Timestamp)
    .IsRowVersion();

TypzuordnungType Mapping

Angeben, dass eine Klasse ein komplexer Typ istSpecifying That a Class Is a Complex Type

Gemäß der Konvention wird ein Typ, der keinen Primärschlüssel enthält, als komplexer Typ behandelt.By convention, a type that has no primary key specified is treated as a complex type. Es gibt einige Szenarien, in denen Code First einen komplexen Typ nicht erkennt (wenn Sie z. b. über eine Eigenschaft mit dem Namen "ID" verfügen, aber nicht bedeuten, dass es sich um einen Primärschlüssel handelt).There are some scenarios where Code First will not detect a complex type (for example, if you do have a property called ID, but you do not mean for it to be a primary key). In solchen Fällen verwenden Sie die fließende API, um explizit anzugeben, dass ein Typ ein komplexer Typ ist.In such cases, you would use the fluent API to explicitly specify that a type is a complex type.

modelBuilder.ComplexType<Details>();

Angeben, dass kein CLR-Entitätstyp einer Tabelle in der Datenbank zugeordnet werden sollSpecifying Not to Map a CLR Entity Type to a Table in the Database

Im folgenden Beispiel wird gezeigt, wie ein CLR-Typ von der Zuordnung zu einer Tabelle in der-Datenbank ausgeschlossen wird.The following example shows how to exclude a CLR type from being mapped to a table in the database.

modelBuilder.Ignore<OnlineCourse>();

Zuordnung eines Entitäts Typs zu einer bestimmten Tabelle in der DatenbankMapping an Entity Type to a Specific Table in the Database

Alle Eigenschaften der Abteilung werden Spalten in einer Tabelle mit dem Namen T_ Abteilung zugeordnet.All properties of Department will be mapped to columns in a table called t_ Department.

modelBuilder.Entity<Department>()  
    .ToTable("t_Department");

Sie können auch den Schema Namen wie folgt angeben:You can also specify the schema name like this:

modelBuilder.Entity<Department>()  
    .ToTable("t_Department", "school");

Zuordnung der "Tabelle pro Hierarchie"-Vererbung (TPH)Mapping the Table-Per-Hierarchy (TPH) Inheritance

Im TPH-Zuordnungsszenario werden alle Typen in einer Vererbungs Hierarchie einer einzelnen Tabelle zugeordnet.In the TPH mapping scenario, all types in an inheritance hierarchy are mapped to a single table. Eine diskriminatorspalte wird verwendet, um den Typ der einzelnen Zeilen zu identifizieren.A discriminator column is used to identify the type of each row. Wenn Sie Ihr Modell mit Code First erstellen, ist TPH die Standardstrategie für die Typen, die an der Vererbungs Hierarchie teilnehmen.When creating your model with Code First, TPH is the default strategy for the types that participate in the inheritance hierarchy. Standardmäßig wird die diskriminatorspalte der Tabelle mit dem Namen "Diskriminator" hinzugefügt, und der CLR-Typname jedes Typs in der Hierarchie wird für die diskriminatorwerte verwendet.By default, the discriminator column is added to the table with the name “Discriminator” and the CLR type name of each type in the hierarchy is used for the discriminator values. Sie können das Standardverhalten mithilfe der flüssigen API ändern.You can modify the default behavior by using the fluent API.

modelBuilder.Entity<Course>()  
    .Map<Course>(m => m.Requires("Type").HasValue("Course"))  
    .Map<OnsiteCourse>(m => m.Requires("Type").HasValue("OnsiteCourse"));

Zuordnung der "Tabelle pro Typ"-Vererbung (TPT)Mapping the Table-Per-Type (TPT) Inheritance

Im TPT-Zuordnungsszenario werden alle Typen einzelnen Tabellen zugeordnet.In the TPT mapping scenario, all types are mapped to individual tables. Eigenschaften, die nur zu einem Basistyp oder einem abgeleiteten Typ gehören, werden in einer Tabelle gespeichert, die diesem Typ zugeordnet ist.Properties that belong solely to a base type or derived type are stored in a table that maps to that type. Tabellen, die abgeleiteten Typen zugeordnet sind, speichern auch einen Fremdschlüssel, der die abgeleitete Tabelle mit der Basistabelle verbindet.Tables that map to derived types also store a foreign key that joins the derived table with the base table.

modelBuilder.Entity<Course>().ToTable("Course");  
modelBuilder.Entity<OnsiteCourse>().ToTable("OnsiteCourse");

Zuordnung der TPC-Vererbung (Tabelle pro konkrete Klasse)Mapping the Table-Per-Concrete Class (TPC) Inheritance

Im TPC-Zuordnungsszenario werden alle nicht abstrakten Typen in der Hierarchie einzelnen Tabellen zugeordnet.In the TPC mapping scenario, all non-abstract types in the hierarchy are mapped to individual tables. Die Tabellen, die den abgeleiteten Klassen zugeordnet sind, haben keine Beziehung zu der Tabelle, die der Basisklasse in der Datenbank zugeordnet ist.The tables that map to the derived classes have no relationship to the table that maps to the base class in the database. Alle Eigenschaften einer Klasse, einschließlich der geerbten Eigenschaften, werden den Spalten der entsprechenden Tabelle zugeordnet.All properties of a class, including inherited properties, are mapped to columns of the corresponding table.

Ruft die mapinheritedproperties-Methode auf, um jeden abgeleiteten Typ zu konfigurieren.Call the MapInheritedProperties method to configure each derived type. Mapinheritedproperties ordnet alle Eigenschaften, die von der Basisklasse geerbt wurden, neuen Spalten in der Tabelle für die abgeleitete Klasse zu.MapInheritedProperties remaps all properties that were inherited from the base class to new columns in the table for the derived class.

Hinweis

Beachten Sie Folgendes: da die an der TPC-Vererbungs Hierarchie beteiligten Tabellen keinen Primärschlüssel gemeinsam verwenden, gibt es beim Einfügen in Tabellen, die Unterklassen zugeordnet sind, doppelte Entitäts Schlüssel, wenn von der Datenbank generierte Werte mit dem gleichen identitätsseed vorhanden sind.Note that because the tables participating in TPC inheritance hierarchy do not share a primary key there will be duplicate entity keys when inserting in tables that are mapped to subclasses if you have database generated values with the same identity seed. Um dieses Problem zu beheben, können Sie entweder für jede Tabelle einen anderen ursprünglichen Startwert angeben oder die Identität der Primärschlüssel Eigenschaft ausschalten.To solve this problem you can either specify a different initial seed value for each table or switch off identity on the primary key property. Identity ist der Standardwert für ganzzahlige Schlüsseleigenschaften beim Arbeiten mit Code First.Identity is the default value for integer key properties when working with Code First.

modelBuilder.Entity<Course>()
    .Property(c => c.CourseID)
    .HasDatabaseGeneratedOption(DatabaseGeneratedOption.None);

modelBuilder.Entity<OnsiteCourse>().Map(m =>
{
    m.MapInheritedProperties();
    m.ToTable("OnsiteCourse");
});

modelBuilder.Entity<OnlineCourse>().Map(m =>
{
    m.MapInheritedProperties();
    m.ToTable("OnlineCourse");
});

Zuordnung von Eigenschaften eines Entitäts Typs zu mehreren Tabellen in der Datenbank (Entitäts Aufteilung)Mapping Properties of an Entity Type to Multiple Tables in the Database (Entity Splitting)

Durch die Entitäts Aufteilung können die Eigenschaften eines Entitäts Typs auf mehrere Tabellen verteilt werden.Entity splitting allows the properties of an entity type to be spread across multiple tables. Im folgenden Beispiel ist die Abteilungs Entität in zwei Tabellen aufgeteilt: Department und departmentdetails.In the following example, the Department entity is split into two tables: Department and DepartmentDetails. Bei der Entitäts Aufteilung werden mehrere Aufrufe der Map-Methode verwendet, um einer bestimmten Tabelle eine Teilmenge von Eigenschaften zuzuordnen.Entity splitting uses multiple calls to the Map method to map a subset of properties to a specific table.

modelBuilder.Entity<Department>()
    .Map(m =>
    {
        m.Properties(t => new { t.DepartmentID, t.Name });
        m.ToTable("Department");
    })
    .Map(m =>
    {
        m.Properties(t => new { t.DepartmentID, t.Administrator, t.StartDate, t.Budget });
        m.ToTable("DepartmentDetails");
    });

Zuordnung mehrerer Entitäts Typen zu einer Tabelle in der Datenbank (Tabellen Aufteilung)Mapping Multiple Entity Types to One Table in the Database (Table Splitting)

Im folgenden Beispiel werden zwei Entitäts Typen, die einen Primärschlüssel gemeinsam verwenden, einer Tabelle zugeordnet.The following example maps two entity types that share a primary key to one table.

modelBuilder.Entity<OfficeAssignment>()
    .HasKey(t => t.InstructorID);

modelBuilder.Entity<Instructor>()
    .HasRequired(t => t.OfficeAssignment)
    .WithRequiredPrincipal(t => t.Instructor);

modelBuilder.Entity<Instructor>().ToTable("Instructor");

modelBuilder.Entity<OfficeAssignment>().ToTable("Instructor");

Zuordnung eines Entitäts Typs zu gespeicherten Prozeduren zum Einfügen/Aktualisieren/Löschen (EF6 oder höher)Mapping an Entity Type to Insert/Update/Delete Stored Procedures (EF6 onwards)

Beginnend mit EF6 können Sie eine Entität zuordnen, um gespeicherte Prozeduren für Insert Update und DELETE zu verwenden.Starting with EF6 you can map an entity to use stored procedures for insert update and delete. Weitere Informationen finden Sie unter Code First gespeicherten Prozeduren INSERT/UPDATE/DELETE.For more details see, Code First Insert/Update/Delete Stored Procedures.

In Beispielen verwendetes ModellModel Used in Samples

Das folgende Code First Modell wird für die Beispiele auf dieser Seite verwendet.The following Code First model is used for the samples on this page.

using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions;
// add a reference to System.ComponentModel.DataAnnotations DLL
using System.ComponentModel.DataAnnotations;
using System.Collections.Generic;
using System;

public class SchoolEntities : DbContext
{
    public DbSet<Course> Courses { get; set; }
    public DbSet<Department> Departments { get; set; }
    public DbSet<Instructor> Instructors { get; set; }
    public DbSet<OfficeAssignment> OfficeAssignments { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // Configure Code First to ignore PluralizingTableName convention
        // If you keep this convention then the generated tables will have pluralized names.
        modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
    }
}

public class Department
{
    public Department()
    {
        this.Courses = new HashSet<Course>();
    }
    // Primary key
    public int DepartmentID { get; set; }
    public string Name { get; set; }
    public decimal Budget { get; set; }
    public System.DateTime StartDate { get; set; }
    public int? Administrator { get; set; }

    // Navigation property
    public virtual ICollection<Course> Courses { get; private set; }
}

public class Course
{
    public Course()
    {
        this.Instructors = new HashSet<Instructor>();
    }
    // Primary key
    public int CourseID { get; set; }

    public string Title { get; set; }
    public int Credits { get; set; }

    // Foreign key
    public int DepartmentID { get; set; }

    // Navigation properties
    public virtual Department Department { get; set; }
    public virtual ICollection<Instructor> Instructors { get; private set; }
}

public partial class OnlineCourse : Course
{
    public string URL { get; set; }
}

public partial class OnsiteCourse : Course
{
    public OnsiteCourse()
    {
        Details = new Details();
    }

    public Details Details { get; set; }
}

public class Details
{
    public System.DateTime Time { get; set; }
    public string Location { get; set; }
    public string Days { get; set; }
}

public class Instructor
{
    public Instructor()
    {
        this.Courses = new List<Course>();
    }

    // Primary key
    public int InstructorID { get; set; }
    public string LastName { get; set; }
    public string FirstName { get; set; }
    public System.DateTime HireDate { get; set; }

    // Navigation properties
    public virtual ICollection<Course> Courses { get; private set; }
}

public class OfficeAssignment
{
    // Specifying InstructorID as a primary
    [Key()]
    public Int32 InstructorID { get; set; }

    public string Location { get; set; }

    // When Entity Framework sees Timestamp attribute
    // it configures ConcurrencyCheck and DatabaseGeneratedPattern=Computed.
    [Timestamp]
    public Byte[] Timestamp { get; set; }

    // Navigation property
    public virtual Instructor Instructor { get; set; }
}