C# में List.GetRange() से तत्वों की रेंज प्राप्त करना

C# में List<T>.GetRange() मेथड का उपयोग करके सूची के एक सन्निकट (contiguous) भाग को एक नई सूची के रूप में प्राप्त किया जा सकता है। यह ArraySegment या LINQ के Skip()/Take() के समान है लेकिन सूची-विशिष्ट है।

उदाहरण

using System;
using System.Collections.Generic;

public class Demo
{
    public static void Main()
    {
        // सूची बनाएं
        List numbers = new List { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
        
        Console.WriteLine($"मूल सूची: [{string.Join(", ", numbers)}]");
        Console.WriteLine($"कुल तत्व: {numbers.Count}");
        
        // इंडेक्स 1 से 3 तत्व प्राप्त करें (इंडेक्स 1, 2, 3 -> मान 20, 30, 40)
        List range = numbers.GetRange(1, 3);
        
        Console.WriteLine($"\nGetRange(1, 3) - इंडेक्स 1 से 3 तत्व:");
        Console.WriteLine($"  [{string.Join(", ", range)}]");
        Console.WriteLine($"  गिनती: {range.Count}");
        
        // अंतिम 3 तत्व
        List lastThree = numbers.GetRange(numbers.Count - 3, 3);
        Console.WriteLine($"\nअंतिम 3 तत्व (GetRange({numbers.Count - 3}, 3)):");
        Console.WriteLine($"  [{string.Join(", ", lastThree)}]");
    }
}

आउटपुट

मूल सूची: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
कुल तत्व: 10

GetRange(1, 3) - इंडेक्स 1 से 3 तत्व:
  [20, 30, 40]
  गिनती: 3

अंतिम 3 तत्व (GetRange(7, 3)):
  [80, 90, 100]

GetRange() सिंटैक्स और पैरामीटर्स

public List GetRange(int index, int count);

GetRange() बनाम LINQ Skip/Take

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

public class Demo
{
    public static void Main()
    {
        List numbers = new List { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
        
        // GetRange - List-विशिष्ट, नई List लौटाता है
        List range1 = numbers.GetRange(2, 4);
        
        // LINQ Skip/Take - किसी भी IEnumerable पर काम करता है, IEnumerable लौटाता है
        var range2 = numbers.Skip(2).Take(4).ToList();
        
        // ArraySegment - सरणी के लिए, कॉपी नहीं करता (व्यू)
        int[] array = numbers.ToArray();
        var segment = new ArraySegment(array, 2, 4);
        
        Console.WriteLine($"GetRange:      [{string.Join(", ", range1)}]  प्रकार: {range1.GetType().Name}");
        Console.WriteLine($"Skip/Take:     [{string.Join(", ", range2)}]  प्रकार: {range2.GetType().Name}");
        Console.WriteLine($"ArraySegment:  [{string.Join(", ", segment)}]  प्रकार: {segment.GetType().Name} (कॉपी नहीं)");
    }
}

आउटपुट

GetRange:      [30, 40, 50, 60]  प्रकार: List`1
Skip/Take:     [30, 40, 50, 60]  प्रकार: List`1
ArraySegment:  [30, 40, 50, 60]  प्रकार: ArraySegment`1 (कॉपी नहीं)

अपवाद और त्रुटि हैंडलिंग

using System;
using System.Collections.Generic;

public class Demo
{
    public static void Main()
    {
        List list = new List { 1, 2, 3 };
        
        try
        {
            // अमान्य इंडेक्स
            var r1 = list.GetRange(5, 1); // ArgumentOutOfRangeException
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"त्रुटि: {ex.Message}");
        }
        
        try
        {
            // अमान्य काउंट (सीमा से बाहर)
            var r2 = list.GetRange(1, 5); // ArgumentOutOfRangeException
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"त्रुटि: {ex.Message}");
        }
        
        try
        {
            // ऋणात्मक काउंट
            var r3 = list.GetRange(0, -1); // ArgumentOutOfRangeException
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"त्रुटि: {ex.Message}");
        }
    }
}

महत्वपूर्ण बिंदु

• GetRange() नई सूची बनाता है (शैलो कॉपी - तत्वों के रेफरेंस कॉपी होते हैं)
• index 0 से Count - 1 के बीच होना चाहिए
• count 0 या अधिक होना चाहिए, और index + count <= Count होना चाहिए
• ऋणात्मक मान या सीमा से बाहर मान पर ArgumentOutOfRangeException फेंकता है
• संदर्भ प्रकारों के लिए, मूल और नई सूची समान ऑब्जेक्ट्स साझा करते हैं
• प्रदर्शन: O(count) समय, O(count) अतिरिक्त स्थान
• केवल List<T> पर उपलब्ध, IList<T> या IEnumerable<T> पर नहीं