Generics आपको एक type द्वारा parameterized classes और methods लिखने देते हैं, code duplication या casting के बिना type safety व reusability प्रदान करते हुए। Constraints प्रतिबंधित करते हैं कि एक generic parameter कौन से types हो सकता है, उनके members के safe उपयोग को सक्षम करते हुए। Generics C# में व्यापक हैं (पूरी collections library उनका उपयोग करती है)।
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics type errors को runtime (object को cast करना) से compile time पर ले जाते हैं, और casts को समाप्त करते हैं — safe, reusable code।
public class Box<T> // a generic class
{
private T _value;
public void Set(T value) => _value = value;
public T Get() => _value;
}
var box = new Box<string>(); // T = string, type-safe
// generic method
public T Max<T>(T a, T b) where T : IComparable<T> // constraint (see below)
=> a.CompareTo(b) > 0 ? a : b;
where T : class // T must be a reference type
where T : struct // T must be a value type
where T : new() // T must have a parameterless constructor
where T : IComparable<T> // T must implement an interface (so you can call its members)
where T : BaseClass // T must derive from BaseClass
// example: constraint lets you call CompareTo safely
public T Max<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) > 0 ? a : b; // CompareTo is available because of the constraint
Constraints (where T : ...) प्रतिबंधित करते हैं कि T क्या हो सकता है, जो आपको उस type के members को safely उपयोग करने देता है (जैसे IComparable<T> तक constrain करना आपको CompareTo call करने देता है)। एक constraint के बिना, T कुछ भी हो सकता है, इसलिए आप किसी भी members को मान नहीं सकते।
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generics C# के लिए मूलभूत हैं — वे व्यापक रूप से उपयोग होते हैं (पूरी collections library, Task<T>, IEnumerable<T>, और अनगिनत APIs generic हैं), इसलिए उन्हें समझना किसी भी C# development के लिए आवश्यक है।
Generics एक वास्तविक समस्या हल करते हैं: reusable code लिखना जो type safety को संरक्षित करते हुए कई types के लिए काम करता है — विकल्प (object का उपयोग और casting) compile-time safety का त्याग करता है और error-prone casts की आवश्यकता होती है, जबकि प्रति type code duplicate करना unmaintainable है।
Generics आपको बिना casting और compile-time error checking के साथ reusable, type-safe code देते हैं। Constraints (where T : ...) एक महत्वपूर्ण पूरक हैं: वे प्रतिबंधित करते हैं कि एक type parameter क्या हो सकता है, जो type के members के safe उपयोग को सक्षम करता है (एक interface तक constrain करना आपको इसके methods call करने देता है) और सही उपयोग सुनिश्चित करता है।
generic classes और methods, type inference कैसे काम करता है, और constraints (class, struct, new(), interface/base-class constraints) को समझना generic-heavy .NET libraries को प्रभावी ढंग से उपयोग करने और अपनी खुद की reusable, type-safe abstractions लिखने दोनों के लिए आवश्यक है।
चूंकि generics C# की collections और framework के अधिकांश हिस्से को रेखांकित करते हैं, और चूंकि वे reusable type-safe code की कुंजी हैं, generics व constraints में महारत हासिल करना effective C# development के लिए मूल, बार-बार-लागू होने वाला ज्ञान है और एक सामान्य विषय है जो type-safe, reusable design की समझ को दर्शाता है।