Entity Framework
Erweiterte Mapping-Szenarien: Entitätsaufteilung, Aufteilung der Tabelle

Einführung

Aufteilung der Entitäten

Nehmen wir an, Sie haben eine Entitätsklasse wie diese:

public class Person  
{
   public int PersonId { get; set; }
   public string Name { get; set; }
   public string ZipCode { get; set; }
   public string City { get; set; }
   public string AddressLine { get; set; }
}

Nehmen wir an, Sie möchten diese Entität "Person" in zwei Tabellen abbilden - eine mit der Personen-ID und dem Namen und eine andere mit den Adressdetails. Natürlich benötigen Sie auch hier die PersonId, um zu ermitteln, zu welcher Person die Adresse gehört. Im Grunde möchten Sie die Entität in zwei (oder sogar mehr) Teile aufteilen. Daher der Name Entity Splitting. Sie können dies tun, indem Sie jede Eigenschaft einer anderen Tabelle zuordnen:

public class MyDemoContext : DbContext  
{       
  public DbSet<Person> Products { get; set; }

  protected override void OnModelCreating(DbModelBuilder modelBuilder)
  {
      modelBuilder.Entity<Person>().Map(m =>
      {
         m.Properties(t => new { t.PersonId, t.Name });
         m.ToTable("People");
      }).Map(m => 
      {   
        m.Properties(t => new { t.PersonId, t.AddressLine, t.City, t.ZipCode });
        m.ToTable("PersonDetails");
      });
  }
}

Dadurch werden zwei Tabellen erstellt: Personen und Personendetails. Person hat zwei Felder, PersonId und Name, PersonDetails hat vier Spalten: PersonId, Adresszeile, Ort und Postleitzahl. In People ist PersonId der Primärschlüssel. In PersonDetails ist der Primärschlüssel auch PersonId, es ist jedoch auch ein Fremdschlüssel, der auf PersonId in der Personentabelle verweist.

Wenn Sie das People-DbSet abfragen, führt EF einen Join für die PersonIds aus, um die Daten aus beiden Tabellen zum Abrufen der Entitäten zu erhalten.

Sie können auch den Namen der Spalten ändern:

protected override void OnModelCreating(DbModelBuilder modelBuilder)  
{
  modelBuilder.Entity<Person>().Map(m =>
  {
    m.Properties(t => new { t.PersonId });
    m.Property(t => t.Name).HasColumnName("PersonName");
    m.ToTable("People");
  }).Map(m =>
  {
    m.Property(t => t.PersonId).HasColumnName("ProprietorId");
    m.Properties(t => new { t.AddressLine, t.City, t.ZipCode });
    m.ToTable("PersonDetails");
  });
}

Dadurch wird dieselbe Tabellenstruktur erstellt. In der People-Tabelle wird jedoch eine PersonName-Spalte anstelle der Name-Spalte und in der PersonDetails-Tabelle eine ProprietorId anstelle der PersonId-Spalte angezeigt.

Tischaufteilung

Angenommen, Sie möchten das Gegenteil der Entitätsaufteilung tun: Anstatt eine Entität in zwei Tabellen abzubilden, möchten Sie eine Tabelle in zwei Entitäten abbilden. Dies wird als Tabellenaufteilung bezeichnet. Angenommen, Sie haben eine Tabelle mit fünf Spalten: PersonId, Name, Adresszeile, Ort, Postleitzahl, wobei PersonId der Primärschlüssel ist. Und dann möchten Sie ein EF-Modell wie folgt erstellen:

public class Person  
{
  public int PersonId { get; set; }
  public string Name { get; set; }
  public Address Address { get; set; }
}

public class Address  
{        
  public string ZipCode { get; set; }
  public string City { get; set; }
  public string AddressLine { get; set; }
  public int PersonId { get; set; }
  public Person Person { get; set; }
}

Eines springt sofort heraus: In Address gibt es keine AddressId. Das liegt daran, dass die beiden Entitäten derselben Tabelle zugeordnet sind und daher auch denselben Primärschlüssel haben müssen. Wenn Sie Tisch teilen, müssen Sie sich nur damit beschäftigen. Neben der Aufteilung von Tabellen müssen Sie also auch die Entität "Address" konfigurieren und den Primärschlüssel angeben. Und so geht's:

public class MyDemoContext : DbContext  
{
  public DbSet<Person> Products { get; set; }
  public DbSet<Address> Addresses { get; set; }

  protected override void OnModelCreating(DbModelBuilder modelBuilder)
  {
     modelBuilder.Entity<Address>().HasKey(t => t.PersonId);
     modelBuilder.Entity<Person>().HasRequired(t => t.Address)
                                  .WithRequiredPrincipal(t => t.Person);

     modelBuilder.Entity<Person>().Map(m => m.ToTable("People"));
     modelBuilder.Entity<Address>().Map(m => m.ToTable("People"));
  }
}