EF LINQ comprend plusieurs entités imbriquées

Ok, j'ai des entités à trois niveaux avec la hiérarchie suivante: Cours -> Module -> Chapitre

Voici la déclaration EF LINQ originale:

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

Maintenant, je veux inclure une autre entité appelée Lab qui est associée à un cours.

Comment inclure l'entité Lab?

J'ai essayé ce qui suit mais cela n'a pas fonctionné:

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

Des idées pour inclure la 2ème entité?

Tout conseil ou information serait très apprécié. Merci!

Avez-vous essayé d'ajouter un autre Include:

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

Votre solution échoue car Includene prend pas d'opérateur booléen

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

Mise à jour Pour en savoir plus, téléchargez LinqPad et parcourez les exemples. Je pense que c'est le moyen le plus rapide de se familiariser avec Linq et Lambda.

Pour commencer - la différence entre Selectet Includeest qu'avec un Select vous décidez ce que vous voulez retourner (aka projection). L'inclusion est une fonction de chargement hâtif, qui indique à Entity Framework que vous souhaitez qu'il inclue les données d'autres tables.

La syntaxe Inclure peut également être sous forme de chaîne. Comme ça:

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

Mais les exemples de LinqPad l' expliquent mieux.

Dans Entity Framework Core ( EF.core), vous pouvez utiliser .ThenIncludepour inclure les niveaux suivants.

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

Plus d'informations: https://docs.microsoft.com/en-us/ef/core/querying/related-data

Note: Dites que vous avez besoin de plusieurs ThenInclude()sur blog.Posts, il suffit de répéter la Include(blog => blog.Posts)et faire une autre 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();

Includefait partie de l'interface fluide, vous pouvez donc écrire plusieurs Includeinstructions les unes après les autres

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

Vous pouvez également essayer

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

On peut écrire une méthode d'extension comme celle-ci:

    /// <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;
    }

Et utilisez-le comme ça même dans une implémentation générique:

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

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