Entity Framework-zawiera wiele poziomów właściwości

Jeśli dobrze cię rozumiem, pytasz o włączenie właściwości zagnieżdżonych. Jeżeli tak :

.Include(x => x.ApplicationsWithOverrideGroup.NestedProp)

Lub

.Include("ApplicationsWithOverrideGroup.NestedProp")  

Lub

.Include($"{nameof(ApplicationsWithOverrideGroup)}.{nameof(NestedProp)}")  

EF Core: Using "ThenInclude" to load mutiple levels: Na przykład:

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

Zrobiłem mały helper dla encji Framework 6 (. Net core style), aby w przyjemny sposób zawierać pod-encje.

Jest teraz na NuGet: Install-Package ThenInclude.EF6

using System.Data.Entity;

var thenInclude = context.One.Include(x => x.Twoes)
    .ThenInclude(x=> x.Threes)
    .ThenInclude(x=> x.Fours)
    .ThenInclude(x=> x.Fives)
    .ThenInclude(x => x.Sixes)
    .Include(x=> x.Other)
    .ToList();

Pakiet jest dostępny na GitHub .

Musiałem również użyć wielu includów i na 3 poziomie potrzebowałem wielu właściwości

(from e in context.JobCategorySet
                      where e.Id == id &&
                            e.AgencyId == agencyId
                      select e)
                      .Include(x => x.JobCategorySkillDetails)
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.DurationType))
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.RuleType))
                      .Include(x => x.Shifts.Select(r => r.Rate).Select(rt => rt.RateType))
                      .FirstOrDefaultAsync();

To może komuś pomóc:)

Więcej przykładów EFCore na MSDN pokazuje, że można zrobić kilka dość złożonych rzeczy z Include i ThenInclude.

Jest to dobry przykład tego, jak skomplikowane można uzyskać (to wszystko jest jednym stwierdzeniem!):

viewModel.Instructors = await _context.Instructors

      .Include(i => i.OfficeAssignment)

      .Include(i => i.CourseAssignments)
        .ThenInclude(i => i.Course)
            .ThenInclude(i => i.Enrollments)
                .ThenInclude(i => i.Student)

      .Include(i => i.CourseAssignments)
        .ThenInclude(i => i.Course)
            .ThenInclude(i => i.Department)

      .AsNoTracking()
      .OrderBy(i => i.LastName)
      .ToListAsync();

Zobacz, jak możesz połączyć Include nawet po ThenInclude i to jakby "resetuje" cię z powrotem do poziomu jednostki najwyższego poziomu (instruktorów).

Możesz nawet wielokrotnie powtarzać tę samą kolekcję "pierwszego poziomu" (CourseAssignments), po której następują osobne polecenia ThenIncludes aby dostać się do różnych jednostek dziecka.

Uwaga twoje rzeczywiste zapytanie musi być oznaczone na końcu łańcucha Include lub ThenIncludes. Nie działa:

var query = _context.Instructors.AsQueryable();
query.Include(i => i.OfficeAssignment);

var first10Instructors = query.Take(10).ToArray();

Zdecydowanie zalecamy skonfigurowanie logowania i upewnienie się, że Twoje zapytania nie wymykają się spod kontroli, jeśli uwzględniasz więcej niż jedną lub dwie rzeczy. Ważne jest, aby zobaczyć, jak to faktycznie działa - i zauważysz, że każde oddzielne "Dołącz" jest zwykle nowym zapytaniem, aby uniknąć masowych połączeń zwracających zbędne data.

AsNoTracking może znacznie przyspieszyć działanie, jeśli nie zamierzasz faktycznie edytować podmiotów i zapisywać ponownie.

Pozwól, że powiem jasno, że możesz użyć przeciążenia łańcuchów do włączenia zagnieżdżonych poziomów niezależnie od wielokrotności odpowiednich relacji, jeśli nie masz nic przeciwko użyciu literałów łańcuchowych:

query.Include("Collection.Property")