Come recuperare i dati secondari, tramite LINQ Includi, in una query, per migliorare le prestazioni?

C'è forse un limite su quanti livelli si può usare "Includi"?

C'è! Come ho spiegato qui sull'istruzione SQL generata -

• Il numero di colonne nella clausola SELECT è la somma di tutte le colonne in tutte le tabelle coinvolte
• Il numero di righe è la somma dei record nelle raccolte secondarie incluse

Questo è potenzialmente un enorme set di risultati (lungo e ampio) restituito dal database. A parte questo, è difficile per Query Optimizer del motore db trovare un buon piano di query. Il database avrà difficoltà a scricchiolare tutti i dati e non sorprende che il comando scada.

L'alternativa

L'alternativa è caricare i dati in blocchi. Ma è più facile a dirsi che a farsi. In un certo senso, si caricano già dati in blocchi, ma questi blocchi sono troppo piccoli e le query troppe (sì, N + 1). I pezzi dovrebbero essere più grandi. Non esiste una strategia chiara su come farlo. Dipende dalla struttura della tabella e dal numero di dati. Ma lasciami tentare di indicarti la giusta direzione.

5 livelli in basso

Per brevità, diciamo che le tabelle e le associazioni sono A < B < C < D < E ("<" che significa 1: n). La query di root è qualcosa di simile

var query = As.Where(a => a.Property == value).ToList();

[Quindi non vuoi tutto As , perché sarebbe facile: allora puoi anche caricare tutti i bambini.]

Supponiamo che tu possa Include i Bs senza problemi, ma ciò include anche il Cs . Quindi la query diventa:

var query = As.Where(a => a.Property == value)
              .Include(a => a.Bs).ToList();

E la Cs , ecc. Dovrebbe essere caricata in blocchi di dati.

Una bella funzionalità di Entity Framework è che connette automaticamente tutte le entità caricate in un contesto, tramite un processo noto come risoluzione delle relazioni . Quindi, se si caricano separatamente le Cs , le raccolte nei loro oggetti B padre verranno popolate. Ciò semplifica il caricamento delle Cs richieste:

var cs = Cs.Where(c => c.B.A.Property == value).ToList();

(supponendo che anche i riferimenti posteriori facciano parte del tuo modello)

No, se puoi tranquillamente includere la Ds , abbiamo quasi finito:

var cs = Cs.Where(c => c.B.A.Property == value)
           .Include(c => c.Ds).ToList();

E l'ultimo livello è caricato da:

var es = Es.Where(e => e.D.C.B.A.Property == value).ToList();

Questo livello di nidificazione (i punti) può sembrare spaventoso. Creerà una query con quattro join. Tuttavia, la grande differenza con 4 Incudes è che ora vengono interrogate solo le colonne E e le righe. Il risultato della query non esplode. E i motori di database sono ottimizzati per l'esecuzione di join.

Quindi questo ti dà alcune maniglie per giocare con i livelli Include e le query separate finché non hai una configurazione che funzioni bene (abbastanza).

Un'ultima cosa: ricordati di disattivare il caricamento pigro. EF riempie automaticamente le raccolte, ma non le contrassegna come caricate. Se il caricamento lazy è abilitato, l'accesso alle raccolte attiverà comunque le query N + 1.