EF LINQ include entità multiple e nidificate

Ok, ho entità a tre livelli con la seguente gerarchia: Corso -> Modulo -> Capitolo

Ecco la dichiarazione originale EF LINQ:

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

Ora, voglio includere un'altra entità chiamata Lab che è associata a un corso.

Come posso includere l'entità Lab?

Ho provato quanto segue ma non ha funzionato:

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

Qualche idea su come includere la 2a entità?

Qualsiasi consiglio o informazione sarebbe molto apprezzato. Grazie!

Hai provato ad aggiungere un altro Include:

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

La tua soluzione fallisce perché Includenon accetta un operatore booleano

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

Aggiornamento Per saperne di più, scarica LinqPad e guarda gli esempi. Penso che sia il modo più veloce per familiarizzare con Linq e Lambda.

Per iniziare, la differenza tra Selected Includeè quella con un Select decidi cosa vuoi restituire (aka proiezione). Includi è una funzione di caricamento desideroso , che dice a Entity Framework che vuoi che includa dati da altre tabelle.

La sintassi Includi può anche essere in stringa. Come questo:

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

Ma i campioni in LinqPad lo spiegano meglio.

In Entity Framework Core ( EF.core) è possibile utilizzare .ThenIncludeper includere i livelli successivi.

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

Ulteriori informazioni: https://docs.microsoft.com/en-us/ef/core/querying/related-data

Nota: Di che hai bisogno di più ThenInclude()su blog.Posts, basta ripetere la Include(blog => blog.Posts)e fare un altro 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();

Includefa parte di un'interfaccia fluida, quindi puoi scrivere più Includeistruzioni una dopo l'altra

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

Puoi anche provare

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

Si può scrivere un metodo di estensione come questo:

    /// <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 usalo così anche in un'implementazione generica:

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

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