EF LINQ incluye entidades múltiples y anidadas

Ok, tengo entidades de tres niveles con la siguiente jerarquía: Curso -> Módulo -> Capítulo

Aquí estaba la declaración original de EF LINQ:

Course course = db.Courses
                .Include(i => i.Modules.Select(s => s.Chapters))
                .Single(x => x.Id == id); 

Ahora, quiero incluir otra entidad llamada Lab que está asociada con un curso.

¿Cómo incluyo la entidad Lab?

Intenté lo siguiente pero no funcionó:

Course course = db.Courses
                .Include(i => i.Modules.Select(s => s.Chapters) && i.Lab)
                .Single(x => x.Id == id); 

¿Alguna idea sobre la inclusión de la 2da entidad?

Cualquier consejo o información sería muy apreciada. ¡Gracias!

¿Has probado simplemente agregando otro Include?

Course course = db.Courses
                .Include(i => i.Modules.Select(s => s.Chapters))
                .Include(i => i.Lab)
                .Single(x => x.Id == id);

Su solución falla porque Includeno toma un operador booleano

Include(i => i.Modules.Select(s => s.Chapters) &&          i.Lab)
                           ^^^                  ^             ^ 
                          list           bool operator    other list

Actualización Para obtener más información, descargue LinqPad y consulte los ejemplos. Creo que es la forma más rápida de familiarizarse con Linq y Lambda.

Para empezar, la diferencia entre Selecty Includees que con un Select usted decide lo que quiere devolver (también conocido como proyección). La función Incluir es Eager Loading , que le dice a Entity Framework que desea que incluya datos de otras tablas.

La sintaxis de Incluir también puede estar en cadena. Me gusta esto:

           db.Courses
            .Include("Module.Chapter")
            .Include("Lab")
            .Single(x => x.Id == id);

Pero las muestras en LinqPad explican esto mejor.

En Entity Framework Core ( EF.core) puede usar .ThenIncludepara incluir los siguientes niveles.

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

Más información: https://docs.microsoft.com/en-us/ef/core/querying/related-data

Nota: Digamos que usted necesita múltiples ThenInclude()en blog.Posts, sólo tiene que repetir el Include(blog => blog.Posts)y hacer otraThenInclude(post => post.Other) .

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

Includeforma parte de una interfaz fluida, por lo que puede escribir varias Includedeclaraciones una tras otra

 db.Courses.Include(i => i.Modules.Select(s => s.Chapters))
           .Include(i => i.Lab)
           .Single(x => x.Id == id); 

También puedes probar

db.Courses.Include("Modules.Chapters").Single(c => c.Id == id);

Uno puede escribir un método de extensión como este:

    /// <summary>
    /// Includes an array of navigation properties for the specified query 
    /// </summary>
    /// <typeparam name="T">The type of the entity</typeparam>
    /// <param name="query">The query to include navigation properties for that</param>
    /// <param name="navProperties">The array of navigation properties to include</param>
    /// <returns></returns>
    public static IQueryable<T> Include<T>(this IQueryable<T> query, params string[] navProperties)
        where T : class
    {
        foreach (var navProperty in navProperties)
            query = query.Include(navProperty);

        return query;
    }

Y úsalo así incluso en una implementación genérica:

string[] includedNavigationProperties = new string[] { "NavProp1.SubNavProp", "NavProp2" };

var query = context.Set<T>()
.Include(includedNavigationProperties);