Estrutura de entidades - Incluir vários níveis de propriedades

O método Include () funciona muito bem para listas de objetos. Mas e se eu precisar subir dois níveis? Por exemplo, o método abaixo retornará ApplicationServers com as propriedades incluídas mostradas aqui. No entanto, ApplicationsWithOverrideGroup é outro contêiner que contém outros objetos complexos. Posso fazer um Include () nessa propriedade também? Ou como posso obter essa propriedade para carregar totalmente?

Como está agora, este método:

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

Preenche apenas a propriedade Enabled (abaixo) e não as propriedades Application ou CustomVariableGroup (abaixo). Como faço isso acontecer?

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

Para EF 6

using System.Data.Entity;

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

Certifique-se de adicionar using System.Data.Entity;para obter a versão Includeque aceita uma lambda.

Para EF Core

Use o novo método ThenInclude

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

Se bem entendi, você está perguntando sobre a inclusão de propriedades aninhadas. Se então :

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

ou

.Include("ApplicationsWithOverrideGroup.NestedProp")  

ou

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

EF Core: usando "ThenInclude" para carregar vários níveis: por exemplo:

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

Fiz uma pequena ajuda para o Entity Framework 6 (estilo .Net Core), para incluir subentidades de uma maneira agradável.

Agora está no 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();

O pacote está disponível no GitHub .

Mais exemplos de EFCore no MSDN mostram que você pode fazer coisas bastante complexas com Includee ThenInclude.

Este é um bom exemplo de quão complexo você pode ficar (esta é uma afirmação!):

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

Veja como você pode encadear Includemesmo depois ThenIncludee isso meio que 'redefine' você de volta ao nível da entidade de nível superior (Instrutores).

Você pode até repetir a mesma coleção de 'primeiro nível' (CourseAssignments) várias vezes seguidas de ThenIncludescomandos separados para acessar diferentes entidades filhas .

Observe que sua consulta real deve ser marcada no final da cadeia Includeou ThenIncludes. O seguinte NÃO funciona:

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

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

É altamente recomendável que você configure o log e verifique se suas consultas não estão fora de controle se você incluir mais de uma ou duas coisas. É importante ver como ele realmente funciona - e você notará que cada 'inclusão' separada é normalmente uma nova consulta para evitar junções em massa que retornam dados redundantes.

AsNoTracking pode acelerar bastante as coisas, se você não pretender realmente editar as entidades e salvar novamente.

Eu também tive que usar várias inclusões e no terceiro nível eu precisava de várias propriedades

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

Isso pode ajudar alguém :)

Deixe-me declarar claramente que você pode usar a sobrecarga de string para incluir níveis aninhados, independentemente das multiplicidades dos relacionamentos correspondentes, se você não se importa em usar literais de string:

query.Include("Collection.Property")