O EF LINQ inclui entidades múltiplas e aninhadas

Ok, eu tenho entidades de três níveis com a seguinte hierarquia: Curso -> Módulo -> Capítulo

Aqui estava a declaração EF LINQ original:

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

Agora, quero incluir outra entidade chamada Lab, associada a um curso.

Como faço para incluir a entidade do laboratório?

Eu tentei o seguinte, mas não funcionou:

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

Alguma idéia de como incluir a 2ª entidade?

Qualquer conselho ou informação seria muito apreciada. Obrigado!

Você já tentou adicionar outro Include:

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

Sua solução falha porque Includenão leva um operador booleano

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

Atualização Para saber mais, faça o download do LinqPad e veja as amostras. Eu acho que é a maneira mais rápida de se familiarizar com Linq e Lambda.

Para começar - a diferença entre Selecte Includeé que, com um Select, você decide o que deseja retornar (também conhecido como projeção). A função Incluir é uma carga ansiosa , que informa ao Entity Framework que você deseja que ele inclua dados de outras tabelas.

A sintaxe Incluir também pode estar na sequência. Como isso:

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

Mas as amostras no LinqPad explicam isso melhor.

No Entity Framework Core ( EF.core), você pode usar .ThenIncludepara incluir os próximos níveis.

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

Mais informações: https://docs.microsoft.com/en-us/ef/core/querying/related-data

Nota: Diga que você precisa múltipla ThenInclude()on blog.Posts, basta repetir o Include(blog => blog.Posts)e fazem outra ThenInclude(post => post.Other).

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

Includefaz parte da interface fluente, para que você possa escrever várias Includeinstruções uma após a outra

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

Você também pode tentar

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

Pode-se escrever um método de extensão 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;
    }

E use-o assim mesmo em uma implementação genérica:

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

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