Que signifie la fin principale d'une association dans une relation 1: 1 dans le cadre Entity

public class Foo
{
    public string FooId{get;set;}
    public Boo Boo{get;set;}
}


public class Boo
{
    public string BooId{get;set;}
    public Foo Foo{get;set;}
}

J'essayais de le faire dans Entity Framework lorsque j'ai eu l'erreur:

Impossible de déterminer la fin principale d'une association entre les types «ConsoleApplication5.Boo» et «ConsoleApplication5.Foo». L'extrémité principale de cette association doit être explicitement configurée à l'aide de l'API fluide de la relation ou des annotations de données.

J'ai vu des questions sur StackOverflow avec une solution à cette erreur, mais je veux comprendre ce que signifie le terme "extrémité principale".

Dans une relation un à un, une extrémité doit être principale et la deuxième extrémité doit être dépendante. L'extrémité principale est celle qui sera insérée en premier et qui peut exister sans celle dépendante. La fin dépendante est celle qui doit être insérée après le principal car elle a une clé étrangère au principal.

Dans le cas d'un framework d'entité, FK en dépend doit également être son PK, donc dans votre cas, vous devez utiliser:

public class Boo
{
    [Key, ForeignKey("Foo")]
    public string BooId{get;set;}
    public Foo Foo{get;set;}
}

Ou cartographie courante

modelBuilder.Entity<Foo>()
            .HasOptional(f => f.Boo)
            .WithRequired(s => s.Foo);

Vous pouvez également utiliser l' [Required]attribut d'annotation de données pour résoudre ce problème:

public class Foo
{
    public string FooId { get; set; }

    public Boo Boo { get; set; }
}

public class Boo
{
    public string BooId { get; set; }

    [Required]
    public Foo Foo {get; set; }
}

Fooest requis pour Boo.

Ceci fait référence à la réponse de @Ladislav Mrnka sur l'utilisation d'une API fluide pour configurer la relation un-à-un.

Eu une situation où avoir FK of dependent must be it's PK n'était pas possible.

Par exemple, Foo déjà une relation un-à-plusieurs avec Bar.

public class Foo {
   public Guid FooId;
   public virtual ICollection<> Bars; 
}
public class Bar {
   //PK
   public Guid BarId;
   //FK to Foo
   public Guid FooId;
   public virtual Foo Foo;
}

Maintenant, nous devions ajouter une autre relation un à un entre Foo et Bar.

public class Foo {
   public Guid FooId;
   public Guid PrimaryBarId;// needs to be removed(from entity),as we specify it in fluent api
   public virtual Bar PrimaryBar;
   public virtual ICollection<> Bars;
}
public class Bar {
   public Guid BarId;
   public Guid FooId;
   public virtual Foo PrimaryBarOfFoo;
   public virtual Foo Foo;
}

Voici comment spécifier une relation un-à-un à l'aide d'une API fluide:

modelBuilder.Entity<Bar>()
            .HasOptional(p => p.PrimaryBarOfFoo)
            .WithOptionalPrincipal(o => o.PrimaryBar)
            .Map(x => x.MapKey("PrimaryBarId"));

Notez que tout en ajoutant PrimaryBarIddoit être supprimé, comme nous le spécifions via une API fluide.

Notez également que le nom de la méthode [WithOptionalPrincipal()][1]est assez ironique. Dans ce cas, le principal est Bar. La description de WithOptionalDependent () sur msdn le rend plus clair.