BeziehungenRelationships

Eine Beziehung definiert, wie zwei Entitäten miteinander verknüpfen.A relationship defines how two entities relate to each other. In einer relationalen Datenbank wird dies durch eine foreign Key-Einschränkung dargestellt.In a relational database, this is represented by a foreign key constraint.

Hinweis

Die meisten Beispiele in diesem Artikel verwenden Sie eine 1: n Beziehung zur Veranschaulichung der Konzepte.Most of the samples in this article use a one-to-many relationship to demonstrate concepts. Weitere Beispiele für 1: 1- und m: n Beziehungen finden Sie unter den andere Beziehung Muster Abschnitt am Ende des Artikels.For examples of one-to-one and many-to-many relationships see the Other Relationship Patterns section at the end of the article.

BegriffsdefinitionDefinition of Terms

Es gibt eine Reihe von Begriffen verwendet, um Beziehungen zu beschreibenThere are a number of terms used to describe relationships

  • Abhängige Entität: Dies ist die Entität, die Fremdschlüsseleigenschaften enthält.Dependent entity: This is the entity that contains the foreign key property(s). Manchmal bezeichnet als "untergeordnetes" der Beziehung.Sometimes referred to as the 'child' of the relationship.

  • Prinzipalentität: Dies ist die Entität, die bzw. der alternativen primären Schlüsseleigenschaften enthält.Principal entity: This is the entity that contains the primary/alternate key property(s). Manchmal bezeichnet als "Parent" der Beziehung.Sometimes referred to as the 'parent' of the relationship.

  • Fremdschlüssel: der dazugehörigen Eigenschaften in der abhängigen Entität, die verwendet wird, um die Werte der Schlüsseleigenschaft Prinzipal zu speichern, die mit die Entität verknüpft ist.Foreign key: The property(s) in the dependent entity that is used to store the values of the principal key property that the entity is related to.

  • Prinzipalschlüssel: der Eigenschaften, die die prinzipalentität eindeutig identifiziert.Principal key: The property(s) that uniquely identifies the principal entity. Dies kann der Primärschlüssel oder einen alternativen Schlüssel sein.This may be the primary key or an alternate key.

  • Navigationseigenschaft: eine Eigenschaft, die in der principal und/oder abhängige Entität, die enthält einen Verweise auf die entsprechenden Entity(s) definiert.Navigation property: A property defined on the principal and/or dependent entity that contains a reference(s) to the related entity(s).

    • Auflistungsnavigationseigenschaft: eine Navigationseigenschaft, die Verweise auf viele verknüpfte Entitäten enthält.Collection navigation property: A navigation property that contains references to many related entities.

    • Verweisnavigationseigenschaft: eine Navigationseigenschaft, die einen Verweis auf eine einzelne verknüpfte Entität enthält.Reference navigation property: A navigation property that holds a reference to a single related entity.

    • Inverse-Navigationseigenschaft: im Zusammenhang mit eine bestimmten Navigationseigenschaft dieser Begriff bezieht sich, auf die Navigationseigenschaft am anderen Ende der Beziehung.Inverse navigation property: When discussing a particular navigation property, this term refers to the navigation property on the other end of the relationship.

Das folgende Codebeispiel veranschaulicht eine 1: n Beziehung zwischen Blog und PostThe following code listing shows a one-to-many relationship between Blog and Post

  • Post die abhängige EntitätPost is the dependent entity

  • Blog ist die prinzipalentitätBlog is the principal entity

  • Post.BlogId ist der FremdschlüsselPost.BlogId is the foreign key

  • Blog.BlogId der prinzipalschlüssel (in diesem Fall ist es ein primärer Schlüssel anstelle eines alternativen Schlüssels)Blog.BlogId is the principal key (in this case it is a primary key rather than an alternate key)

  • Post.Blog ist eine verweisnavigationseigenschaftPost.Blog is a reference navigation property

  • Blog.Posts ist eine auflistungsnavigationseigenschaftBlog.Posts is a collection navigation property

  • Post.Blog ist die umgekehrte Navigationseigenschaft des Blog.Posts (und umgekehrt)Post.Blog is the inverse navigation property of Blog.Posts (and vice versa)

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

    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

KonventionenConventions

Gemäß der Konvention wird eine Beziehung erstellt werden, wenn eine Navigationseigenschaft, die ermittelt, die für einen Typ vorhanden ist.By convention, a relationship will be created when there is a navigation property discovered on a type. Eine Eigenschaft gilt eine Navigationseigenschaft, wenn der Typ, auf die verwiesen, durch den aktuellen Anbieter nicht als ein skalarer Typ zugeordnet werden kann.A property is considered a navigation property if the type it points to can not be mapped as a scalar type by the current database provider.

Hinweis

Beziehungen, die gemäß der Konvention ermittelt werden, werden immer den Primärschlüssel der prinzipalentität Ziel.Relationships that are discovered by convention will always target the primary key of the principal entity. Um einen alternativen Schlüssel als Ziel verwenden, muss zusätzliche Konfigurationsschritte mithilfe der Fluent-API ausgeführt werden.To target an alternate key, additional configuration must be performed using the Fluent API.

Vollständig definierten BeziehungenFully Defined Relationships

Das bekannteste Muster für Beziehungen werden Navigationseigenschaften, die definiert, die an beiden Enden der Beziehung und eine Fremdschlüsseleigenschaft in der abhängigen Entität-Klasse definiert haben.The most common pattern for relationships is to have navigation properties defined on both ends of the relationship and a foreign key property defined in the dependent entity class.

  • Wenn ein Paar von Navigationseigenschaften zwischen zwei Typen gefunden wird, werden sie als umgekehrte Navigationseigenschaften, die von der gleichen Beziehung konfiguriert werden.If a pair of navigation properties is found between two types, then they will be configured as inverse navigation properties of the same relationship.

  • Wenn die abhängige Entität eine Eigenschaft namens enthält <primary key property name>, <navigation property name><primary key property name>, oder <principal entity name><primary key property name> als Fremdschlüssel so konfiguriert werden, wird.If the dependent entity contains a property named <primary key property name>, <navigation property name><primary key property name>, or <principal entity name><primary key property name> then it will be configured as the foreign key.

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

    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

Warnung

Treten mehrere Navigationseigenschaften, die zwischen zwei Arten definiert (d. h. mehrere unterschiedliche Paar von Navigationen, die auf den jeweils anderen verweisen), gemäß der Konvention werden dann keine Beziehungen erstellt werden, und Sie müssen manuell konfigurieren, um sich zu identifizieren wie die Navigationseigenschaften, kombinieren Sie.If there are multiple navigation properties defined between two types (that is, more than one distinct pair of navigations that point to each other), then no relationships will be created by convention and you will need to manually configure them to identify how the navigation properties pair up.

Keine Foreign Key-EigenschaftNo Foreign Key Property

Zwar wird empfohlen, eine Fremdschlüsseleigenschaft in der abhängigen Entität-Klasse definiert haben, ist es nicht erforderlich.While it is recommended to have a foreign key property defined in the dependent entity class, it is not required. Wenn keine foreign Key-Eigenschaft gefunden wird, wird eine Fremdschlüsseleigenschaft Volumeschattenkopie eingeführt werden, mit dem Namen <navigation property name><principal key property name> (finden Sie unter Schatteneigenschaften Informationen).If no foreign key property is found, a shadow foreign key property will be introduced with the name <navigation property name><principal key property name> (see Shadow Properties for more information).

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

    public Blog Blog { get; set; }
}

Einzelne NavigationseigenschaftSingle Navigation Property

Nur eine Navigationseigenschaft (keine umgekehrte Navigation und keine Fremdschlüsseleigenschaft) einschließlich ist ausreichend, um eine Beziehung, die gemäß der Konvention definiert haben.Including just one navigation property (no inverse navigation, and no foreign key property) is enough to have a relationship defined by convention. Sie können auch die Möglichkeit, eine einzelne Navigationseigenschaft und eine Fremdschlüsseleigenschaft haben.You can also have a single navigation property and a foreign key property.

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

Kaskadierendes DeleteCascade Delete

Gemäß der Konvention Löschweitergabe festgelegt Cascade für erforderliche Beziehungen und ClientSetNull für optionale Beziehungen.By convention, cascade delete will be set to Cascade for required relationships and ClientSetNull for optional relationships. CASCADE bedeutet, dass abhängige Entitäten werden ebenfalls gelöscht.Cascade means dependent entities are also deleted. ClientSetNull bedeutet, der abhängigen Entitäten, die nicht in den Speicher geladen bleibt unverändert und müssen manuell gelöscht oder aktualisiert, um auf eine gültige Prinzipal Entität verweisen.ClientSetNull means that dependent entities that are not loaded into memory will remain unchanged and must be manually deleted, or updated to point to a valid principal entity. Für Entitäten, die in den Arbeitsspeicher geladen werden, versucht EF Core, die die foreign Key-Eigenschaften auf null festgelegt.For entities that are loaded into memory, EF Core will attempt to set the foreign key properties to null.

Finden Sie unter den erforderlichen und optionalen Beziehungen Abschnitt für den Unterschied zwischen erforderlichen und optionalen Beziehungen.See the Required and Optional Relationships section for the difference between required and optional relationships.

Finden Sie unter Löschweitergabe für Weitere Informationen zu den verschiedenen Verhalten und die Standardwerte, die gemäß der Konvention verwendet löschen.See Cascade Delete for more details about the different delete behaviors and the defaults used by convention.

DatenanmerkungenData Annotations

Es gibt zwei datenanmerkungen, die verwendet werden können, so konfigurieren Sie Beziehungen, [ForeignKey] und [InverseProperty].There are two data annotations that can be used to configure relationships, [ForeignKey] and [InverseProperty].

[ForeignKey][ForeignKey]

Sie können die Datenanmerkungen verwenden, so konfigurieren Sie die Eigenschaft als die Fremdschlüsseleigenschaft für eine bestimmte Beziehung verwendet werden soll.You can use the Data Annotations to configure which property should be used as the foreign key property for a given relationship. Dies erfolgt normalerweise, wenn die Fremdschlüsseleigenschaft nicht gemäß der Konvention ermittelt wird.This is typically done when the foreign key property is not discovered by convention.

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

    public int BlogForeignKey { get; set; }

    [ForeignKey("BlogForeignKey")]
    public Blog Blog { get; set; }
}

Tipp

Die [ForeignKey] Anmerkung in beiden Navigationseigenschaft in der Beziehung platziert werden kann.The [ForeignKey] annotation can be placed on either navigation property in the relationship. Es muss nicht für die Navigationseigenschaft in der abhängigen Entität-Klasse zu wechseln.It does not need to go on the navigation property in the dependent entity class.

[InverseProperty][InverseProperty]

Sie können die Datenanmerkungen verwenden, konfigurieren, wie Navigationseigenschaften für Entitäten abhängigen und der Prinzipaleigenschaft kombinieren Sie.You can use the Data Annotations to configure how navigation properties on the dependent and principal entities pair up. Dies erfolgt normalerweise, wenn mehr als ein Paar von Navigationseigenschaften zwischen zwei Entitätstypen vorhanden ist.This is typically done when there is more than one pair of navigation properties between two entity types.

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

    public int AuthorUserId { get; set; }
    public User Author { get; set; }

    public int ContributorUserId { get; set; }
    public User Contributor { get; set; }
}

public class User
{
    public string UserId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    [InverseProperty("Author")]
    public List<Post> AuthoredPosts { get; set; }

    [InverseProperty("Contributor")]
    public List<Post> ContributedToPosts { get; set; }
}

Fluent-APIFluent API

Um eine Beziehung in der Fluent-API zu konfigurieren, starten Sie durch das Identifizieren der Navigationseigenschaften, die die Beziehung bilden.To configure a relationship in the Fluent API, you start by identifying the navigation properties that make up the relationship. HasOne oder HasMany identifiziert die Navigationseigenschaft für den Entitätstyp, der Sie die Konfiguration ab.HasOne or HasMany identifies the navigation property on the entity type you are beginning the configuration on. Sie verketten, klicken Sie dann einen Aufruf von WithOne oder WithMany die umgekehrte Navigation zu identifizieren.You then chain a call to WithOne or WithMany to identify the inverse navigation. HasOne/WithOne werden verwendet, für die verweisnavigationseigenschaften und HasMany / WithMany werden für Navigationseigenschaften für Auflistungen verwendet.HasOne/WithOne are used for reference navigation properties and HasMany/WithMany are used for collection navigation properties.

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts);
    }
}

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

    public Blog Blog { get; set; }
}

Einzelne NavigationseigenschaftSingle Navigation Property

Wenn Sie nur eine Navigationseigenschaft stehen die parameterlose Überladung von WithOne und WithMany.If you only have one navigation property then there are parameterless overloads of WithOne and WithMany. Dies bedeutet, dass im Prinzip ein Verweis oder eine Auflistung am anderen Ende der Beziehung vorhanden ist, aber es keine Navigationseigenschaft, die in der Entitätsklasse enthalten gibt.This indicates that there is conceptually a reference or collection on the other end of the relationship, but there is no navigation property included in the entity class.

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .HasMany(b => b.Posts)
            .WithOne();
    }
}

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

FremdschlüsselForeign Key

Sie können die Fluent-API verwenden, so konfigurieren Sie die Eigenschaft als die Fremdschlüsseleigenschaft für eine bestimmte Beziehung verwendet werden soll.You can use the Fluent API to configure which property should be used as the foreign key property for a given relationship.

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .HasForeignKey(p => p.BlogForeignKey);
    }
}

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

    public int BlogForeignKey { get; set; }
    public Blog Blog { get; set; }
}

Das folgende Codebeispiel veranschaulicht einen zusammengesetzten Fremdschlüssel zu konfigurieren.The following code listing shows how to configure a composite foreign key.

class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Car>()
            .HasKey(c => new { c.State, c.LicensePlate });

        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => new { s.CarState, s.CarLicensePlate });
    }
}

public class Car
{
    public string State { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public List<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarState { get; set; }
    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}

Können Sie die zeichenfolgenüberladung von HasForeignKey(...) so konfigurieren Sie eine schatteneigenschaft als Fremdschlüssel (finden Sie unter Schatteneigenschaften Informationen).You can use the string overload of HasForeignKey(...) to configure a shadow property as a foreign key (see Shadow Properties for more information). Es wird empfohlen, das Modell explizit die Shadow-Eigenschaft hinzugefügt werden, bevor es als Fremdschlüssel verwendet wird (siehe unten).We recommend explicitly adding the shadow property to the model before using it as a foreign key (as shown below).

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Add the shadow property to the model
        modelBuilder.Entity<Post>()
            .Property<int>("BlogForeignKey");

        // Use the shadow property as a foreign key
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .HasForeignKey("BlogForeignKey");
    }
}

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

    public Blog Blog { get; set; }
}

DienstprinzipalschlüsselPrincipal Key

Wenn Sie den Fremdschlüssel auf eine Eigenschaft als Primärschlüssel verweisen möchten, können Sie die Fluent-API, so konfigurieren Sie die wichtigsten Prinzipaleigenschaft für die Beziehung.If you want the foreign key to reference a property other than the primary key, you can use the Fluent API to configure the principal key property for the relationship. Die Eigenschaft, die Sie als Prinzipal Schlüssel wird automatisch konfigurieren, werden Setup als alternativer Schlüssel (finden Sie unter Alternativschlüssel Informationen).The property that you configure as the principal key will automatically be setup as an alternate key (see Alternate Keys for more information).

class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => s.CarLicensePlate)
            .HasPrincipalKey(c => c.LicensePlate);
    }
}

public class Car
{
    public int CarId { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public List<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}

Das folgende Codebeispiel zeigt einen zusammengesetzten Schlüssel für Prinzipal zu konfigurieren.The following code listing shows how to configure a composite principal key.

class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => new { s.CarState, s.CarLicensePlate })
            .HasPrincipalKey(c => new { c.State, c.LicensePlate });
    }
}

public class Car
{
    public int CarId { get; set; }
    public string State { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public List<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarState { get; set; }
    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}

Warnung

Die Reihenfolge, in der Sie wichtige prinzipaleigenschaften angeben, muss der Reihenfolge entsprechen, in der sie für den Fremdschlüssel angegeben sind.The order in which you specify principal key properties must match the order in which they are specified for the foreign key.

Erforderliche und optionale BeziehungenRequired and Optional Relationships

Sie können die Fluent-API verwenden, konfigurieren Sie, ob die Beziehung erforderlich oder optional ist.You can use the Fluent API to configure whether the relationship is required or optional. Letzten Endes steuert, ob die Fremdschlüsseleigenschaft erforderlich oder optional ist.Ultimately this controls whether the foreign key property is required or optional. Dies ist besonders hilfreich, wenn Sie einen Fremdschlüssel für die Schattenkopien Zustand verwenden.This is most useful when you are using a shadow state foreign key. Wenn Sie eine Fremdschlüsseleigenschaft in Ihrer Entitätsklasse verfügen, und klicken Sie dann die Requiredness der Beziehung bestimmt wird, je nachdem, ob die Fremdschlüsseleigenschaft erforderlich oder optional ist (finden Sie unter erforderliche und optionale Eigenschaften Weitere (Informationen).If you have a foreign key property in your entity class then the requiredness of the relationship is determined based on whether the foreign key property is required or optional (see Required and Optional properties for more information).

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .IsRequired();
    }
}

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

    public Blog Blog { get; set; }
}

Kaskadierendes DeleteCascade Delete

Sie können die Fluent-API verwenden, das Cascade Löschverhalten für eine bestimmte Beziehung explizit zu konfigurieren.You can use the Fluent API to configure the cascade delete behavior for a given relationship explicitly.

Finden Sie unter Löschweitergabe im Abschnitt Speichern von Daten für eine detaillierte Erläuterung der einzelnen Optionen.See Cascade Delete on the Saving Data section for a detailed discussion of each option.

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .OnDelete(DeleteBehavior.Cascade);
    }
}

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

    public int? BlogId { get; set; }
    public Blog Blog { get; set; }
}

Andere Beziehung-MusterOther Relationship Patterns

1: 1One-to-one

1: 1-Beziehungen haben einer verweisnavigationseigenschaft auf beiden Seiten.One to one relationships have a reference navigation property on both sides. Folgen sie die gleichen Konventionen wie 1: n Beziehungen, aber ein eindeutiger Index wird eingeführt, auf die Fremdschlüsseleigenschaft, um sicherzustellen, dass nur eine abhängige, der jedem Prinzipal verknüpft ist.They follow the same conventions as one-to-many relationships, but a unique index is introduced on the foreign key property to ensure only one dependent is related to each principal.

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

    public BlogImage BlogImage { get; set; }
}

public class BlogImage
{
    public int BlogImageId { get; set; }
    public byte[] Image { get; set; }
    public string Caption { get; set; }

    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

Hinweis

EF wählt eine der Entitäten, die basierend auf der Fähigkeit zum Erkennen von Fremdschlüsseleigenschaften abhängig sein.EF will choose one of the entities to be the dependent based on its ability to detect a foreign key property. Wenn die falsche Entität als die abhängigen ausgewählt wird, können Sie die Fluent-API, um dies zu korrigieren.If the wrong entity is chosen as the dependent, you can use the Fluent API to correct this.

Wenn Sie die Beziehung mit der Fluent-API konfigurieren möchten, verwenden Sie die HasOne und WithOne Methoden.When configuring the relationship with the Fluent API, you use the HasOne and WithOne methods.

Wenn die foreign Key konfigurieren, Sie den abhängige Entitätstyp - angeben müssen, beachten Sie den generischen Parameter bereitgestellt, um HasForeignKey in der folgenden Liste.When configuring the foreign key you need to specify the dependent entity type - notice the generic parameter provided to HasForeignKey in the listing below. In einer 1: n Beziehung wird deutlich, dass die Entität mit dem die Navigation Verweis des abhängigen und der Auftrag mit dem die Auflistung der Prinzipal ist.In a one-to-many relationship it is clear that the entity with the reference navigation is the dependent and the one with the collection is the principal. Dies ist jedoch nicht in einer 1: 1-Beziehung – daher so müssen sie explizit zu definieren.But this is not so in a one-to-one relationship - hence the need to explicitly define it.

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

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .HasOne(p => p.BlogImage)
            .WithOne(i => i.Blog)
            .HasForeignKey<BlogImage>(b => b.BlogForeignKey);
    }
}

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

    public BlogImage BlogImage { get; set; }
}

public class BlogImage
{
    public int BlogImageId { get; set; }
    public byte[] Image { get; set; }
    public string Caption { get; set; }

    public int BlogForeignKey { get; set; }
    public Blog Blog { get; set; }
}

M: nMany-to-many

M: n Beziehungen ohne eine Entitätsklasse zur Darstellung der Jointabelle werden noch nicht unterstützt.Many-to-many relationships without an entity class to represent the join table are not yet supported. Allerdings können Sie eine m: n Beziehung darstellen, durch Einschließen einer Entitätsklasse für die Jointabelle und die Zuordnung zwei separate 1: n Beziehungen.However, you can represent a many-to-many relationship by including an entity class for the join table and mapping two separate one-to-many relationships.

class MyContext : DbContext
{
    public DbSet<Post> Posts { get; set; }
    public DbSet<Tag> Tags { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<PostTag>()
            .HasKey(t => new { t.PostId, t.TagId });

        modelBuilder.Entity<PostTag>()
            .HasOne(pt => pt.Post)
            .WithMany(p => p.PostTags)
            .HasForeignKey(pt => pt.PostId);

        modelBuilder.Entity<PostTag>()
            .HasOne(pt => pt.Tag)
            .WithMany(t => t.PostTags)
            .HasForeignKey(pt => pt.TagId);
    }
}

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

    public List<PostTag> PostTags { get; set; }
}

public class Tag
{
    public string TagId { get; set; }

    public List<PostTag> PostTags { get; set; }
}

public class PostTag
{
    public int PostId { get; set; }
    public Post Post { get; set; }

    public string TagId { get; set; }
    public Tag Tag { get; set; }
}