Entity Framework - Inclure plusieurs niveaux de propriétés

La méthode Include () fonctionne assez bien pour les listes d'objets. Mais que se passe-t-il si j'ai besoin d'aller deux niveaux en profondeur? Par exemple, la méthode ci-dessous retournera ApplicationServers avec les propriétés incluses affichées ici. Cependant, ApplicationsWithOverrideGroup est un autre conteneur qui contient d'autres objets complexes. Puis-je également faire un Include () sur cette propriété? Ou comment puis-je charger complètement cette propriété?

En l'état actuel, cette méthode:

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

Remplira uniquement la propriété Enabled (ci-dessous) et non les propriétés Application ou CustomVariableGroup (ci-dessous). Comment puis-je y arriver?

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

Pour EF 6

using System.Data.Entity;

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

Assurez-vous d'ajouter using System.Data.Entity;pour obtenir la version de Includecette prise dans un lambda.

Pour EF Core

Utilisez la nouvelle méthode ThenInclude

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

Si je vous comprends bien, vous demandez l'ajout de propriétés imbriquées. Si c'est le cas :

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

ou

.Include("ApplicationsWithOverrideGroup.NestedProp")  

ou

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

EF Core: Utilisation de "ThenInclude" pour charger plusieurs niveaux: Par exemple:

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

J'ai fait un petit assistant pour Entity Framework 6 (style .Net Core), pour inclure les sous-entités de manière agréable.

C'est maintenant sur 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();

Le package est disponible sur GitHub .

Plus d' exemples EFCore sur MSDN montrent que vous pouvez faire des choses assez complexes avec Includeet ThenInclude.

Ceci est un bon exemple de la complexité que vous pouvez obtenir (ce n'est qu'une seule déclaration!):

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

Voyez comment vous pouvez enchaîner Includemême après ThenIncludeet cela vous ramène au niveau de l'entité de niveau supérieur (instructeurs).

Vous pouvez même répéter plusieurs fois la même collection de «premier niveau» (CourseAssignments) suivie de ThenIncludescommandes distinctes pour accéder à différentes entités enfants.

Notez que votre requête réelle doit être balisée à la fin de la chaîne Includeou ThenIncludes. Ce qui suit ne fonctionne PAS:

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

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

Je vous recommande fortement de configurer la journalisation et de vous assurer que vos requêtes ne sont pas hors de contrôle si vous incluez plus d'une ou deux choses. Il est important de voir comment cela fonctionne réellement - et vous remarquerez que chaque «inclusion» distincte est généralement une nouvelle requête pour éviter que des jointures massives ne renvoient des données redondantes.

AsNoTracking peut accélérer considérablement les choses si vous n'avez pas l'intention de modifier réellement les entités et de les réenregistrer.

J'ai également dû utiliser plusieurs inclusions et au 3ème niveau, j'avais besoin de plusieurs propriétés

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

Cela peut aider quelqu'un :)

Permettez-moi de dire clairement que vous pouvez utiliser la surcharge de chaîne pour inclure des niveaux imbriqués indépendamment des multiplicités des relations correspondantes, si cela ne vous dérange pas d'utiliser des littéraux de chaîne:

query.Include("Collection.Property")