जेनेरिक्स तुम्हाला प्रकार (type) द्वारे पॅरामीटर केलेली क्लास आणि मेथड लिहिण्यास अनुमती देतात, कोड डुप्लिकेशन किंवा कास्टिंग केल्याशिवाय प्रकार सुरक्षा आणि पुनरुपयोगीयता प्रदान करतात. Constraints मर्यादित करतात की जेनेरिक पॅरामीटर कोणते प्रकार असू शकतात, त्यांच्या सदस्यांचा सुरक्षितपणे वापर करणे शक्य करतात. जेनेरिक्स C# मध्ये सर्वत्र वापरल्या जातात (संपूर्ण संग्रह लायब्ररी त्यांचा वापर करते).
जेनेरिक्स कोणत्या समस्येचे निराकरण करतात
// without generics — either duplicate per type, or use `object` (unsafe, requires casts)
object Get(object[] arr, int i) => arr[i]; // returns object → cast needed, runtime errors
// with generics — type-safe and reusable
T Get<T>(T[] arr, int i) => arr[i]; // works for any T, returns the exact type
int x = Get(new[] { 1, 2, 3 }, 0); // T inferred as int, no cast
जेनेरिक्स प्रकारच्या त्रुटींना रनटाइमवरून (कास्टिंग object) कंपाइल वेळेस हलवतात, आणि कास्ट्स दूर करतात — सुरक्षित, पुनरुपयोगी कोड.
जेनेरिक क्लास आणि मेथड
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;
Constraints — प्रकार पॅरामीटरला प्रतिबंधित करा
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 काय असू शकते, जे तुम्हाला त्या प्रकारच्या सदस्यांचा सुरक्षितपणे वापर करण्यास अनुमती देते (उदा. IComparable<T> साठी constraint केल्यास तुम्ही CompareTo कॉल करू शकता). constraint न करता, T कहीही असू शकते, म्हणून तुम्ही कोणत्याही सदस्यांची गृहीत धरू शकत नाही.
.NET मध्ये जेनेरिक्स सर्वत्र
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
महत्व का आहे
जेनेरिक्स C# साठी मूलभूत आहेत — ते सर्वत्र वापरल्या जातात (संपूर्ण संग्रह लायब्ररी, Task<T>, IEnumerable<T>, आणि अगणित API जेनेरिक आहेत), म्हणून त्यांना समजून घेणे कोणत्याही C# विकासासाठी आवश्यक आहे.
जेनेरिक्स एक खरी समस्या सोडवतात: पुनरुपयोगी कोड लिहिणे जो अनेक प्रकारांसाठी कार्य करतो प्रकार सुरक्षा राखून — पर्याय (object वापर करणे आणि कास्टिंग) कंपाइल-वेळ सुरक्षा त्यागते आणि त्रुटी-प्रवण कास्ट्स आवश्यक करते, तर प्रकारानुसार कोड डुप्लिकेट करणे अरक्षणीय आहे.
जेनेरिक्स तुम्हाला पुनरुपयोगी, प्रकार-सुरक्षित कोड देतात कास्टिंग शिवाय आणि कंपाइल-वेळ त्रुटी तपासणीसह. Constraints (where T : ...) एक महत्वाचा पूरक आहेत: ते प्रकार पॅरामीटरला मर्यादित करतात, जे प्रकारच्या सदस्यांचा सुरक्षित वापर दोन्ही सक्षम करते (इंटरफेसला constraint केल्यास तुम्ही त्याच्या मेथड्स कॉल करू शकता) आणि योग्य वापर सुनिश्चित करते.
जेनेरिक क्लास आणि मेथड्स समजून घेणे, प्रकार अनुमान कसे कार्य करते, आणि constraints (class, struct, new(), इंटरफेस/बेस-क्लास constraints) समजून घेणे जेनेरिक-भारी .NET लायब्ररी प्रभावीपणे वापरण्यासाठी आणि तुमचे स्वतःचे पुनरुपयोगी, प्रकार-सुरक्षित अमूर्ताकरण लिहिण्यासाठी आवश्यक आहे.
जेनेरिक्स C# च्या संग्रह आणि फ्रेमवर्कचा बराच भाग आधार करतात, आणि ते पुनरुपयोगी प्रकार-सुरक्षित कोडची कुंजी असल्याने, जेनेरिक्स आणि constraints मास्टर करणे प्रभावी C# विकासासाठी मूळ, वारंवार लागू केलेले ज्ञान आहे आणि प्रकार-सुरक्षित, पुनरुपयोगी डिজाइनची समज प्रतिबिंबित करते.