Co oznacza główny koniec powiązania w relacji 1: 1 w ramach jednostki

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

Próbowałem to zrobić w Entity Framework, gdy otrzymałem błąd:

Nie można określić głównego końca powiązania między typami „ConsoleApplication5.Boo” i „ConsoleApplication5.Foo”. Główny koniec tego powiązania musi zostać jawnie skonfigurowany przy użyciu interfejsu API płynnego dla relacji lub adnotacji danych.

Widziałem pytania dotyczące StackOverflow z rozwiązaniem tego błędu, ale chcę zrozumieć, co oznacza termin „główny koniec”.

W relacji jeden do jednego jeden koniec musi być główny, a drugi koniec musi być zależny. Główny koniec to ten, który zostanie wstawiony jako pierwszy i który może istnieć bez zależnego. Koniec zależny to taki, który należy wstawić za zleceniodawcą, ponieważ ma on klucz obcy do zleceniodawcy.

W przypadku struktury jednostki FK zależna musi być również jej PK, więc w twoim przypadku powinieneś użyć:

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

Lub płynne mapowanie

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

[Required]Aby rozwiązać ten problem, możesz również użyć atrybutu adnotacji danych:

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

Foojest wymagane dla Boo.

Odnosi się to do odpowiedzi @Ladislav Mrnka na używanie płynnego interfejsu API do konfigurowania relacji jeden do jednego.

Miałem sytuację, w której posiadanie FK of dependent must be it's PKbyło niemożliwe.

Np. FooMa już relację jeden do wielu 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;
}

Teraz musieliśmy dodać kolejną relację jeden do jednego między Foo i Barem.

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

Oto jak określić relację jeden do jednego za pomocą płynnego interfejsu API:

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

Pamiętaj, że podczas dodawania PrimaryBarIdnależy usunąć, ponieważ określamy go za pomocą płynnego interfejsu API.

Zauważ też, że nazwa metody [WithOptionalPrincipal()][1]jest trochę ironiczna. W tym przypadku Zleceniodawcą jest Bar. Opis WithOptionalDependent () na msdn czyni go bardziej zrozumiałym.