EF LINQ obejmować wiele i zagnieżdżonych podmioty

Question

Ok, mam tri-wyrównane podmioty o następującej hierarchii: kurs -> Moduły -> Rozdział

Tu był oryginalny rachunek EF LINQ:

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

teraz , Chcę dołączyć inny podmiot o nazwie Lab, który jest powiązany z kursem.

Jak dołączyć encję Lab?

Próbowałem następujących ale to nie działa:

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

pomysłów na tym 2nd Entity?

Wszelkie porady lub informacje są bardzo cenne. Dzięki!

Answer 1

Czy próbowali po prostu dodając kolejny Include:

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

Twoje rozwiązanie nie działa, ponieważ Include nie bierze logiczną operatora

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

Aktualizacja Aby dowiedzieć się więcej, pobierz LinqPad i patrzeć przez próbki. Myślę, że jest to najszybszy sposób na zaznajomienie się z Linq i Lambda.

Na początek - Różnica między Select i Include jest to, że z wybraną zdecydujesz co chcesz powrócić (aka projekcji). Funkcja Uwzględnij jest funkcją, która mówi Entity Framework, że chcesz dołączyć dane z innych tabel.

Składnia Include może być również w postaci ciągu. W ten sposób:

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

Ale próbki w LinqPad wyjaśniają to lepiej.

Answer 2

Include jest częścią płynny interfejs, dzięki czemu można napisać wiele Include oświadczenia każdy po drugiej

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

Answer 3

Można także spróbować

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

Answer 4

Ktoś może napisać metodę rozszerzenia tak:

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

I używać go tak, nawet w ogólnej implementacji entation:

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

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

Answer 5

W Entity Framework rdzenia (EF.core) można użyć .ThenInclude za tym kolejne poziomy.

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

Więcej informacji: https://docs.microsoft.com/en-us/ef/core/querying/related-data

Uwaga: Powiedzieć trzeba wiele ThenInclude() na blog.Posts, tylko powtórzyć Include(blog => blog.Posts) i zrobić kolejny 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(); 

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