EF 6.1:

Wir haben gerade ein Projekt gestartet, das viel Vererbung hat. Der ausgewählte Vererbungs-DB-Zuordnungstyp ist die Tabelle pro Hierarchie. Das Problem ist, dass beim Versuch, die Migration mithilfe der Add-Migration zu generieren, der folgende Fehler ausgegeben wird:

The foreign key component 'VersionId' is not a declared property on type 'SER'. Verify that it has not been explicitly excluded from the model and that it is a valid primitive property.

Hier sind die verwendeten Klassen und Konfigurationsklassen:

public class Version : BaseObject
{
    public virtual ICollection<SER> ListOfSER { get; set; }
}

public abstract class AbsractR : BaseObject
{
    public int ParentId { get; set; }
    public int ChildId { get; set; }

    public int VersionId { get; set; }
    public virtual Version Version { get; set; }
}

public class SER : AbstractR
{
    public int SEDId
    {
        get
        {
            return base.ChildId;
        }
        set
        {
            base.ChildId = value;
        }
    }
    public virtual SED SED { get; set; }
}

public abstract class AbstractD : BaseObject
{
}

public class SED : AbstractD
{
    public virtual ICollection<SER> ListOfSER { get; set; }
}


public class SDContext : BaseContext
{
    public DbSet<Version> Versions { get; set; }
    public DbSet<AbstractD> Ds { get; set; }
    public DbSet<AbstractR> Rs { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Configurations.Add(new VersionConfiguration());

        #region Refs
        modelBuilder.Configurations.Add(new AbstractRConfiguration());
        modelBuilder.Configurations.Add(new SERConfiguration());
        #endregion

        #region Defs
        modelBuilder.Configurations.Add(new AbstractDConfiguration());
        modelBuilder.Configurations.Add(new SEDConfiguration());
        #endregion
    }
}

public class BaseObjectConfiguration<T> : EntityTypeConfiguration<T> where T : BaseObject
{
    public BaseObjectConfiguration()
    {
        #region Key
        this.HasKey(bo => bo.Id);
        #endregion

        #region Properties
        this.Property(bo => bo.Id).IsRequired();
        this.Property(bo => bo.IsDeleted).IsRequired();
        this.Property(bo => bo.LastModificationDate).IsOptional();
        this.Property(bo => bo.OptimisticVersion).IsConcurrencyToken().IsRequired().IsRowVersion();
        this.Property(bo => bo.CreationDate).IsRequired();
        this.Property(bo => bo.DeletionDate).IsOptional();
        #endregion
    }
}

public class VersionConfiguration : BaseObjectConfiguration<Version>
{
    public VersionConfiguration() : base()
    {
        #region Properties
        #endregion

        #region Objects
        this.HasMany(mdv => mdv.ListOfSER).WithRequired().HasForeignKey(ser => ser.VersionId).WillCascadeOnDelete(false);
        #endregion

        #region Table
        this.ToTable("Versions");
        #endregion
    }
}

public class AbstractRConfiguration : BaseObjectConfiguration<AbstractR>
{
    public AbstractRConfiguration()
        : base()
    {
        #region Properties
        this.Property(ser => ser.VersionId).IsRequired();
        #endregion

        #region Objects
        this.HasRequired(ar => ar.Version).WithMany().HasForeignKey(ar => ar.VersionId).WillCascadeOnDelete(false);
        #endregion

        #region Table
        this.ToTable("Refs");
        #endregion
    }
}

public class SERConfiguration : BaseObjectConfiguration<SER>
{
    public SERConfiguration()
        : base()
    {
        #region Properties
        this.Ignore(ser => ser.SEDId);
        #endregion

        #region Objects
        this.HasRequired(ser => ser.SED).WithMany(sed => sed.ListOfSER).HasForeignKey(ser => ser.ChildId).WillCascadeOnDelete(false);
        #endregion

        #region Table
        this.ToTable("Refs");
        #endregion
    }
}

public class AbstractDConfiguration : BaseObjectConfiguration<AbstractD>
{
    public AbstractDConfiguration() : base()
    {
        this.ToTable("Defs");
    }
}

public class SEDConfiguration : BaseObjectConfiguration<SED>
{
    public SEDConfiguration()
        : base()
    {
        #region Properties
        #endregion

        #region Objects
        this.HasMany(sed => sed.ListOfSER).WithRequired(sed => sed.SED).HasForeignKey(sed => sed.ChildId).WillCascadeOnDelete(false);
        #endregion

        #region Table
        this.ToTable("Defs");
        #endregion
    }
}

Ich weiß, dass wir das Attribut [ForeignKey] verwenden können, um anzugeben, dass die Navigationseigenschaft einer abgeleiteten Klasse die in der übergeordneten abstrakten Klasse definierte Spalte verwenden soll. Wir möchten die Verwendung von DataAnnotations vermeiden. Ich verstehe nur nicht, warum es diesen Fehler auslöst. Die Navigationseigenschaft "Version" ist in der AbstractR-Konfiguration und nicht in der SER-Konfiguration definiert (was auch funktionieren sollte, da SER von AbstractR erbt). Stimmt das?

Zweitens tritt beim Entfernen der Version-Eigenschaft und der Zuordnung dasselbe Problem mit den in der SER-Zuordnung verwendeten Eigenschaften "ChildId" und "ParentId" auf. Ist das ein bekanntes Problem? Mache ich etwas falsch

PS: Die ParentId-Zuordnung wurde der Einfachheit halber entfernt, da sie anscheinend dasselbe Problem wie die ChildId-Zuordnung darstellt.

Hat jemand eine Idee, warum diese Art von Problem auftritt?

AKTUALISIERE

Nach einiger Recherche stellte sich heraus, dass Fluent API keine Basisklasseneigenschaften für das Mapping verwenden kann. Ist das richtig ? Ist das ein gewolltes Verhalten? Warum können die DataAnnotations Basisklasseneigenschaften und keine Fluent-API verwenden? Sind nicht alle Basisklasseneigenschaften in jede Klasse eingefügt oder wird sie mit einem Dekorationsmuster gelesen?