Generics ले तपाईंलाई classes र methods लिख्न दिन्छ जो type द्वारा parameterize गरिएको हुन्छ, type safety र reusability प्रदान गर्दै code duplication वा casting बिना। Constraints ले restrict गर्छ कि generic parameter कस्तो type हुन सक्छ, उनीहरूको members को safe उपयोग सक्षम गर्दै। Generics C# मा व्यापक छन् (सम्पूर्ण collections library उनीहरू प्रयोग गर्छ)।
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics ले type errors लाई runtime (casting object) बाट compile time मा सार्छ, र casts लाई हटाएर दिन्छ — सुरक्षित, 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 : ...) ले restrict गर्छ कि T के हुन सक्छ, जसले तपाईंलाई त्यो type को members लाई safely उपयोग गर्न दिन्छ (जस्तै IComparable<T> मा constrain गर्दा CompareTo कल गर्न दिन्छ)। 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 लेख्नु जो बहु types को लागि काम गर्छ जबकि type safety लाई सुरक्षित राख्दै — विकल्प (object र casting प्रयोग गर्दै) compile-time safety लाई त्याग गर्छ र error-prone casts आवश्यक गर्छ, जबकि code लाई type प्रति duplicate गर्नु अनुरक्षण गर्न असम्भव छ।
Generics ले तपाईंलाई reusable, type-safe code दिन्छ कुनै casting र compile-time error checking को साथ। Constraints (where T : ...) एक महत्त्वपूर्ण पूरक छन्: तिनीहरू restrict गर्छन् कि type parameter के हुन सक्छ, जसले दुवै type को members को safe उपयोग सक्षम गर्छ (interface मा constrain गर्दा यसको methods कल गर्न दिन्छ) र सही उपयोग सुनिश्चित गर्छ।
Generic classes र methods बुझ्नु, कसरी type inference काम गर्छ, र constraints (class, struct, new(), interface/base-class constraints) कसरी काम गर्छन् यो दुवै generic-heavy .NET libraries लाई effectively उपयोग गर्न र आफ्नो नै reusable, type-safe abstractions लेख्न आवश्यक छ।
Generics पछि C# को collections र framework को धेरै भाग अँड़ाइएको छ, र generics reusable type-safe code को लागि key भएकोले, generics र constraints मा दक्षता प्राप्त गर्नु type-safe, reusable design को बुझाइलाई प्रतिबिम्बित गर्दै effective C# development को लागि core, frequently-applied ज्ञान हो।