Cosa significa fine principale di un'associazione nella relazione 1: 1 nel framework 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;}
}

Stavo provando a farlo in Entity Framework quando ho ricevuto l'errore:

Impossibile determinare la fine principale di un'associazione tra i tipi "ConsoleApplication5.Boo" e "ConsoleApplication5.Foo". L'estremità principale di questa associazione deve essere configurata esplicitamente utilizzando l'API fluente della relazione o le annotazioni dei dati.

Ho visto domande su StackOverflow con una soluzione per questo errore, ma voglio capire cosa significa il termine "fine principale".

Nella relazione uno a uno un'estremità deve essere principale e la seconda estremità deve essere dipendente. Il fine principale è quello che verrà inserito per primo e che può esistere senza quello dipendente. L'estremità dipendente è quella che deve essere inserita dopo il principale perché ha una chiave esterna per il principale.

Nel caso di framework di entità FK in dipendenza deve essere anche il suo PK, quindi nel tuo caso dovresti usare:

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

O mappatura fluida

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

Puoi anche usare l' [Required]attributo di annotazione dei dati per risolvere questo:

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è richiesto per Boo.

Questo è in riferimento alla risposta di @Ladislav Mrnka sull'uso di API fluenti per la configurazione della relazione uno a uno.

Ha avuto una situazione in cui FK of dependent must be it's PKnon era fattibile.

Ad esempio, Fooha già una relazione uno-a-molti con 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;
}

Ora, abbiamo dovuto aggiungere un'altra relazione uno a uno tra Foo e 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;
}

Ecco come specificare una relazione uno a uno usando api fluente:

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

Si noti che durante l'aggiunta PrimaryBarIddeve essere rimosso, poiché lo specifichiamo tramite API fluente.

Si noti inoltre che il nome del metodo [WithOptionalPrincipal()][1]è un po 'ironico. In questo caso, Principal è Bar. La descrizione WithOptionalDependent () su msdn lo rende più chiaro.