Comment cartographier correctement deux clés étrangères à partir du même tableau du code Framework Entity Framework en premier?

Code du framework Entity First: Gestion de plusieurs clés étrangères à partir d'une seule table

Cet article relève le défi de cartographier deux clés étrangères de la même table (par exemple, Team) à une autre table (Match) dans le code du framework d'entité. Une erreur commune rencontrée est une exception de référence cyclique.

Le problème:

Lors de la modélisation d'une entité Match avec un HomeTeam et un GuestTeam, les deux faisant référence au tableau Team, une erreur de relation cyclique survient souvent. En effet, Entity Framework, par défaut, suppose une relation un-à-plusieurs, conduisant à une dépendance circulaire.

La solution:

La clé est de définir explicitement la relation comme deux relations un à plusieurs distinctes de Team à Match. Ceci est réalisé en créant deux propriétés de navigation au sein de la classe Team.

Modèle révisé:

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

Notez que Team a maintenant des collections HomeMatches et AwayMatches, distinguant clairement les rôles de chaque équipe dans un match.

Configuration du modèle (dbContext):

Les relations doivent être définies explicitement dans la méthode OnModelCreating de votre classe DbContext:

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

Cette configuration mappe explicitement les clés étrangères et, surtout, définit WillCascadeOnDelete(false) pour éviter la suppression accidentelle des équipes lorsque les matchs sont supprimés.

Cette approche définit clairement les relations, en évitant l'erreur de référence cyclique et en fournissant un modèle de données robuste et maintenable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!