[Entity Framework][Code First] Herencia - Tabla por tipo - Table per Type (TPT)

 

Introducción

---

Analizaremos un modelo de herencia el cual permite definir una tabla para cada tipo concreto. En este caso la relación entre las tablas define el tipo de instancia de la entidad.

El modelo utilizado en este artículo es idéntico al anterior:

[Entity Framework][Code First] Herencia - Tabla por jerarquía - Table per Hierarchy (TPH)

 

Definición del modelo

---

Modelaremos la entidad empleado y sus derivados que representan al personal externo y el contratado por la compañía.

Partiremos de un modelo de clases como el siguiente:

y obtendremos un modelo de tablas

en donde cada la clase base estará en una tabla mientras que los derivados, con sus atributos particulares, en otras distintas.

En este caso la relación entre las tablas define el tipo, a diferencia del modelo TPH (Tabla por jerarquía) en donde un campo era quien lo indicaba.

 

Definición del Mapping

---

Se va a necesitar definir en que tabla se persiste cada tipo especifico, es por ello que se requiere una clase de mapping para cada derivado que herede de la base.

 

public class NorthWindContext : DbContext
{

    public NorthWindContext()
        : base("NorthwindDb")
    {
        this.Configuration.LazyLoadingEnabled = false;
        this.Configuration.ProxyCreationEnabled = false;
    }

    public DbSet<Employee> Employees { get; set; }

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

        modelBuilder.Configurations.Add(new EmployeeInternalMap());
        modelBuilder.Configurations.Add(new EmployeeExternalMap());

        base.OnModelCreating(modelBuilder);
    }

}

public class EmployeeMap : EntityTypeConfiguration<Employee>
{
    public EmployeeMap()
    {
        HasKey(x => x.EmployeeID);
        Property(x => x.LastName).HasMaxLength(20).IsRequired();
        Property(x => x.FirstName).HasMaxLength(10).IsRequired();

        Property(x => x.Address).HasMaxLength(60);
        Property(x => x.City).HasMaxLength(15);
        Property(x => x.Region).HasMaxLength(15);
        Property(x => x.PostalCode).HasMaxLength(10);
        Property(x => x.Country).HasMaxLength(15);

    }
}

public class EmployeeInternalMap : EntityTypeConfiguration<EmployeeInternal>
{
    public EmployeeInternalMap()
    {
        ToTable("EmployeeInternal");

      
    }
}

public class EmployeeExternalMap : EntityTypeConfiguration<EmployeeExternal>
{
    public EmployeeExternalMap()
    {
        ToTable("EmployeeExternal");

        Property(x => x.ConsultantName).IsRequired()
                                       .HasColumnType("varchar")
                                       .HasMaxLength(100);
    }
}

El principal detalle esta en la definición de los nombre de la tablas

 

Definición Repository

---

Este no sufrió cambios con respecto al articulo anterior donde tratamos TPH.

Nota: se agrego un método adicional a la interfaz del repositorio el cual implementa una query linq que utiliza el “is”, pero no varia la forma de definir esta funcionalidad con respecto al articulo anterior. Se analizara este punto más adelante cuando tratemos el Test que utiliza esta implementacion.

 

Test – Inicializar datos

---

La inicialización de datos es idéntica al artículo anterior donde explique TPH.

Pero el resultado de los “insert” que define EF son bastante diferentes, ya que por cada entidad creada requiere realiza dos operaciones, uno en la tabla base y otro en cada especialización, esto se aprecia claramente en el trace tomado desde el sql profiler.

 

Test – Obtener todos los empleados

---

Recuperar todos los empleados requiere implementar la unión de dos tablas, la de empleados internos y externos,  al ejecutar el test se puede observar claramente si analizamos el select definido por EF

La unión de las dos tablas que representan las entidades hijas se unen mediante un INNER JOIN con la tabla padre de empleados

Aquí nuevamente aparecen los “0X0X” y “0X1X” los cuales son usados por EF para determinar que tipo de instancia debe crear

 

Test – Recuperar todos los empleados de tipo interno, usando un repositorio especifico

---

Utilizamos el repositorio definido para un tipo concreto, en este caso se recuperan los empleados internos a la empresa

Esta acción unirá mediante un INNER JOIN la tabla que representa estos empleados con la tabla base, del cruce se obtendrán solo los registros de un único tipo.

 

 

Test – Recuperar todos los empleados del tipo interno, usando funcionalidad del repositorio genérico

---

Utilizar el método OfType<> definido en un método en al repositorio general

dará el mismo resultado que utilizar el repositorio especifico del test anterior

 

Test – Obtener todos los empleados Externos

---

Se obtienes todos los empleados de contratación externa.

El join se realiza utilizando la tabla que representa los empleados externos a la compañía.

 

Test – Obtener todo los empleados externos, usando el “is”

---

Aplicaremos una variación en la técnica utilizada al definir el tipo que queremos filtrar, para ello nos ayudaremos con el “is” en el where de la query linq.

como veremos EF detecta el “is” como la acción de recuperar un tipo especifico, por eso el sql que define nuevamente hace uso del JOIN entre las tablas

 

Documentación de referencia

---

Inheritance with EF Code First: Part 2 – Table per Type (TPT)

 

Código

---

Se utilizo Visual Studio 2012, no se adjunta ninguna base de datos, esta será creada al ejecutar los test utilizando el modelo definido en el contexto de EF

[C#]