જેનરિક્સ અને કન્સ્ટ્રેઇન્ટ્સ શું છે?

Question

Accepted Answer

**જેનરિક્સ** તમને ક્લાસ અને મેથડ્સ લખવા દે છે જે એક પ્રકાર દ્વારા પેરામેટરાઇજ્ડ હોય છે, **ટાઇપ સેફ્ટી અને પુનઃઉપયોગીયતા** પ્રદાન કરે છે કોડ ડુપ્લીકેશન અથવા કાસ્ટિંગ વિના। **કન્સ્ટ્રેઇન્ટ્સ** ઘટાડે છે કે જેનરિક પેરામીટર કયા પ્રકાર હોઈ શકે છે, તેમના સભ્યોનો સલામત ઉપયોગ સક્ષમ કરે છે। જેનરિક્સ C# માં વ્યાપક છે (સમગ્ર કલેકશન્સ લાઇબ્રેરી તેમનો ઉપયોગ કરે છે)। ## સમસ્યા જેનરિક્સ હલ કરે છે ```csharp // 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[] 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`) થી કમ્પાઇલ સમયે લઈ જાય છે, અને કાસ્ટ્સ દૂર કરે છે — સલામત, પુનઃઉપયોગી કોડ। ## જેનરિક ક્લાસ અને મેથડ્સ ```csharp public class Box // a generic class { private T _value; public void Set(T value) => _value = value; public T Get() => _value; } var box = new Box(); // T = string, type-safe // generic method public T Max(T a, T b) where T : IComparable // constraint (see below) => a.CompareTo(b) > 0 ? a : b; ``` ## કન્સ્ટ્રેઇન્ટ્સ — ટાઇપ પેરામીટરને મર્યાદિત કરો ```csharp 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 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 a, T b) where T : IComparable => a.CompareTo(b) > 0 ? a : b; // CompareTo is available because of the constraint ``` **કન્સ્ટ્રેઇન્ટ્સ** (`where T : ...`) મર્યાદિત કરે છે કે `T` શું હોઈ શકે છે, જે તમને તે પ્રકારના સભ્યોનો સલામતથી ઉપયોગ કરવા દે છે (દા. તરીકે, `IComparable` માં અવરોધ લગાવવો તમને `CompareTo` કહેવા દે છે)। કોઇ અવરોધ વિના, `T` કંઇ પણ હોઈ શકે છે, તેથી તમે કોઇ સભ્યો ધારણ કરી શકતા નથી। ## જેનરિક્સ .NET માં સર્વત્ર ```text List, Dictionary, IEnumerable, Task, Nullable ... → the entire collections library and much of .NET is generic. ``` ## તે શા માટે મહત્વપૂર્ણ છે જેનરિક્સ C# માટે મૌલિક છે — તેનો વ્યાપક ઉપયોગ થાય છે (સમગ્ર કલેકશન્સ લાઇબ્રેરી, `Task`, `IEnumerable`, અને અસંખ્ય API જેનરિક છે), તેથી તેમને સમજવું કોઇ પણ C# ડેવલપમેન્ટ માટે આવશ્યક છે। જેનરિક્સ વાસ્તવિક સમસ્યા હલ કરે છે: પુનઃઉપયોગી કોડ લખવું જે બહુવિધ પ્રકારો માટે કામ કરે જ્યારે **ટાઇપ સેફ્ટી** સાચવે છે — વિકલ્પ (`object` નો ઉપયોગ અને કાસ્ટિંગ) કમ્પાઇલ-સમે સલામતીનો ત્યાગ કરે છે અને ભૂલ-પ્રવણ કાસ્ટ્સ જરૂરી કરે છે, જ્યારે પ્રતિ પ્રકાર કોડ ડુપ્લીકેટ કરવું અસ્થાયી છે। જેનરિક્સ તમને પુનઃઉપયોગી, ટાઇપ-સલામત કોડ આપે છે કોઇ કાસ્ટિંગ અને કમ્પાઇલ-સમે ભૂલ તપાસ વિના। **કન્સ્ટ્રેઇન્ટ્સ** (`where T : ...`) એક મહત્વપૂર્ણ પૂરક છે: તેઓ મર્યાદિત કરે છે કે ટાઇપ પેરામીટર શું હોઈ શકે છે, જે તે પ્રકારના સભ્યોનો સલામત ઉપયોગ સક્ષમ કરે છે (ઇન્ટરફેસમાં અવરોધ લગાવવો તમને તેની મેથડ્સ કહેવા દે છે) અને સાચો ઉપયોગ સુનિશ્ચિત કરે છે। જેનરિક ક્લાસ અને મેથડ્સને સમજવું, કીવી પ્રકાર અનુમાન કાર્ય કરે છે, અને કન્સ્ટ્રેઇન્ટ્સ (`class`, `struct`, `new()`, ઇન્ટરફેસ/બેઝ-ક્લાસ કન્સ્ટ્રેઇન્ટ્સ) કોઇ પણ જેનરિક-ભારે .NET લાઇબ્રેરીઓ અસરકારક રીતે ઉપયોગ કરવા અને તમારી પોતાની પુનઃઉપયોગી, ટાઇપ-સલામત અમુર્તીકરણ લખવા બંને માટે આવશ્યક છે। ચૂંકે જેનરિક્સ C# ના કલેકશન્સ અને ફ્રેમવર્કના મોટા ભાગને અધોરણ આપે છે, અને કારણ કે તેઓ પુનઃઉપયોગી ટાઇપ-સલામત કોડની કી છે, જેનરિક્સ અને કન્સ્ટ્રેઇન્ટ્સમાં માસ્ટરી C# ડેવલપમેન્ટ માટે અસરકારક માટે મૂળ, વારંવાર-લાગુ જ્ઞાન છે અને ટાઇપ-સલામત, પુનઃઉપયોગી ડિઝાઇનને સમજવા પ્રતિબિંબિત કરતું સામાન્ય વિષય છે।