How to Use Inheritance in Entity Framework

In Entity Framework, inheritance allows modeling relationships between entities so that a base class can be extended by one or more derived classes.

However, since relational databases do not directly support inheritance, Entity Framework uses mapping strategies to represent these relationships in tables.

In this article, we will look at these strategies, their advantages, disadvantages, and when it is appropriate to use each one 👇.

Inheritance Strategies

The three main strategies are:

Here is a summary of their main characteristics.

Classes for the Example

For the examples, let’s assume we have a class hierarchy where Animal is the base class and Dog and Cat are derived classes.

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

public class Dog : Animal
{
    public string Breed { get; set; }
}

public class Cat : Animal
{
    public bool HasClaws { get; set; }
}

Table Per Hierarchy (TPH)

TPH (Table Per Hierarchy) is a strategy where all classes in an inheritance hierarchy are stored in a single table.

This table includes a discriminator column that indicates the type of entity each row represents.

In our example, in TPH, all these entities would be stored in a single table called Animals with a discriminator column:

CREATE TABLE Animals (
    Id INT PRIMARY KEY,
    Name NVARCHAR(100),
    Breed NVARCHAR(100),
    HasClaws BIT,
    Discriminator NVARCHAR(50)
);

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Animal>()
        .HasDiscriminator<string>("Discriminator")
        .HasValue<Dog>("Dog")
        .HasValue<Cat>("Cat");
}

Table Per Type (TPT)

TPT (Table Per Type) is a strategy where each class in the inheritance hierarchy is stored in its own table. The tables are related by foreign keys.

Using the same example of Animal, Dog, and Cat, in TPT we would have three tables:

CREATE TABLE Animals (
    Id INT PRIMARY KEY,
    Name NVARCHAR(100)
);

CREATE TABLE Dogs (
    Id INT PRIMARY KEY,
    Breed NVARCHAR(100),
    FOREIGN KEY (Id) REFERENCES Animals(Id)
);

CREATE TABLE Cats (
    Id INT PRIMARY KEY,
    HasClaws BIT,
    FOREIGN KEY (Id) REFERENCES Animals(Id)
);

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Dog>().ToTable("Dogs");
    modelBuilder.Entity<Cat>().ToTable("Cats");
}

Table Per Concrete Class (TPC)

TPC (Table Per Concrete Class) is a strategy where each concrete class in the inheritance hierarchy is stored in its own table, but the properties of the base class are duplicated in each table.

Using the same example of Animal, Dog, and Cat, in TPC we would have two tables:

CREATE TABLE Dogs (
    Id INT PRIMARY KEY,
    Name NVARCHAR(100),
    Breed NVARCHAR(100)
);

CREATE TABLE Cats (
    Id INT PRIMARY KEY,
    Name NVARCHAR(100),
    HasClaws BIT
);

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Dog>().ToTable("Dogs");
    modelBuilder.Entity<Cat>().ToTable("Cats");

    modelBuilder.Entity<Dog>().Property(p => p.Id).ValueGeneratedNever();
    modelBuilder.Entity<Cat>().Property(g => g.Id).ValueGeneratedNever();
}

When to Use TPH, TPT, or TPC?