C# में Generics: उपयोग और लाभों के लिए पूर्ण गाइड

C# में Generics: क्यों आवश्यक हैं और कैसे उपयोग करें

सामान्यीकृत प्रकार (Generics) C# भाषा की एक प्रमुख क्षमता है, जो पैरामीटरयुक्त प्रकारों के साथ क्लासेस, विधियाँ और इंटरफ़ेस बनाने की अनुमति देती है। प्रत्येक डेटा प्रकार के लिए एक ही कोड लिखने के बजाय, आप इसे एक बार लिखते हैं, और उपयोग करते समय प्रकार निर्दिष्ट करते हैं। इससे प्रदर्शन, प्रकार सुरक्षा और कोड पुन: उपयोग में वृद्धि होती है। इस लेख में, हम समझेंगे कि Generics की आवश्यकता क्यों है, उन्हें व्यवहार में कैसे लागू करें और .NET से वास्तविक उदाहरण देखेंगे।

C# में Generics की आवश्यकता क्यों है

C# (संस्करण 2.0) में Generics के आगमन से पहले, डेवलपर्स अक्सर object प्रकार और ArrayList संग्रह का उपयोग करते थे। इससे दो समस्याएँ उत्पन्न होती थीं:

• प्रदर्शन हानि — मान प्रकारों (int, double, struct) के लिए बॉक्सिंग (boxing) और अनबॉक्सिंग (unboxing)।
• संकलन समय पर प्रकार जाँच का अभाव — गलती से संख्याओं की सूची में एक स्ट्रिंग डाल सकते हैं और केवल रनटाइम पर त्रुटि प्राप्त कर सकते हैं।

Generics दोनों समस्याओं का समाधान करते हैं। वे अनावश्यक ओवरहेड के बिना प्रकार-सुरक्षित डेटा संरचनाएँ बनाने की अनुमति देते हैं। उदाहरण के लिए, List<int> बिना बॉक्सिंग के int के साथ काम करता है, और कंपाइलर इसमें स्ट्रिंग जोड़ने की अनुमति नहीं देगा।

Generics की मूल अवधारणाएँ

सामान्यीकृत क्लासेस

Generic-क्लास को कोण कोष्ठक में प्रकार पैरामीटर के साथ घोषित किया जाता है। प्रकार पैरामीटर एक प्लेसहोल्डर है, जो इंस्टेंस बनाते समय वास्तविक प्रकार से बदल दिया जाता है।

public class Box<T>{    private T _value;

    public Box(T value)    {        _value = value;    }

    public T GetValue() => _value;}

उपयोग:

var intBox = new Box<int>(42);var stringBox = new Box<string>("Hello");

Console.WriteLine(intBox.GetValue());   // 42Console.WriteLine(stringBox.GetValue());// Hello

सामान्यीकृत विधियाँ

एक विधि का अपना स्वयं का प्रकार पैरामीटर हो सकता है, भले ही क्लास generic न हो:

public class Utils{    public static void Swap<T>(ref T a, ref T b)    {        T temp = a;        a = b;        b = temp;    }}

// उपयोगint x = 1, y = 2;Utils.Swap(ref x, ref y);Console.WriteLine($"{x} {y}"); // 2 1

सामान्यीकृत इंटरफ़ेस

प्रकार पैरामीटर वाले इंटरफ़ेस लचीले एब्स्ट्रैक्शन बनाने की अनुमति देते हैं:

public interface IRepository<T>{    T GetById(int id);    void Add(T entity);}

public class UserRepository : IRepository<User>{    public User GetById(int id) => new User();    public void Add(User user) { }}

Generics में सीमाएँ (Constraints)

कभी-कभी उन प्रकारों पर सीमाएँ लगाने की आवश्यकता होती है जिन्हें प्रतिस्थापित किया जा सकता है। इसके लिए where कीवर्ड का उपयोग किया जाता है।

सीमाओं के मुख्य प्रकार

• where T : class — केवल संदर्भ प्रकार (string, क्लासेस)।
• where T : struct — केवल मान प्रकार (int, DateTime, struct)।
• where T : new() — प्रकार में बिना पैरामीटर के सार्वजनिक कंस्ट्रक्टर होना चाहिए।
• where T : SomeBaseClass — प्रकार निर्दिष्ट क्लास होना चाहिए या उससे विरासत में मिला होना चाहिए।
• where T : ISomeInterface — प्रकार को इंटरफ़ेस लागू करना चाहिए।

एकाधिक सीमाओं वाला उदाहरण:

public class Repository<T> where T : class, IEntity, new(){    public T Create()    {        return new T(); // new() के कारण अनुमति    }}

Generics में Covariance और Contravariance

C# 4.0 से शुरू होकर, in और out कीवर्ड की मदद से generic-इंटरफ़ेस की वेरिएंस को नियंत्रित करने की क्षमता आई।

• कोवेरियंस (out) — उपयोग की अनुमति देता है