我可以在Entity Framework 6中的关系中的属性上定义过滤器吗？

Question

Before I get started, note that I've simplified the data structure for what I'm trying to do and in the real world it isn't as awful of an implementation as you might think. Or maybe it is. Regardless, I can't change the way the data is structured so I'm not looking for suggestions on how to better structure the data. I'm just hoping to see if there is a way I can do what I'm asking in Entity Framework 6.

Consider I have the following tables:

Person:

ID    FirstName    LastName
1     John         Smith
2     Jane         Doe

Job:

ID    Name
1     Developer

ExtendedData:

ID    TableName    RowID    FieldName      FieldValue
1     Person       1        MiddleInitial  A
2     Person       1        Gender         M
3     Person       2        MiddleInitial  B
4     Person       2        Gender         F
5     Job          1        Description    Develop Stuff

The purpose of this ExtendedData table is to allow for additional data to be stored when there isn't a column for the data. For example, here "MiddleInitial" is not a column in the Person table, but in the ExtendedData table we can add a row to store that data.

In my "Person" class I can add the following code to add an ExtendedData property:

public virtual ICollection<ExtendedData> ExtendedData { get; set; }

Then I can create a relationship in Entity Framework with this:

modelBuilder.Entity<Person>()
    .HasMany(e => e.ExtendedData)
    .WithRequired(e => e.Person)
    .HasForeignKey(e => e.RowID);

The concern I have, is if I call...

john = Persons.Where(a => a.ID == 1);
john.ExtendedData...

... I'll get back all Extended Data rows where RowID = 1, including the row for the "Job" table. Obviously, I could do something like...

john.ExtendedData.Where(a => a.TableName == "Person")...

... but this is a little dangerous because what if I (or some other developer) forget to specify that extra filter in the code?

I tried doing something like this...

modelBuilder.Entity<Person>()
    .HasMany(e => (ICollection<ExtendedData>))e.ExtendedData.Where(a => a.TableName == "Person"))
    .WithRequired(e => e.Person)
    .HasForeignKey(e => e.RowID);

... but received an error at run time stating...

The expression 'e => Convert(e.ExtendedData.Where(a => (a.TableName == "Person")))' is not a valid property expression. The expression should represent a property: C#: 't => t.MyProperty' VB.Net: 'Function(t) t.MyProperty'.

The sense I make of it is it wants me to specify a property from "e" and not try to do any further wizardry.

Is there anywhere I can modify the Entity Framework model such that when I call person.ExtendedData it will only return to me ExtendedData records where the TableName = "Person"? Or must I remember to always include that extra filter when trying to pull data from the ExtendedData table?

Answer 1

What you really want here is Table Per Hierarchy. Define a base entity for your table, then define an inherited entity for each variation, and customize the discriminator.

Public abstract class ExtendedData
{
    public int Id {get;set;}
    public string FieldName {get;set;}
    public string FieldValue {get;set;}
}

public class ExtendedPersonData : ExtendedData
{}

public class ExtendedJobData : ExtendedData
{}

public class Person
{
    ....
    public virtual ICollection<ExtendedPersonData> ExtendedData {get;set}
}

public class Job
{
    ....
    public virtual ICollection<ExtendedJobData> ExtendedData {get;set;}
}

public class Context : DbContext
{
    ....
    public DbSet<ExtendedData> ExtendedData {get;set;}
} 

modelBuilder.Entity<ExtendedData>()
    .Map<ExtendedPersonData>(m => m.Requires("TableName").HasValue("Person"))
    .Map<ExtendedJobData>(m => m.Requires("TableName").HasValue("Job"));

with the inherited classes, you can now do Non-Polymorphic Queries against the table data, ie

IQueryable<ExtendedPersonData> query = from e in context.ExtendedData
                                                .OfType<ExtendedPersonData>()
                                       select e;

This will generate a SQL query which only returns records where the discriminator column matches ( "TableName" == "Person" in this case). Returning a Person and querying it's ExtendedData would automatically create a Non-Polymorphic Query, due to the collection type defined on the entity.

Note that in this scenario, you can mix shared columns and columns unique to each variation. Any columns specific to a unique variation would automatically become nullable in the table, and would only be filled by the entities that provide it. In your case, however, you have no unique columns, so the Inherited classes are just implementation stubs.

http://weblogs.asp.net/manavi/inheritance-mapping-strategies-with-entity-framework-code-first-ctp5-part-1-table-per-hierarchy-tph