Entity Framework: incluye múltiples niveles de propiedades

El método Include () funciona bastante bien para listas en objetos. ¿Pero qué pasa si necesito ir a dos niveles de profundidad? Por ejemplo, el siguiente método devolverá ApplicationServers con las propiedades incluidas que se muestran aquí. Sin embargo, ApplicationsWithOverrideGroup es otro contenedor que contiene otros objetos complejos. ¿Puedo hacer un Incluir () en esa propiedad también? ¿O cómo puedo hacer que esa propiedad se cargue completamente?

Tal como está ahora, este método:

public IEnumerable<ApplicationServer> GetAll()
{
    return this.Database.ApplicationServers
        .Include(x => x.ApplicationsWithOverrideGroup)                
        .Include(x => x.ApplicationWithGroupToForceInstallList)
        .Include(x => x.CustomVariableGroups)                
        .ToList();
}

Rellenará solo la propiedad Enabled (a continuación) y no las propiedades Application o CustomVariableGroup (a continuación). ¿Cómo hago que esto suceda?

public class ApplicationWithOverrideVariableGroup : EntityBase
{
    public bool Enabled { get; set; }
    public Application Application { get; set; }
    public CustomVariableGroup CustomVariableGroup { get; set; }
}

Para EF 6

using System.Data.Entity;

query.Include(x => x.Collection.Select(y => y.Property))

Asegúrate de agregar using System.Data.Entity;para obtener la versión Includeque toma una lambda.

Para EF Core

Usa el nuevo método ThenInclude

query.Include(x => x.Collection)
     .ThenInclude(x => x.Property);

Si te entiendo correctamente, estás preguntando sobre la inclusión de propiedades anidadas. Si es así :

.Include(x => x.ApplicationsWithOverrideGroup.NestedProp)

o

.Include("ApplicationsWithOverrideGroup.NestedProp")  

o

.Include($"{nameof(ApplicationsWithOverrideGroup)}.{nameof(NestedProp)}")  

EF Core: Usando "ThenInclude" para cargar niveles múltiples: Por ejemplo:

var blogs = context.Blogs
    .Include(blog => blog.Posts)
        .ThenInclude(post => post.Author)
        .ThenInclude(author => author.Photo)
    .ToList();

Hice un pequeño ayudante para Entity Framework 6 (.Net Core style), para incluir subentidades de una manera agradable.

Ahora está en NuGet: Install-Package ThenInclude.EF6

using System.Data.Entity;

var thenInclude = context.One.Include(x => x.Twoes)
    .ThenInclude(x=> x.Threes)
    .ThenInclude(x=> x.Fours)
    .ThenInclude(x=> x.Fives)
    .ThenInclude(x => x.Sixes)
    .Include(x=> x.Other)
    .ToList();

El paquete está disponible en GitHub .

Más ejemplos de EFCore en MSDN muestran que puede hacer algunas cosas bastante complejas con Includey ThenInclude.

Este es un buen ejemplo de lo complejo que puede ser (¡esta es una sola declaración!):

viewModel.Instructors = await _context.Instructors

      .Include(i => i.OfficeAssignment)

      .Include(i => i.CourseAssignments)
        .ThenInclude(i => i.Course)
            .ThenInclude(i => i.Enrollments)
                .ThenInclude(i => i.Student)

      .Include(i => i.CourseAssignments)
        .ThenInclude(i => i.Course)
            .ThenInclude(i => i.Department)

      .AsNoTracking()
      .OrderBy(i => i.LastName)
      .ToListAsync();

Vea cómo puede encadenar Includeincluso después ThenIncludey de alguna manera lo 'restablece' al nivel de la entidad de nivel superior (Instructores).

Incluso puede repetir la misma colección de 'primer nivel' (Asignaciones de curso) varias veces, seguido de ThenIncludescomandos separados para llegar a diferentes entidades secundarias.

Tenga en cuenta que su consulta real debe estar etiquetada en el final de la cadena Includeo ThenIncludes. Lo siguiente NO funciona:

var query = _context.Instructors.AsQueryable();
query.Include(i => i.OfficeAssignment);

var first10Instructors = query.Take(10).ToArray();

Le recomiendo que configure el registro y asegúrese de que sus consultas no estén fuera de control si incluye más de una o dos cosas. Es importante ver cómo funciona realmente, y notará que cada 'inclusión' por separado suele ser una nueva consulta para evitar uniones masivas que devuelven datos redundantes.

AsNoTracking puede acelerar mucho las cosas si no tiene la intención de editar las entidades y volver a guardarlas.

También tuve que usar varias inclusiones y en el 3er nivel necesitaba múltiples propiedades

(from e in context.JobCategorySet
                      where e.Id == id &&
                            e.AgencyId == agencyId
                      select e)
                      .Include(x => x.JobCategorySkillDetails)
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.DurationType))
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.RuleType))
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.RateType))
                      .FirstOrDefaultAsync();

Esto puede ayudar a alguien :)

Permítame decirle claramente que puede usar la sobrecarga de cadena para incluir niveles anidados independientemente de las multiplicidades de las relaciones correspondientes, si no le importa usar literales de cadena:

query.Include("Collection.Property")