实体框架查询多个 inheritance 共享属性

Question

I have a table using TPH in Entity Framework Core. I've created a simple example to transmit the idea using animals, for example a Dog and a Dolphin are mammals and a Dolphin and a Salmon are marine animals, but a Dog is not marine and a Salmon is not a mammal, it's a fish.

You can see here some code:

public interface IMammal
{
    public int NeocortexSize { get; set; }
}

public interface IFish
{
    public int GillSize { get; set; }
}

public interface IMarine
{
    public int MaxDepth { get; set; }
}

public abstract class Animal
{
    protected Animal(AnimalType animalType)
    {
        Type = animalType;
    }

    public AnimalType Type { get; }
}

public class Dog : Animal, IMammal
{
    public Dog() : base(AnimalType.Dog) {}

    public int NeocortexSize { get; set; }
}

public class Salmon: Animal, IFish, IMarine
{
    public Salmon() : base(AnimalType.Salmon) {}

    public int GillSize { get; set; }

    public int MaxDepth { get; set; }
}

public class Dolphin : Animal, IMammal, IMarine
{
    public Dolphin() : base(AnimalType.Dolphin) {}

    public int NeocortexSize { get; set; }

    public int MaxDepth { get; set; }
}

My question is on how to query for things that are on an interface, for example MaxDepth > 650 , because the only way that I've found to do it feels a little bit hacky. You just cast to some concrete animal that implements the interface. From reading the code, it looks that you would only get Dolphin , but it will return Dolphin and Salmon at runtime (which is fine, it's what I want).

// Hacky way that works
// You get a `List<Animal>` with `Salmon` and `Dolphin` inside
context.Animals.Where(animal => (animal as Dolphin).MaxDepth > 650).ToList()

// runtime error because LINQ to sql doesn't know how to translate
context.Animals.Where(animal => (animal as IMarine).MaxDepth > 650)
context.Animals.Cast<IMarine>.Where(marine => marine.MaxDepth > 650)

Is there a better way to do it?

Answer 1

I would do

context.Animals.Where(animal => (animal is IMarine) && (animal as IMarine).MaxDepth > 650) 

This way you avoid runtime error, as you check if animal is marine first, so you will not try to treat something that isn't IMarine as IMarine.

Or even better:

    context.Animals.OfType<IMarine>().Where(marine => marine.MaxDepth > 650) 

Answer 2

An interface is not an implementation. It's just a contract, ie a "promise" that something will be available or "requirement" that something should be implemented.

By manually setting the column name, you are forcing something that is not supposed to be like that. That fact that your "hacky" query works is a result of that. But you are actually asking for problems, because EF now internally sets all objects in the list to be of type Dolphin . That could cause exceptions when you cast the objects to that type (which would be legal).

Interfaces are not entities. Ie by casting to an interface EF cannot distinguish an object of a specific type, which it needs for the relational mapping. Interfaces do not represent inheritance: there's no "is a" relationship. It's more a "guarantees these methods and properties", but EF cannot work with those.

You could get the specific rows in your current setup using raw SQL queries, Eg Dapper

    using (var connection = new SqlConnection(connString))
    {
        var animals = connection.Query<Animal>(
            "SELECT * FROM Animals WHERE MaxDepth > 650");
        ... do stuff with animals
    }

C# doesn't have multiple inheritance, and interfaces don't work, so you'll have to find another solution. You can for instance think of composition with "abilities". Ie a Fish 'has a' SwimmingAbility that 'has a' MaxDepth property. You would distribute data over multiple tables. And the "ability" tables will only have rows related to a few specific animals.

If you think about that, it will also give a cleaner solution, because else you would get a gigantic single table with many many columns for all properties of subspecies. And most columns will be NULL for a specific animal.

The downside is additional time required to fetch relational data from separate tables.

By the way, if you use a document-based database (NoSql) this will be easier.