web-dev-qa-db-fra.com

Que signifie le terme principal d'une association dans une relation 1: 1 dans un cadre d'entité?

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 faire cela dans Entity Framework quand j'ai eu l'erreur:

Impossible de déterminer l'extrémité 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 la relation API couramment utilisée 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 "fin principale".

c#entity-frameworkdatabase-designforeign-key-relationship
263
taher chhabrawala

Dans une relation un à un, une extrémité doit être principale et la seconde extrémité doit être dépendante. La fin principale est celle qui sera insérée en premier et qui peut exister sans la personne 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 de la structure d'entité, FK in dépend doit également être sa PK. Dans ce cas, vous devez utiliser:

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

Ou cartographie fluide

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

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

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

Foo est requis pour Boo.

178
Leniel Maccaferri

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

Avait eu une situation où FK of dependent must be it's PK n'était pas réalisable.

Par exemple, Foo a 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 en utilisant un api fluide:

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

Notez que bien que l'ajout de PrimaryBarId doive ê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. WithOptionalDependent () la description de msdn rend les choses plus claires.

5
Sudarshan_SMD