Entity Framework linq query Include () mehrere untergeordnete Entitäten

Dies mag eine wirklich elementare Frage sein, aber was ist eine gute Möglichkeit, mehrere untergeordnete Entitäten einzuschließen, wenn Sie eine Abfrage schreiben, die DREI Ebenen (oder mehr) umfasst?

dh ich habe 4 Tabellen: Company, Employee, Employee_CarundEmployee_Country

Das Unternehmen hat eine 1: m-Beziehung zum Mitarbeiter.

Der Mitarbeiter hat eine 1: m-Beziehung zu Employee_Car und Employee_Country.

Wenn ich eine Abfrage schreiben möchte, die die Daten aus allen 4 Tabellen zurückgibt, schreibe ich gerade:

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

Es muss einen eleganteren Weg geben! Dies ist langwierig und erzeugt horrendes SQL

Ich verwende EF4 mit VS 2010

Verwenden Sie Erweiterungsmethoden . Ersetzen Sie NameOfContext durch den Namen Ihres Objektkontexts.

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

}

Dann wird Ihr Code

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

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

EF 4.1 bis EF 6

Es ist eine stark getippte.Include , mit dem die erforderliche Tiefe des eifrigen Ladens angegeben werden kann, indem Select-Ausdrücke in der entsprechenden Tiefe bereitgestellt werden:

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

Das in beiden Fällen generierte SQL ist noch keineswegs intuitiv, scheint aber performant genug zu sein. Ich habe ein kleines Beispiel gegeben GitHub gesetzt

EF Core

EF Core hat eine neue Erweiterungsmethode .ThenInclude(), obwohl die Syntax etwas anders ist :

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

Gemäß den Dokumenten würde ich den zusätzlichen Einzug in der behalten .ThenInclude, um Ihre geistige Gesundheit zu bewahren.

Veraltete Informationen (Tun Sie dies nicht):

Das Laden mehrerer Enkelkinder könnte in einem Schritt erfolgen, dies erfordert jedoch eine ziemlich umständliche Umkehrung des Diagramms, bevor der nächste Knoten heruntergefahren wird (Hinweis: Dies funktioniert NICHT AsNoTracking()- Sie erhalten einen Laufzeitfehler):

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

Ich würde also bei der ersten Option bleiben (ein Include pro Blattentitätstiefenmodell).

Möglicherweise finden Sie diesen Artikel von Interesse, der unter codeplex.com verfügbar ist .

• Verbessern der Abfrageleistung von Entity Framework mithilfe grafischer Abfragen .

Der Artikel bietet eine neue Möglichkeit, Abfragen, die mehrere Tabellen umfassen, in Form von deklarativen Diagrammformen auszudrücken.

Darüber hinaus enthält der Artikel einen gründlichen Leistungsvergleich dieses neuen Ansatzes mit EF-Abfragen. Diese Analyse zeigt, dass GBQ EF-Abfragen schnell übertrifft.

Wie erstellen Sie eine LINQ to Entities-Abfrage, um untergeordnete Objekte direkt zu laden, anstatt eine Referenzeigenschaft oder Load () aufzurufen?

Es gibt keinen anderen Weg - außer das verzögerte Laden zu implementieren.

Oder manuelles Laden ....

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