Entity Framework
Scenari di mappatura avanzati: suddivisione delle entità, divisione delle tabelle

introduzione

Scissione di entità

Quindi diciamo che hai una classe di entità come questa:

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; }
}

E poi diciamo che vuoi mappare questa entità Person in due tabelle - una con PersonId e il Nome, e un'altra con i dettagli dell'indirizzo. Ovviamente anche qui avete bisogno del PersonId per identificare a quale persona appartiene l'indirizzo. Quindi in pratica quello che vuoi è dividere l'entità in due (o anche più) parti. Da qui il nome, divisione dell'entità. Puoi farlo associando ciascuna delle proprietà a una tabella diversa:

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");
      });
  }
}

Questo creerà due tabelle: People e PersonDetails. La persona ha due campi, PersonId e Name, PersonDetails ha quattro colonne, PersonId, AddressLine, City e ZipCode. In People, PersonId è la chiave primaria. In PersonDetails la chiave primaria è anche PersonId, ma è anche una chiave esterna che fa riferimento a PersonId nella tabella Persona.

Se si esegue una query su People DbSet, EF eseguirà un join su PersonIds per ottenere i dati da entrambe le tabelle per popolare le entità.

Puoi anche cambiare il nome delle colonne:

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");
  });
}

Questo creerà la stessa struttura di tabella, ma nella tabella Persone ci sarà una colonna PersonName invece della colonna Name, e nella tabella PersonDetails ci sarà un ProprietorId invece della colonna PersonId.

Scissione della tabella

E ora diciamo che vuoi fare l'opposto della scomposizione dell'entità: anziché mappare un'entità in due tabelle, ti piacerebbe mappare una tabella in due entità. Questo è chiamato suddivisione delle tabelle. Supponiamo che tu abbia una tabella con cinque colonne: PersonId, Name, AddressLine, City, ZipCode, dove PersonId è la chiave primaria. E poi ti piacerebbe creare un modello EF come questo:

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; }
}

Una cosa salta fuori: non c'è AddressId in Address. Questo perché le due entità sono mappate sulla stessa tabella, quindi devono avere anche la stessa chiave primaria. Se fai una suddivisione in tabelle, questo è qualcosa che devi solo affrontare. Quindi, oltre alla divisione delle tabelle, è necessario configurare anche l'entità Indirizzo e specificare la chiave primaria. Ed ecco come:

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"));
  }
}