EF LINQ enthält mehrere und verschachtelte Entitäten

Ok, ich habe dreistufige Entitäten mit der folgenden Hierarchie: Kurs -> Modul -> Kapitel

Hier war die ursprüngliche EF LINQ-Anweisung:

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

Jetzt möchte ich eine weitere Entität namens Lab einfügen, die einem Kurs zugeordnet ist.

Wie füge ich die Lab-Entität hinzu?

Ich habe Folgendes versucht, aber es hat nicht funktioniert:

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

Irgendwelche Ideen zur Aufnahme der 2. Entität?

Jeder Ratschlag oder jede Information wäre sehr dankbar. Vielen Dank!

Haben Sie versucht, nur eine weitere hinzuzufügen Include:

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

Ihre Lösung schlägt fehl, da Includekein boolescher Operator erforderlich ist

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

Update Um mehr zu erfahren, laden Sie LinqPad herunter und sehen Sie sich die Beispiele an. Ich denke, es ist der schnellste Weg, sich mit Linq und Lambda vertraut zu machen.

Zunächst einmal - der Unterschied zwischen Selectund Includebesteht darin, dass Sie mit einem Select entscheiden, was Sie zurückgeben möchten (auch bekannt als Projektion). Das Include ist eine Funktion zum eifrigen Laden , die Entity Framework mitteilt, dass Daten aus anderen Tabellen enthalten sein sollen.

Die Include-Syntax kann auch eine Zeichenfolge sein. So was:

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

Die Beispiele in LinqPad erklären dies jedoch besser.

In Entity Framework Core ( EF.core) können Sie die .ThenIncludenächsten Ebenen einbeziehen.

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

Weitere Informationen: https://docs.microsoft.com/en-us/ef/core/querying/related-data

Hinweis: Sagen Sie müssen Sie mehrere ThenInclude()auf blog.Posts, nur das wiederholen , Include(blog => blog.Posts)und das andere zu tun 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();

Includeist Teil einer fließenden Benutzeroberfläche, sodass Sie mehrere IncludeAnweisungen nacheinander schreiben können

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

Sie können es auch versuchen

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

Man kann eine Erweiterungsmethode wie folgt schreiben:

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

Und verwenden Sie es auch in einer generischen Implementierung so:

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

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