Bei Verwendung von Entity Framework Code First 4.3.1 ist es möglich, Beziehungen mit einer Vielzahl von 1 zu 1 zu erstellen. Das heißt, eine Entität an jedem Ende der Beziehung.

Es ist möglich, 1-zu-1-Beziehungen zu konfigurierenerforderlich erforderlich odererforderlich-optional ^. Wenn ich jedoch zwischen den beiden umschalte, sehe ich keine Unterschiede in:

Das generierte Datenbankschema. Ich beziehe mich auf SQL Server 2008.Das Laufzeitverhalten von EF.

Als solches bin ich in der Lage, eineRequiredPrincipalAs aufnehmen ohne ein entsprechendesRequiredDependentAs aufzeichnen, obwohl die Beziehung als konfiguriert isterforderlich erforderlich. Dies scheint der Dokumentation zu widersprechenHasRequired (...):

Konfiguriert eine erforderliche Beziehung aus diesem Entitätstyp. Instanzen des Entitätstyps können nur in der Datenbank gespeichert werden, wenn diese Beziehung angegeben ist. Der Fremdschlüssel in der Datenbank kann nicht auf Null gesetzt werden.

http://msdn.microsoft.com/en-us/library/gg671317

Daserforderlich erforderlich Beziehungseinheiten:

public class RequiredPrincipalA
{
    public int Id { get; set; }
    public virtual RequiredDependentA DependentA { get; set; }
}

public class RequiredDependentA
{
    public int Id { get; set; }
    public virtual RequiredPrincipalA PrincipalA { get; set; }
}

Daserforderlich-optional Beziehungseinheiten:

public class RequiredPrincipalB
{
    public int Id { get; set; }
    public virtual OptionalDependentB DependentB { get; set; }
}

public class OptionalDependentB
{
    public int Id { get; set; }
    public virtual RequiredPrincipalB PrincipalB { get; set; }
}

Die DbContext- und Modellkonfiguration:

public class AppContext : DbContext
{
    public DbSet<RequiredPrincipalA> PrincipalAs { get; set; }
    public DbSet<RequiredDependentA> DependentAs { get; set; }

    public DbSet<RequiredPrincipalB> PrincipalBs { get; set; }
    public DbSet<OptionalDependentB> DependentBs { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<RequiredPrincipalA>()
            .HasRequired(o => o.DependentA)
            .WithRequiredPrincipal(o => o.PrincipalA);

        modelBuilder.Entity<RequiredPrincipalB>()
            .HasOptional(o => o.DependentB)
            .WithRequired(o => o.PrincipalB);
    }
}

Der Testcode:

Database.SetInitializer(new DropCreateDatabaseAlways<AppContext>());

using (var ctx = new AppContext())
{
    ctx.Database.Initialize(force: false);

    ctx.PrincipalAs.Add(new RequiredPrincipalA());
    ctx.PrincipalBs.Add(new RequiredPrincipalB());

    ctx.SaveChanges();
}

Mir ist bewusst, dass ich eine hinzufügen könnte[Erforderlich] Datenattribut zu den Navigationseigenschaften vonRequiredPrincipalA.DependentA undRequiredDependentA.PrincipalA. Dies würde dazu führen, dass die EF-Validierung das oben beschriebene Szenario verhindert. Ich möchte dies jedoch nicht tun, da dadurch auch überprüft wird, ob die Navigationseigenschaft beim Aktualisieren einer vorhandenen Entität ausgefüllt wird. Dies bedeutet, dass die Anwendung bei jeder Aktualisierung die Entität am anderen Ende der Beziehung vorabholen muss.

Warum sehe ich keinen Unterschied im Verhalten von EF, nur wenn ich eine Beziehung ändere zwischenerforderlich erforderlich underforderlich-optional?

^ Beachten Sie, dass optional-optional ebenfalls unterstützt wird, dies jedoch nicht Teil meiner Frage ist. Es gibt offensichtliche Unterschiede im generierten Datenbankschema und im Laufzeitverhalten, wenn eine optional-optionale Beziehung konfiguriert wird.