Entity Framework: Ist es möglich, von der Basiskonfigurationsklasse zu erben?

Question

Ich modelliere eine neue Datenbank von EF CodeFirst. Hier habe ich eine abstrakte Basisklasse und jede Domain-Modell aus dieser Klasse geerbt:

public abstract class Entity 
{ 
    public Guid Id { get; set; } 
    public byte [] TimeStamp { get; set; } 
} 

Und es gibt viele Klassen wie:

public class Country : Entity 
{ 
    public string Name { get; set; } 
    public string InternationalCode { get; set; } 
    public Location Location { get; set; } 
    public ICollection<City> Cities { get; set; } 

    public Country(string name, string internationalCode, decimal latitude, decimal longitude) 
     : this(name, internationalCode) 
    { 
     Location.Latitude = latitude; 
     Location.Longitude = longitude; 
    } 
    public Country(string name, string internationalCode) : this() 
    { 
     Name = name; 
     InternationalCode = internationalCode; 
    } 

    public Country() 
    { 
     Location = new Location(); 
     Cities = new List<City>(); 
    } 
} 

und Konfiguration jedes Modells basiert auf FluentAPI:

public CountryConfiguration() 
    { 
     HasKey(p => p.Id); 
     Property(p => p.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); 
     Property(p => p.TimeStamp).IsRowVersion(); 

     Property(p => p.Name).IsRequired().HasMaxLength(100); 
     Property(p => p.InternationalCode).IsRequired().HasMaxLength(5); 

     HasMany(p => p.Cities) 
      .WithOptional(p => p.BelongedCountry) 
      .HasForeignKey(p => p.BelongedCountryId); 
    } 

Das Problem ist, dass

 HasKey(p => p.Id); 
     Property(p => p.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); 
     Property(p => p.TimeStamp).IsRowVersion(); 

Dieses Stück wurde mehr als 30 mal für jedes Domänenmodell kopiert. Gibt es eine Möglichkeit, Konfigurationsklassen von EntityTypeConfiguration zu erben, aber auch die Konfiguration von Entity Configuration übernehmen?

public class EntityConfiguration : EntityTypeConfiguration<Entity> 
{ 
    public EntityConfiguration() 
    { 
     HasKey(p => p.Id); 
     Property(p => p.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); 
     Property(p => p.TimeStamp).IsRowVersion(); 
    } 
} 

Ich weiß, dass C# keine Mehrfachvererbung erlaubt. Was kannst du vorschlagen?

Answer 1

Wenn ich etwas nicht vermisse, können Sie nicht eine abstrakte Klasse verwenden?

public abstract class BaseEntityConfiguration<T> : EntityTypeConfiguration<T> where T : Entity 
{ 
    protected BaseEntityConfiguration() 
    { 
     HasKey(p => p.Id); 
     Property(p => p.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); 
     Property(p => p.TimeStamp).IsRowVersion(); 
    } 
} 

public class CountryConfiguration : BaseEntityConfiguration<Country> 
{} 

Answer 2

von Just in Ihrem Schnipsel suchen, und wie ich es strukturieren könnte Ihre Anforderungen zu erfüllen, könnte ich Ihre EntityConfiguration Klasse ändern wie folgt:

public class EntityConfiguration<TEntityType> : EntityTypeConfiguration<TEntityType> where TEntityType : Entity 
{ 
    public EntityConfiguration() 
    { 
    HasKey(p => p.Id); 
    Property(p => p.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); 
    Property(p => p.TimeStamp).IsRowVersion(); 
    } 
} 

Dann Sie erbte Konfigurationen erstellen können, wie Ihre CountryConfiguration:

public class CountryConfiguration : EntityConfiguration<Country> 
{ 
    public CountryConfiguration() : base() 
    { 
    Property(p => p.Name).IsRequired().HasMaxLength(100); 
    Property(p => p.InternationalCode).IsRequired().HasMaxLength(5); 
    } 
} 

den generischen Typ auf der EntityConfiguration Klasse mit der Where-Klausel an Ihrer Basis Entitätstyp Durch die Beschränkung, werden Sie in der Lage sein, mit th zu arbeiten Setzen Sie die Basiseigenschaften in der EntityConfiguration-Klasse, während Sie den Rest den abgeleiteten Klassen für Ihre spezifischen Modelle überlassen.

Answer 3

Ich schätze Lösungen von @mxmissile und @Jodacola, Sie haben genau das gemacht, was ich gesucht habe.

Ich möchte nur hinzufügen, dass ich einen anderen „Bug“ Weg gefunden zu tun, was ich fragte:

modelBuilder.Entity<Entity>().HasKey(p => p.Id); 
     modelBuilder.Entity<Entity>().Property(p => p.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity); 
     modelBuilder.Entity<Entity>().Property(p => p.TimeStamp).IsRowVersion(); 

     modelBuilder.Configurations.Add(new CountryConfiguration()); 
     modelBuilder.Configurations.Add(new CityConfiguration()); 
     modelBuilder.Configurations.Add(new LocationConfiguration()); 
     modelBuilder.ComplexType<Location>(); 

Es ist „nicht angemessen“ Lösung und ich kann es nur in akademischen Zwecken veröffentlichen. Aus einigen Gründen hat es eine Tabelle "Entitäten" in der Datenbank erstellt. Ich wäre sehr dankbar, wenn Sie erklären könnten, warum hier eine Tabelle "Entitäten" in db erstellt wurde?

In db enthält es eine Kopie aller IDs von allen Entitäten, die von der Entity-Klasse geerbt wurden.