C# LINQ का उपयोग करके लिस्ट को फ्लैट कैसे करें?

लिस्ट को फ्लैट करने का अर्थ है List<List<T>> को List<T> में बदलना। उदाहरण के लिए, List<List<int>> को List<int> में कन्वर्ट करना।

SelectMany ऑपरेटर

LINQ में SelectMany का उपयोग प्रत्येक एलिमेंट को IEnumerable<T> में प्रोजेक्ट करने और फिर परिणामी सीक्वेंसेज को एक सीक्वेंस में फ्लैट करने के लिए किया जाता है। यानी SelectMany ऑपरेटर रिजल्ट्स के सीक्वेंस से रिकॉर्ड्स को जोड़ता है और उन्हें एक रिजल्ट में बदल देता है।

विधि 1: SelectMany मेथड सिंटैक्स

using System;
using System.Collections.Generic;
using System.Linq;

namespace DemoApplication
{
    public class Program
    {
        static void Main(string[] args)
        {
            // नेस्टेड लिस्ट्स
            List> listOfNumLists = new List>
            {
                new List { 1, 2 },
                new List { 3, 4 },
                new List { 5, 6, 7 }
            };
            
            // SelectMany का उपयोग करके फ्लैट करें
            var flattenedList = listOfNumLists.SelectMany(x => x).ToList();
            
            Console.WriteLine("फ्लैट लिस्ट:");
            foreach (var num in flattenedList)
            {
                Console.Write(num + " ");
            }
            // आउटपुट: 1 2 3 4 5 6 7
            
            Console.ReadLine();
        }
    }
}

विधि 2: क्वेरी सिंटैक्स

using System;
using System.Collections.Generic;
using System.Linq;

namespace DemoApplication
{
    public class Program
    {
        static void Main(string[] args)
        {
            List> listOfNumLists = new List>
            {
                new List { 1, 2 },
                new List { 3, 4 },
                new List { 5, 6, 7 }
            };
            
            // क्वेरी सिंटैक्स में फ्लैट करना
            var flattenedList = (from sublist in listOfNumLists
                                from item in sublist
                                select item).ToList();
            
            Console.WriteLine("फ्लैट लिस्ट (क्वेरी सिंटैक्स):");
            flattenedList.ForEach(x => Console.Write(x + " "));
            
            Console.ReadLine();
        }
    }
}

आउटपुट (दोनों के लिए)

फ्लैट लिस्ट: 1 2 3 4 5 6 7

एडवांस्ड उदाहरण: कॉम्प्लेक्स ऑब्जेक्ट्स के साथ

public class Department
{
    public string Name { get; set; }
    public List Employees { get; set; }
}

public class Employee
{
    public string Name { get; set; }
    public decimal Salary { get; set; }
}

var departments = new List
{
    new Department { Name = "IT", Employees = new List
    {
        new Employee { Name = "Alice", Salary = 50000 },
        new Employee { Name = "Bob", Salary = 60000 }
    }},
    new Department { Name = "HR", Employees = new List
    {
        new Employee { Name = "Carol", Salary = 45000 }
    }}
};

// सभी कर्मचारियों की फ्लैट लिस्ट प्राप्त करें
var allEmployees = departments.SelectMany(d => d.Employees).ToList();

// विभाग नाम के साथ (अनाम टाइप)
var employeesWithDept = departments
    .SelectMany(d => d.Employees.Select(e => new 
    {
        EmployeeName = e.Name,
        Department = d.Name,
        Salary = e.Salary
    }))
    .ToList();

// उच्च वेतन वाले कर्मचारी
var highEarners = departments
    .SelectMany(d => d.Employees)
    .Where(e => e.Salary > 50000)
    .ToList();

SelectMany ओवरलोड्स

// 1. बेसिक: प्रत्येक एलिमेंट को IEnumerable में प्रोजेक्ट करता है
IEnumerable SelectMany(
    this IEnumerable source, 
    Func> selector)

// 2. इंडेक्स के साथ: सेलेक्टर को एलिमेंट का इंडेक्स भी मिलता है
IEnumerable SelectMany(
    this IEnumerable source, 
    Func> selector)

// 3. रिजल्ट सेलेक्टर के साथ: सोर्स एलिमेंट और कलेक्टेड एलिमेंट दोनों से रिजल्ट बनाता है
IEnumerable SelectMany(
    this IEnumerable source,
    Func> collectionSelector,
    Func resultSelector)

ओवरलोड 3 का उदाहरण (रिजल्ट सेलेक्टर)

var result = departments.SelectMany(
    d => d.Employees,           // कलेक्शन सेलेक्टर
    (dept, emp) => new          // रिजल्ट सेलेक्टर
    {
        Department = dept.Name,
        Employee = emp.Name,
        Salary = emp.Salary
    }
);

अन्य फ्लैटिंग दृष्टिकोण

Select + Concat (कम कुशल)

// SelectMany के बजाय - कम पठनीय
var flat = listOfNumLists
    .SelectMany(x => x)  // यही सही तरीका है
    // .Aggregate((a, b) => a.Concat(b).ToList())  // जटिल और धीमा
    .ToList();

foreach लूप (पारंपरिक)

var flat = new List();
foreach (var sublist in listOfNumLists)
{
    flat.AddRange(sublist);
}

प्रदर्शन तुलना

सिफारिश: अधिकांश मामलों में SelectMany का उपयोग करें - यह पठनीय, अभिव्यंजक और पर्याप्त रूप से प्रदर्शनकारी है। हॉट पाथ्स में जहां प्रदर्शन महत्वपूर्ण है, foreach + AddRange या List<T> कंस्ट्रक्टर के साथ क्षमता पूर्व-आवंटन पर विचार करें।