是否可以在 EF Core Include 查询中加入不相关的表

Question

I have an EF Core code first project and have created the following table

[Table("Activity")]
public class Activity : BaseModel
{
    [Key]
    public int Id { get; set; }
    public int ActivityId { get; set; }
    public TransactionType Type { get; set; }
    public virtual ActivityItem Item { get; set; }
}

ActivityItem is an abstract class that doesn't map to its own table, but I have three separate models that all inherit from it.

//Not its own table in the database
public abstract class ActivityItem
{}

[Table("ClassA")]
public class ClassA : ActivityItem
{
    public int Id {get; set;}
}

[Table("ClassB")]
public class ClassB : ActivityItem
{
    public int Id {get; set;}
}

[Table("ClassC")]
public class ClassC : ActivityItem
{
    public int Id {get; set;}
}

In this particular instance I'm explicitly avoiding the Table-Per-Hierarchy scheme because I need to have ClassA , ClassB , and ClassC as there own unique tables in the database.

Whenever I'm querying an entry from my Activity table I use the Type property to indicate if the Item is either an instance of ClassA , ClassB , or ClassC .

Is there a way that I can still use the Include method when I'm forming my queries to populate the Item navigation property?

Current Solution

var activity = _context.Activity.Where(...).FirstOrDefault();

if (activity.Type == "ClassA")
    activity.Item = _context.ClassA.First(p => p.Id == activity.ActivityId);
else if (activity.Type == "ClassB")
    activity.Item = _context.ClassB.First(p => p.Id == activity.ActivityId);
else if (activity.Type == "ClassC")
    activity.Item = _context.ClassC.First(p => p.Id == activity.ActivityId);

Desired Solution

var activity = _context.Activity.Include(p => p.Item).Where(...).FirstOrDefault();

I know EF Core will write Join queries on the related table when you use the Include method, but in my case there is no related table since ActivityItem isn't represented in the database. Is there a way to explicitly specify which table to Join based on my custom Type field without resorting to the Table-Per-Hierarchy scheme?

Answer 1

So you have a table of Activities, and a predicate that filters zero or more Activities from this table. You are only interested in the first Activity that passes the filter. There might be no Activity at all that might pass the filter, hence the OrDefault.

This fetched Activity has a (string?) property Type. The value of this property depicts whether you should look in table ClassA / ClassB / ClassC.

The fetched Activity also has a property ActivityId. You want the first (or default) ActivityItem (ClassA / ClassB / ClassC), that has an Id equal to this ActivityId.

Your design makes that property ActivityId is not a proper foreign key to the ActivityItem that this Activity belongs to. In fact your foreign key is a combination of [Type, ActivityId] .

So what you need, is a method that concatenates all your ClassA / ClassB / ClassC into one sequence, remembering the Type . After that you can join on [Type, Id] .

If you have to do this only once, you can use the following. If you have to do this to solve several problems, consider creating extension methods.

var activityItems = dbContext.ClassAItems.Cast<ActivityItem>()
    .Select(classAItem => new
    {
        Type = "ClassA",
        Data = classAItem,
    })
.Concat(dbContext.ClassBItems.Cast<ActivityItem>()
    .Select(classBItem => new
    {
        Type = "ClassB",
        Data = classBItem,
    }))
.Concat(dbContext.ClassCItems.Cast<ActivityItem>()
    .Select(classCItem => new
    {
        Type = "ClassC",
        Data = classCItem,
    }));

Now you can just do an inner join:

// join the filtered activities with the activityitems:
var result = dbContext.Activities.Where(...)
    .Join(activityItems,

    activity => new                     // from each activity take [type, activityId]
    {
        Type = activity.Type
        Id = activity.ActivityId,
    }
    activityItem => new                 // from each ActivityItems take [Type, Id]
    {
        Type = activityItem.Type,
        Id = activityItem.Data.Id,
    }

    // when these keys match, use the Activity and the matching ActivityItem to make one new
    // well, in this case, you are only interested in the Data of the ActivityItem
    (activity, activityItem) => activityItem.Data)

    // From the joined items you only want the first:
    .FirstOrDefault();