Query di raggruppamento LINQ di grandi dimensioni, cosa accade dietro le quinte

Question

Prendere come esempio la seguente query LINQ. Si prega di non commentare il codice stesso come ho appena digitato per aiutare con questa domanda.

La seguente query LINQ utilizza un "gruppo per" e calcola le informazioni di riepilogo. Come puoi vedere ci sono numerosi calcoli che vengono eseguiti sui dati ma quanto è efficiente LINQ dietro le quinte.

var NinjasGrouped = (from ninja in Ninjas 
    group pos by new { pos.NinjaClan, pos.NinjaRank } 
    into con 
    select new NinjaGroupSummary 
    { 
     NinjaClan = con.Key.NinjaClan, 
     NinjaRank = con.Key.NinjaRank, 
     NumberOfShoes = con.Sum(x => x.Shoes), 
     MaxNinjaAge = con.Max(x => x.NinjaAge), 
     MinNinjaAge = con.Min(x => x.NinjaAge), 
     ComplicatedCalculation = con.Sum(x => x.NinjaGrade) != 0 
     ? con.Sum(x => x.NinjaRedBloodCellCount)/con.Sum(x => x.NinjaDoctorVisits) 
     : 0, 
    ListOfNinjas = con.ToList() 
    }).ToList(); 

1. Quante volte è l'elenco dei 'Ninjas' essere iterato sopra al fine di calcolare ciascuno dei valori?
2. Sarebbe più rapido impiegare un ciclo foreach per accelerare l'esecuzione di tale query?
3. Aggiungendo ".AsParallel()" dopo Ninjas si ottengono miglioramenti delle prestazioni?
4. Esiste un modo migliore per calcolare le informazioni di scadenza per l'elenco?

Qualsiasi consiglio è apprezzato poiché utilizziamo questo tipo di codice in tutto il nostro software e mi piacerebbe davvero ottenere una migliore comprensione di ciò che LINQ sta facendo sotto il cofano (per così dire). Forse c'è un modo migliore?

Answer 1

Supponendo che questo è un query LINQ to Objects:

• Ninjas è solo ripetuti su una sola volta; i gruppi sono incorporati in elenchi concreti interni, che vengono quindi ripetuti più volte (una volta per aggregazione).
• L'utilizzo di un ciclo foreach quasi certamente non accelera le cose - si potrebbe trarre un ulteriore vantaggio dalla coerenza della cache (poiché ogni volta che si esegue iterazione su un gruppo, probabilmente sarà necessario recuperare i dati da una cache di livello superiore o dalla memoria principale) ma dubito fortemente che sarebbe significativo. L'aumento del dolore nella sua attuazione probabilmente sarebbe significativo però :)
• Utilizzando AsParallelforza accelerare le cose - sembra piuttosto facilmente parallelizzabile. Vale la pena provare ...
• Non c'è un modo molto migliore per LINQ to Objects, per essere onesti. Sarebbe bello poter eseguire l'aggregazione mentre si sta raggruppando, e le Reactive Extensions ti permetterebbero di fare qualcosa del genere, ma per il momento questo è probabilmente l'approccio più semplice.

Si potrebbe desiderare di avere uno sguardo al GroupBy post in my Edulinq blog series per maggiori dettagli su una possibile implementazione.