LINQ में एकाधिक कॉलम द्वारा समूहीकरण: उदाहरण और सर्वोत्तम अभ्यास

C# में LINQ का उपयोग करके दो या अधिक फ़ील्ड द्वारा डेटा कैसे समूहित करें?

नमस्ते मित्र! यदि आपने कभी SQL में डेटाबेस के लिए क्वेरी लिखी है, तो आपको निश्चित रूप से एकाधिक कॉलम वाली GROUP BY संरचना याद होगी। यह डेटा को तार्किक बाल्टियों में विभाजित करने की अनुमति देती है — उदाहरण के लिए, पहले शहर के अनुसार बिक्री को समूहित करना, और फिर उसके अंदर उत्पाद श्रेणी के अनुसार। C# में इसी उद्देश्य के लिए LINQ से GroupBy का उपयोग किया जाता है। लेकिन एक समस्या है: मानक GroupBy केवल एक कुंजी स्वीकार करता है। यदि एकाधिक कॉलम द्वारा समूहित करना हो तो क्या करें?

डरें नहीं! समाधान सुरुचिपूर्ण और सरल है — हम एक अनाम प्रकार बनाते हैं जो आवश्यक फ़ील्ड को एक समग्र कुंजी में जोड़ता है। इस लेख में मैं आपको न केवल मूल सिंटैक्स दिखाऊंगा, बल्कि कोड के साथ वास्तविक उदाहरण भी दूंगा जिन्हें आप तुरंत अपने प्रोजेक्ट में लागू कर सकते हैं। चलिए शुरू करते हैं!

समस्या: एक कुंजी बहुत कम है

कल्पना करें कि आपके पास छात्रों की एक सूची है:

public class Student\n{\n    public string Name { get; set; }\n    public string Course { get; set; }\n    public int Grade { get; set; }\n}\n\nList<Student> students = new List<Student>\n{\n    new Student { Name = "Анна", Course = "Математика", Grade = 85 },\n    new Student { Name = "Борис", Course = "Математика", Grade = 90 },\n    new Student { Name = "Анна", Course = "Физика", Grade = 78 },\n    new Student { Name = "Борис", Course = "Физика", Grade = 82 },\n    new Student { Name = "Анна", Course = "Математика", Grade = 95 }\n};

आप प्रत्येक पाठ्यक्रम में प्रत्येक छात्र का औसत अंक जानना चाहते हैं। यदि केवल नाम से GroupBy का उपयोग किया जाए, तो गणित और भौतिकी के आंकड़े मिल जाएंगे। यदि केवल पाठ्यक्रम से — तो छात्र से संबंध खो जाएगा। दो कॉलम द्वारा समूहीकरण आवश्यक है: Name + Course.

समाधान: समग्र कुंजी के रूप में अनाम प्रकार

C# में हम मौके पर ही आवश्यक फ़ील्ड वाली एक अस्थायी वस्तु बना सकते हैं:

var grouped = students\n    .GroupBy(s => new { s.Name, s.Course })\n    .Select(g => new\n    {\n        g.Key.Name,\n        g.Key.Course,\n        AverageGrade = g.Average(st => st.Grade)\n    });\n\nforeach (var item in grouped)\n{\n    Console.WriteLine($"{item.Name} | {item.Course} | औसत अंक: {item.AverageGrade:F2}");\n}

आउटपुट:
\nАнна | Математика | औसत अंक: 90.00
\nБорис | Математика | औसत अंक: 90.00
\nАнна | Физика | औसत अंक: 78.00
\nБорис | Физика | औसत अंक: 82.00

ध्यान दें: new { s.Name, s.Course } — यही अनाम प्रकार है। LINQ स्वचालित रूप से वस्तुओं की तुलना उनके सभी गुणों (Value equality) के आधार पर करता है।

IGrouping और नेस्टेड कलेक्शन के साथ कार्य

कभी-कभी डेटा को एकत्रित करने के बजाय, समूह के अंदर सभी मूल तत्वों को संरक्षित करने की आवश्यकता होती है। इसके लिए IGrouping<TKey, TElement> इंटरफ़ेस का उपयोग किया जाता है। प्रत्येक समूह में एक कुंजी और तत्वों का संग्रह होता है:

var groups = students.GroupBy(s => new { s.Name, s.Course });\n\nforeach (var group in groups)\n{\n    Console.WriteLine($"छात्र: {group.Key.Name}, पाठ्यक्रम: {group.Key.Course}");\n    foreach (var student in group)\n    {\n        Console.WriteLine($"  अंक: {student.Grade}");\n    }\n}

यह दृष्टिकोण तब आदर्श होता है जब आपको, उदाहरण के लिए, एक विस्तृत रिपोर्ट प्रदर्शित करने की आवश्यकता होती है।

क्वेरी बनाम फ्लुएंट सिंटैक्स — क्या चुनें?

LINQ क्वेरी लिखने की दो शैलियों का समर्थन करता है। आइए दोनों देखें:

1. फ्लुएंट (मेथड सिंटैक्स)

var result = students\n    .GroupBy(s => new { s.Name, s.Course })\n    .Select(g => new { g.Key.Name, g.Key.Course, Count = g.Count() });

2. क्वेरी (SQL-जैसे एक्सप्रेशन सिंटैक्स)

var result = from student in students\n             group student by new { student.Name, student.Course } into g\n             select new { g.Key.Name, g.Key.Course, Count = g.Count() };

दोनों शैलियाँ पूरी तरह से समतुल्य हैं। चुनाव केवल आपकी आदत और सुविधा पर निर्भर करता है।

यह व्यवहार में कहाँ उपयोगी है?

\n
• ई-कॉमर्स में: विभिन्न शाखाओं में उत्पाद श्रेणी के अनुसार बिक्री को समूहित करना।
\n
• लॉगिंग में: दिन और घटना स्तर के अनुसार त्रुटियों की गणना करना।
\n
• रिपोर्ट में: विभाग और तिमाही के अनुसार कर्मचारियों को समूहित करना।
\n

निष्कर्ष

हमने सीखा कि एकाधिक फ़ील्ड द्वारा समूहीकरण के लिए आपको एक अनाम प्रकार का उपयोग करना होगा। यह एक सरल और सुरुचिपूर्ण तकनीक है जो किसी भी जटिल समूहीकरण को एक सुरुचिपूर्ण LINQ-शैली समाधान में बदल देती है।

// त्वरित सारांश:\n// एकाधिक कुंजियाँ —> नया अनाम प्रकार\nGroupBy(s => new { s.Field1, s.Field2 })

अब आपके पास C# में डेटा प्रोसेसिंग के लिए एक शक्तिशाली उपकरण है। टिप्पणियों में लिखें कि आप इसे कहाँ उपयोग करने की योजना बना रहे हैं!