C# में Select और SelectMany: गति के लिए क्या चुनें?

C# में Select और SelectMany: क्या अंतर है और यह गति को कैसे प्रभावित करता है?

यदि आपने कभी C# में LINQ क्वेरी लिखी है, तो आपने निश्चित रूप से दो समान लेकिन बहुत अलग विधियों का सामना किया होगा: Select और SelectMany। पहली नज़र में, दोनों कलेक्शन से "कुछ चुनते" हैं। लेकिन शैतान, हमेशा की तरह, विवरण में छिपा है। उनके बीच गलत चुनाव आपके तेज़ कोड को धीमा बना सकता है, जबकि सही चुनाव इसे सुरुचिपूर्ण और बिजली की गति वाला बना सकता है।

इस लेख में, हम केवल सिद्धांत पर चर्चा नहीं करेंगे। हम वास्तविक प्रदर्शन परीक्षण करेंगे, दोनों विधियों की आंतरिक कार्यप्रणाली देखेंगे, और आपको एक स्पष्ट एल्गोरिदम देंगे: कब Select का उपयोग करें और कब SelectMany का। तैयार हैं? चलिए शुरू करते हैं!

संक्षिप्त परिचय: Select और SelectMany क्या हैं?

शुरुआत के लिए — मूल बातें। कल्पना करें कि आपके पास छात्रों की एक सूची है (List<Student>), और प्रत्येक छात्र के पास ग्रेड की एक सूची है (List<int>)।

Select — यह "एक-से-एक" प्रोजेक्शन है। मूल कलेक्शन के प्रत्येक तत्व के लिए, आपको आउटपुट पर ठीक एक तत्व मिलता है। यदि आपके पास 10 छात्र हैं, तो Select 10 तत्वों का एक कलेक्शन लौटाएगा।

\n
• उदाहरण: सभी छात्रों के नाम प्राप्त करना।
\n
• सिग्नेचर: IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
\n

SelectMany — यह "एक-से-अनेक" प्रोजेक्शन है जिसके बाद "फ्लैटनिंग" (flatten) होता है। मूल कलेक्शन का प्रत्येक तत्व आउटपुट पर कई तत्व उत्पन्न कर सकता है, और वे सभी एक फ्लैट सूची में जुड़ जाते हैं।

\n
• उदाहरण: सभी छात्रों के सभी ग्रेड प्राप्त करना (संख्याओं की एक फ्लैट सूची)।
\n
• सिग्नेचर: IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
\n

ऐसा लगता है कि अंतर स्पष्ट है। लेकिन पेच कहाँ है? पेच यह है कि ये विधियाँ हुड के नीचे कैसे काम करती हैं और शुरुआती लोग अक्सर इन्हें कैसे भ्रमित करते हैं।

मुख्य अंतर: आउटपुट डेटा का रूप

आइए इसे कोड उदाहरण के साथ तुरंत समझें। यहाँ हमारा मॉडल क्लास है:

public class Student\n{\n    public string Name { get; set; }\n    public List<int> Grades { get; set; } = new List<int>();\n}\n\n// डेटा बनाएं\nvar students = new List<Student>\n{\n    new Student { Name = "अन्ना", Grades = new List<int>{ 5, 4, 5 } },\n    new Student { Name = "बोरिस", Grades = new List<int>{ 3, 4 } },\n    new Student { Name = "विका", Grades = new List<int>{ 5, 5, 5, 4 } }\n};\n

उदाहरण 1: Select का उपयोग करना (गलत)

// हम सभी ग्रेड प्राप्त करना चाहते हैं। लेकिन Select कलेक्शन का कलेक्शन लौटाएगा!\nvar allGradesNested = students.Select(s => s.Grades);\n// प्रकार: IEnumerable<List<int>> — अंदर तीन सूचियाँ!\n\nforeach (var gradeList in allGradesNested)\n{\n    foreach (var grade in gradeList)\n    {\n        Console.Write(grade + " "); // नेस्टेड लूप का उपयोग करना पड़ता है\n    }\n}\n// आउटपुट: 5 4 5 3 4 5 5 5 4\n

यह काम करता है, लेकिन असुविधाजनक है। आपको एक नेस्टेड संरचना मिलती है जिसे अतिरिक्त रूप से फ्लैट करने की आवश्यकता होती है।

उदाहरण 2: SelectMany का उपयोग करना (सही)

// SelectMany हमारे लिए सारा काम करता है: अंदर के कलेक्शन लेता है और उन्हें "चपटा" करता है\nvar allGradesFlat = students.SelectMany(s => s.Grades);\n// प्रकार: IEnumerable<int> — संख्याओं की एक फ्लैट सूची!\n\nforeach (var grade in allGradesFlat)\n{\n    Console.Write(grade + " "); // कोई नेस्टेड लूप नहीं!\n}\n// आउटपुट: 5 4 5 3 4 5 5 5 4\n

अंतर महसूस कर रहे हैं?