inmueble cargando Deseoso de clase derivada usando incluyen

Question

tengo clases como:

Person 
{ 
    Name 
    Address 
} 

Employee : Person 
{ 
    Compensation - object 
} 

Visitor : Person 
{ 

} 

Si escribo LINQ:

var persons = Context.Persons 
       .Include("Compensation"); 

me sale error:

A specified Include path is not valid. The EntityType 'Person' does not declare a navigation property with the name 'Compensation'.

Funciona bien si Hago:

var persons = Context.Persons 
       .OfType<Employee>() 
       .Include("Compensation"); 

Pero me gustaría obtener empleados y visitantes en la misma consulta.

Parece que hay una solicitud de esta característica en EF4 UserVoice: http://data.uservoice.com/forums/72025-ado-net-entity-framework-ef-feature-suggestions/suggestions/1249289-include-property-of-derived-classes?ref=title

pero no parece que será hecho en el corto plazo.

¿Cuál es una buena solución para este problema?

Answer 1

Usted puede tratar de esta manera:

var persons = Context.Persons 
        .OfType<Employee>() 
        .Include("Compensation") 
        .Concat<Person>(Context.Persons.OfType<Visitor>()); 

Answer 2

Esta cosa horrible funciona:

var persons = context.Persons 
       .Concat(context.Employees 
        .Where(e => e.Compensation.Amount >= 0)) 
       .Concat(context.Visitors 
        .Where(v => v.SomeProperty == "AlwaysTrue")); 

No estoy seguro de por qué, pero cuando filtra en una propiedad de objeto, objeto de la propiedad es ansiosamente cargado. Si no desea filtrar esa propiedad, use una condición que siempre será cierta.

Descargo de responsabilidad: No tengo idea de qué tan eficiente es la consulta resultante. Comprobé el sql generado cuando probé esto en un escenario un poco más complicado y era muy grande.

Answer 3

Aquí es un buen ejemplo de cómo cargar Persons e incluyen Compensation para Employees

Reemplazar Reference() por Collection() para una propiedad de colección.

IQueryable<Person> GetPersons() 
{ 
    var persons = Context.Persons; 
    foreach(var entry in persons.OfType<Employee>()) 
     Context.Entry(entry).Reference(e => e.Compensation).Load(); 
    return persons; 
} 

No estoy seguro si es eficiente, pero funciona, y la intención es más clara que con las uniones.

Basándose en esta SO answer

Answer 4

var employees = context.Persons.OfType<Employee>().Include(x => x.Compensation).ToArray(); 

var nonEmployees = context.Persons.Except(context.Persons.OfType<Employee>()).ToArray(); 

var people = employees.Concat(nonEmployees);