Entity Framework: include più livelli di proprietà

Il metodo Include () funziona abbastanza bene per gli elenchi sugli oggetti. E se avessi bisogno di approfondire due livelli? Ad esempio, il metodo seguente restituirà ApplicationServers con le proprietà incluse mostrate qui. Tuttavia, ApplicationsWithOverrideGroup è un altro contenitore che contiene altri oggetti complessi. Posso fare anche un Include () su quella proprietà? O come posso caricare completamente quella proprietà?

Così com'è ora, questo metodo:

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

Popolerà solo la proprietà Enabled (sotto) e non le proprietà Application o CustomVariableGroup (sotto). Come posso farlo accadere?

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

Per EF 6

using System.Data.Entity;

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

Assicurati di aggiungere using System.Data.Entity;per ottenere la versione Includeche accetta un lambda.

Per EF Core

Usa il nuovo metodo ThenInclude

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

Se ti capisco correttamente, mi stai chiedendo di includere le proprietà nidificate. Se è così :

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

o

.Include("ApplicationsWithOverrideGroup.NestedProp")  

o

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

EF Core: Utilizzo di "ThenInclude" per caricare livelli multipli: Ad esempio:

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

Ho creato un piccolo aiuto per Entity Framework 6 (.Net Core style), per includere le entità secondarie in modo piacevole.

Ora è su 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();

Il pacchetto è disponibile su GitHub .

Altri esempi di EFCore su MSDN mostrano che puoi fare alcune cose piuttosto complesse con IncludeeThenInclude .

Questo è un buon esempio di quanto tu possa ottenere complesso (questa è tutta una dichiarazione!):

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();

Scopri come puoi concatenare Includeanche dopo ThenIncludee il tipo di "reimpostazione" ti riporta al livello dell'entità di livello superiore (Istruttori).

Puoi persino ripetere la stessa raccolta di "primo livello" (CourseAssignments) più volte seguita da ThenIncludescomandi separati per accedere a diverse entità figlio.

Nota che la tua query effettiva deve essere taggata alla fine della catena Includeo ThenIncludes. Quanto segue NON funziona:

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

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

Ti consigliamo vivamente di impostare la registrazione e assicurarti che le tue query non siano fuori controllo se includi più di una o due cose. È importante vedere come funziona effettivamente e noterai che ogni 'inclusione' separata è in genere una nuova query per evitare che enormi join restituiscano dati ridondanti.

AsNoTracking può velocizzare notevolmente le cose se non hai intenzione di modificare effettivamente le entità e salvare.

Ho anche dovuto usare più inclusioni e al 3 ° livello avevo bisogno di più proprietà

(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();

Questo può aiutare qualcuno :)

Consentitemi di affermare chiaramente che è possibile utilizzare il sovraccarico della stringa per includere i livelli nidificati indipendentemente dalle molteplicità delle relazioni corrispondenti, se non vi dispiace usare i valori letterali delle stringhe:

query.Include("Collection.Property")