Cómo usar herencia en Entity Framework

En Entity Framework, la herencia permite modelar relaciones entre entidades de manera que una clase base puede ser extendida por una o más clases derivadas.

Sin embargo, dado que las bases de datos relacionales no soportan directamente la herencia, Entity Framework utiliza estrategias de mapeo para representar estas relaciones en tablas.

En este artículo, vamos a ver estas estrategias, sus ventajas, desventajas y cuándo es apropiado utilizar cada una 👇.

Estrategias de herencia

Las tres estrategias principales son:

Aquí tenéis un resumen de sus principales características.

Clases para los ejemplo

Para los ejemplos, vamos a suponer que tenemos una jerarquía de clases donde Animal es la clase base y Perro y Gato son clases derivadas.

public class Animal
{
    public int Id { get; set; }
    public string Nombre { get; set; }
}

public class Perro : Animal
{
    public string Raza { get; set; }
}

public class Gato : Animal
{
    public bool TieneGarras { get; set; }
}

Table Per Hierarchy (TPH)

TPH (Table Per Hierarchy) es una estrategia en la que todas las clases en una jerarquía de herencia se almacenan en una sola tabla.

Esta tabla incluye una columna discriminadora que indica el tipo de entidad que representa cada fila.

En nuestro ejemplo, en TPH, todas estas entidades se almacenarían en una sola tabla llamada Animales con una columna discriminadora:

CREATE TABLE Animales (
    Id INT PRIMARY KEY,
    Nombre NVARCHAR(100),
    Raza NVARCHAR(100),
    TieneGarras BIT,
    Discriminador NVARCHAR(50)
);

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Animal>()
        .HasDiscriminator<string>("Discriminador")
        .HasValue<Perro>("Perro")
        .HasValue<Gato>("Gato");
}

Table Per Type (TPT)

TPT (Table Per Type) es una estrategia en la que cada clase en la jerarquía de herencia se almacena en su propia tabla. Las tablas están relacionadas mediante claves foráneas.

Usando el mismo ejemplo de Animal, Perro y Gato, en TPT tendríamos tres tablas:

CREATE TABLE Animales (
    Id INT PRIMARY KEY,
    Nombre NVARCHAR(100)
);

CREATE TABLE Perros (
    Id INT PRIMARY KEY,
    Raza NVARCHAR(100),
    FOREIGN KEY (Id) REFERENCES Animales(Id)
);

CREATE TABLE Gatos (
    Id INT PRIMARY KEY,
    TieneGarras BIT,
    FOREIGN KEY (Id) REFERENCES Animales(Id)
);

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Perro>().ToTable("Perros");
    modelBuilder.Entity<Gato>().ToTable("Gatos");
}

Table Per Concrete Class (TPC)

TPC (Table Per Concrete Class) es una estrategia en la que cada clase concreta en la jerarquía de herencia se almacena en su propia tabla, pero las propiedades de la clase base se duplican en cada tabla.

Usando el mismo ejemplo de Animal, Perro y Gato, en TPC tendríamos dos tablas:

CREATE TABLE Perros (
    Id INT PRIMARY KEY,
    Nombre NVARCHAR(100),
    Raza NVARCHAR(100)
);

CREATE TABLE Gatos (
    Id INT PRIMARY KEY,
    Nombre NVARCHAR(100),
    TieneGarras BIT
);

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Perro>().ToTable("Perros");
    modelBuilder.Entity<Gato>().ToTable("Gatos");

    modelBuilder.Entity<Perro>().Property(p => p.Id).ValueGeneratedNever();
    modelBuilder.Entity<Gato>().Property(g => g.Id).ValueGeneratedNever();
}

¿Cuándo usar TPH, TPT o TPC?