Query linq di entità framework Includi () più entità figlio

Questa potrebbe essere una domanda davvero elementare ma qual è il modo migliore per includere più entità figlio quando si scrive una query che si estende su TRE livelli (o più)?

vale a dire Ho 4 tabelle: Company, Employee, Employee_CareEmployee_Country

La società ha una relazione 1: m con il Dipendente.

Il dipendente ha una relazione 1: m sia con Employee_Car che Employee_Country.

Se voglio scrivere una query che restituisca i dati da tutte e 4 le tabelle, sto attualmente scrivendo:

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

Deve esserci un modo più elegante! Questo è lungo e genera un orrendo SQL

Sto usando EF4 con VS 2010

Usa metodi di estensione . Sostituisci NameOfContext con il nome del contesto dell'oggetto.

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

}

Quindi il tuo codice diventa

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

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

Da EF 4.1 a EF 6

Esiste un tipo fortemente tipizzato.Include che consente di specificare la profondità richiesta di caricamento desideroso fornendo espressioni Select alla profondità appropriata:

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

L'Sql generato in entrambi i casi non è ancora affatto intuitivo, ma sembra abbastanza performante. Ho fatto un piccolo esempio su GitHub qui

EF Core

EF Core ha un nuovo metodo di estensione .ThenInclude(), sebbene la sintassi sia leggermente diversa :

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

Secondo i documenti, terrei il "trattino" in più .ThenIncludeper preservare la tua sanità mentale.

Informazioni obsolete (non farlo):

Il caricamento di più nipoti potrebbe essere eseguito in un solo passaggio, ma ciò richiede un'inversione piuttosto imbarazzante del backup del grafico prima di andare al nodo successivo (NB: NON funziona con questo AsNoTracking(), si otterrà un errore di runtime):

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

Quindi rimarrei con la prima opzione (un modello Includi per profondità dell'entità foglia).

È possibile trovare questo articolo di interesse disponibile su codeplex.com .

• Miglioramento delle prestazioni delle query di Entity Framework mediante query basate su grafici .

L'articolo presenta un nuovo modo di esprimere query che si estendono su più tabelle sotto forma di forme di grafico dichiarative.

Inoltre, l'articolo contiene un confronto completo delle prestazioni di questo nuovo approccio con le query EF. Questa analisi mostra che GBQ supera rapidamente le query EF.

Come si costruisce una query LINQ to Entities per caricare direttamente gli oggetti figlio, invece di chiamare una proprietà di riferimento o Load ()

Non esiste altro modo, tranne l'implementazione del caricamento lento.

O caricamento manuale ....

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

Potrebbe essere che aiuterà qualcuno, 4 livelli e 2 bambini per ogni livello

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