Entity Framework - Uwzględnij wiele poziomów właściwości

Metoda Include () działa całkiem dobrze w przypadku list na obiektach. Ale co, jeśli muszę zejść dwa poziomy w głąb? Na przykład poniższa metoda zwróci ApplicationServers z dołączonymi właściwościami pokazanymi tutaj. Jednak ApplicationsWithOverrideGroup to kolejny kontener, w którym przechowywane są inne złożone obiekty. Czy mogę wykonać Include () również dla tej właściwości? Lub w jaki sposób mogę w pełni załadować tę właściwość?

W obecnej postaci ta metoda:

public IEnumerable<ApplicationServer> GetAll()
{
    return this.Database.ApplicationServers
        .Include(x => x.ApplicationsWithOverrideGroup)                
        .Include(x => x.ApplicationWithGroupToForceInstallList)
        .Include(x => x.CustomVariableGroups)                
        .ToList();
}

Zapełni tylko właściwość Enabled (poniżej), a nie właściwości Application lub CustomVariableGroup (poniżej). Jak to zrobić?

public class ApplicationWithOverrideVariableGroup : EntityBase
{
    public bool Enabled { get; set; }
    public Application Application { get; set; }
    public CustomVariableGroup CustomVariableGroup { get; set; }
}

Dla EF 6

using System.Data.Entity;

query.Include(x => x.Collection.Select(y => y.Property))

Pamiętaj, aby dodać, using System.Data.Entity;aby uzyskać wersję, Includektóra przyjmuje lambda.

Dla EF Core

Użyj nowej metody ThenInclude

query.Include(x => x.Collection)
     .ThenInclude(x => x.Property);

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

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

lub

.Include("ApplicationsWithOverrideGroup.NestedProp")  

lub

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

EF Core: Używanie „ThenInclude” do ładowania wielu poziomów: Na przykład:

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

Zrobiłem małego pomocnika dla Entity Framework 6 (styl .Net Core), aby ładnie włączać pod-byty.

Jest teraz w 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 .

Więcej przykładów EFCore na MSDN pokazuje, że możesz robić dość skomplikowane rzeczy przy pomocy Includei ThenInclude.

To dobry przykład tego, jak bardzo możesz się skomplikować (to wszystko jedno zdanie!):

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 łączyć w łańcuchy, Includenawet po, ThenIncludea to „resetuje” cię z powrotem do poziomu jednostki najwyższego poziomu (Instruktorzy).

Możesz nawet powtórzyć tę samą kolekcję „pierwszego poziomu” (CourseAssignments) wiele razy, a następnie osobne ThenIncludespolecenia, aby dostać się do różnych encji potomnych.

Uwaga: Twoje zapytanie musi być oznaczone na końcu łańcucha Includelub ThenIncludes. Następujące NIE działa:

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

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

Zdecydowanie zalecamy skonfigurowanie rejestrowania i upewnienie się, że zapytania nie wymkną się spod kontroli, jeśli podajesz więcej niż jedną lub dwie rzeczy. Ważne jest, aby zobaczyć, jak to naprawdę działa - a zauważysz, że każde „dołączenie” jest zwykle nowym zapytaniem, aby uniknąć masowego łączenia zwracającego zbędne dane.

AsNoTracking może znacznie przyspieszyć, jeśli nie zamierzasz edytować elementów i ponownie zapisywać.

Musiałem także użyć wielu dołączeń 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 :)

Pozwólcie, że jasno stwierdzę, że można użyć przeciążenia łańcucha, aby uwzględnić poziomy zagnieżdżone, niezależnie od mnogości odpowiednich relacji, jeśli nie przeszkadza ci użycie literałów łańcucha:

query.Include("Collection.Property")