बड़े LINQ समूह क्वेरी, दृश्यों के पीछे क्या हो रहा है

Question

निम्न LINQ क्वेरी को उदाहरण के रूप में लें। कृपया कोड पर टिप्पणी न करें क्योंकि मैंने अभी इस प्रश्न के साथ मदद करने के लिए इसे टाइप किया है।

निम्न LINQ क्वेरी 'समूह द्वारा' का उपयोग करती है और सारांश जानकारी की गणना करती है। जैसा कि आप देख सकते हैं कि डेटा पर कई गणनाएं की जा रही हैं लेकिन दृश्यों के पीछे LINQ कितनी कुशल है।

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. कितनी बार 'निन्जा' की सूची क्रम से प्रत्येक मान के गणना करने के लिए अधिक दोहराया जा रहा है?
2. क्या ऐसी क्वेरी के निष्पादन को तेज करने के लिए फ़ोरैच लूप को नियोजित करना तेज़ होगा?
3. निनजास के बाद 'एस्पारेल()' जोड़कर कोई प्रदर्शन सुधार होगा?
4. क्या सूची के लिए सारांश जानकारी की गणना करने का एक बेहतर तरीका है?

किसी भी सलाह की सराहना की जाती है क्योंकि हम अपने पूरे सॉफ़्टवेयर में इस प्रकार के कोड का उपयोग करते हैं और मैं वास्तव में अच्छी तरह से समझना चाहता हूं कि LINQ हुड के नीचे क्या कर रहा है (इसलिए बोलने के लिए)। शायद एक बेहतर तरीका है?

Answer 1

यह मानते हुए वस्तुओं क्वेरी के लिए एक LINQ है:

• Ninjas केवल एक बार से अधिक दोहराया है, समूह आंतरिक कंक्रीट सूचियों में बनाए जाते हैं, जिन्हें आप कई बार फिर से भर रहे हैं (एक बार प्रति एकत्रीकरण)।
• foreach लूप का उपयोग करना लगभग निश्चित रूप से चीजों को गति नहीं देगा - आपको कैश कोहेन्सी से थोड़ी अधिक लाभ हो सकता है (जैसे ही आप एक समूह पर फिर से सक्रिय होते हैं, इसे शायद उच्च स्तर के कैश या मुख्य मेमोरी से डेटा प्राप्त करना होगा) लेकिन मुझे बहुत संदेह है कि यह महत्वपूर्ण होगा। यह लागू करने में दर्द में वृद्धि शायद हालांकि महत्वपूर्ण होगा :)
• अप AsParallelपराक्रम गति चीजों का उपयोग करना - यह बहुत आसानी से चलाने योग्य लग रहा है। कोशिश करने के लायक ...
• ईमानदार होने के लिए LINQ से ऑब्जेक्ट्स के लिए कोई बेहतर तरीका नहीं है। समूह के रूप में समेकन करने में सक्षम होना अच्छा होगा, और प्रतिक्रियाशील एक्सटेंशन आपको ऐसा कुछ करने की अनुमति देगा, लेकिन इस पल के लिए यह शायद सबसे आसान तरीका है।

आप एक संभव क्रियान्वयन पर अधिक विवरण के लिए GroupBy post in my Edulinq blog series पर एक नजर है सकते हैं। निंजा के लिए