Quando eseguiamo una query tramite Entity Framework, spesso abbiamo l'esigenza di recuperare dati da più entity. Grazie all'espressività di LINQ to Entities e al metodo Include, mettere in relazione più entity è estremamente semplice. Tuttavia quando le entity coinvolte nella query sono tante, la query SQL che viene inviata al database diventa pesante.
In scenari come questi, si possono ottimizzare le prestazioni limitando l'uso della clausola Include ed effettuando più query. L'ovvio svantaggio di questa tecnica è quello di dover eseguire più query, ma spesso questo svantaggio è superato dai vantaggi.
Facciamo un esempio. Supponiamo di dover eseguire una query che estrae gli ordini con i relativi dettagli, il cliente che ha piazzato l'ordine, il dipendente che lo ha inserito e i prodotti presenti nei dettagli. Eseguire in un colpo solo una query simile significa mettere in JOIN molte tabelle sul database il che significa bassa velocità di esecuzione e, soprattutto, un'enorme mole di dati duplicati restituiti dalla query il che aumenta il carico di rete ed il tempo che Entity Framework impiega per trasformari i dati nel database in oggetti.
Se suddividiamo la query in query più piccole otteniamo una maggior velocità di esecuzione ed un minore numero di dati scambiati tra il database e la nostra applicazione. La cosa più importante è che Entity Framework mette comunque in relazione le entity recuperate. Il risultato è che alla fine delle query, gli ordini sono collegati ai clienti, al dipendente, ai dettagli e ai prodotti esattamente come se i dati fossero stati recuperati in una sola query.
Ovviamente, come tutte le ottimizzazioni, questa tecnica non è da applicare sempre; il suo utilizzo va valutato caso per caso misurando le prestazioni sul campo.

//Query lenta
var orders = ctx.Orders.Include(o => o.Customer).Include(o => o.Employee).Include(o => o.Details.Select(d => d.Product));

//Ottimizzata
ctx.Customers.Load();
ctx.Employees.Load();
var orders = ctx.Orders.Include(o => o.Details.Select(d => d.Product));