How to Properly Map Two Foreign Keys from the Same Table in Entity Framework Code First?

Entity Framework Code First: Handling Multiple Foreign Keys from a Single Table

This article addresses the challenge of mapping two foreign keys from the same table (e.g., Team) to another table (Match) in Entity Framework Code First. A common error encountered is a cyclical reference exception.

The Problem:

When modeling a Match entity with a HomeTeam and a GuestTeam, both referencing the Team table, a cyclical relationship error often arises. This is because Entity Framework, by default, assumes a one-to-many relationship, leading to a circular dependency.

The Solution:

The key is to explicitly define the relationship as two separate one-to-many relationships from Team to Match. This is achieved by creating two navigation properties within the Team class.

Revised Model:

<code class="language-csharp">public class Team
{
    public int TeamId { get; set; }
    public string Name { get; set; }

    public virtual ICollection<Match> HomeMatches { get; set; }
    public virtual ICollection<Match> AwayMatches { get; set; }
}

public class Match
{
    public int MatchId { get; set; }
    public int HomeTeamId { get; set; }
    public int GuestTeamId { get; set; }
    public float HomePoints { get; set; }
    public float GuestPoints { get; set; }
    public DateTime Date { get; set; }

    public virtual Team HomeTeam { get; set; }
    public virtual Team GuestTeam { get; set; }
}</code>

Notice that Team now has HomeMatches and AwayMatches collections, clearly distinguishing the roles of each team in a match.

Model Configuration (DbContext):

The relationships need to be explicitly defined in the OnModelCreating method of your DbContext class:

<code class="language-csharp">protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Match>()
                .HasRequired(m => m.HomeTeam)
                .WithMany(t => t.HomeMatches)
                .HasForeignKey(m => m.HomeTeamId)
                .WillCascadeOnDelete(false); // Prevent orphan records

    modelBuilder.Entity<Match>()
                .HasRequired(m => m.GuestTeam)
                .WithMany(t => t.AwayMatches)
                .HasForeignKey(m => m.GuestTeamId)
                .WillCascadeOnDelete(false); // Prevent orphan records
}</code>

This configuration explicitly maps the foreign keys and importantly, sets WillCascadeOnDelete(false) to prevent accidental deletion of teams when matches are deleted.

This approach clearly defines the relationships, avoiding the cyclical reference error and providing a robust and maintainable data model.

The above is the detailed content of How to Properly Map Two Foreign Keys from the Same Table in Entity Framework Code First?. For more information, please follow other related articles on the PHP Chinese website!