Requête Linq Entity Framework Inclure () plusieurs entités enfants

Cela peut être une question vraiment élémentaire, mais quelle est la bonne façon d'inclure plusieurs entités enfants lors de l'écriture d'une requête qui s'étend sur TROIS niveaux (ou plus)?

à- dire que j'ai 4 tables: Company, Employee, Employee_CaretEmployee_Country

L'entreprise a une relation de 1: m avec l'employé.

L'employé a une relation 1: m avec Employee_Car et Employee_Country.

Si je veux écrire une requête qui renvoie les données des 4 tables, j'écris actuellement:

Company company = context.Companies
                         .Include("Employee.Employee_Car")
                         .Include("Employee.Employee_Country")
                         .FirstOrDefault(c => c.Id == companyID);

Il doit y avoir une manière plus élégante! Ceci est long et génère un SQL horrible

J'utilise EF4 avec VS 2010

Utilisez des méthodes d'extension . Remplacez NameOfContext par le nom de votre contexte d'objet.

public static class Extensions{
   public static IQueryable<Company> CompleteCompanies(this NameOfContext context){
         return context.Companies
             .Include("Employee.Employee_Car")
             .Include("Employee.Employee_Country") ;
     }

     public static Company CompanyById(this NameOfContext context, int companyID){
         return context.Companies
             .Include("Employee.Employee_Car")
             .Include("Employee.Employee_Country")
             .FirstOrDefault(c => c.Id == companyID) ;
      }

}

Alors votre code devient

     Company company = 
          context.CompleteCompanies().FirstOrDefault(c => c.Id == companyID);

     //or if you want even more
     Company company = 
          context.CompanyById(companyID);

EF 4.1 à EF 6

Il existe un type fortement typé.Include qui permet de spécifier la profondeur requise du chargement hâtif en fournissant des expressions Select à la profondeur appropriée:

using System.Data.Entity; // NB!

var company = context.Companies
                     .Include(co => co.Employees.Select(emp => emp.Employee_Car))
                     .Include(co => co.Employees.Select(emp => emp.Employee_Country))
                     .FirstOrDefault(co => co.companyID == companyID);

Le SQL généré dans les deux instances n'est toujours pas intuitif, mais semble suffisamment performant. J'ai mis un petit exemple sur GitHub ici

EF Core

EF Core a une nouvelle méthode d'extension .ThenInclude(), bien que la syntaxe soit légèrement différente :

var company = context.Companies
                     .Include(co => co.Employees)
                           .ThenInclude(emp => emp.Employee_Car)
                      ...

Selon la documentation, je garderais le «retrait» supplémentaire dans le .ThenIncludepour préserver votre santé mentale.

Informations obsolètes (ne faites pas cela):

Le chargement de plusieurs petits-enfants peut être effectué en une seule étape, mais cela nécessite une inversion plutôt maladroite du graphique avant de descendre le nœud suivant (NB: cela ne fonctionne PAS avec AsNoTracking()- vous obtiendrez une erreur d'exécution):

var company = context.Companies
         .Include(co => 
             co.Employees
                .Select(emp => emp.Employee_Car
                    .Select(ec => ec.Employee)
                    .Select(emp2 => emp2.Employee_Country)))
         .FirstOrDefault(co => co.companyID == companyID);

Je resterais donc avec la première option (un modèle de profondeur d'inclusion par entité feuille).

Vous trouverez peut-être cet article intéressant disponible sur codeplex.com .

• Amélioration des performances des requêtes Entity Framework à l'aide de la requête basée sur un graphique .

L'article présente une nouvelle façon d'exprimer des requêtes qui s'étendent sur plusieurs tables sous la forme de formes graphiques déclaratives.

De plus, l'article contient une comparaison approfondie des performances de cette nouvelle approche avec les requêtes EF. Cette analyse montre que GBQ surpasse rapidement les requêtes EF.

Comment construire une requête LINQ to Entities pour charger directement des objets enfants, au lieu d'appeler une propriété Reference ou Load ()

Il n'y a pas d'autre moyen - sauf l'implémentation du chargement différé.

Ou chargement manuel ....

myobj = context.MyObjects.First();
myobj.ChildA.Load();
myobj.ChildB.Load();
...

Peut-être que cela aidera quelqu'un, 4 niveaux et 2 enfants à chaque niveau

Library.Include(a => a.Library.Select(b => b.Library.Select(c => c.Library)))
            .Include(d=>d.Book.)
            .Include(g => g.Library.Select(h=>g.Book))
            .Include(j => j.Library.Select(k => k.Library.Select(l=>l.Book)))