જેનરિક્સ તમને ક્લાસ અને મેથડ્સ લખવા દે છે જે એક પ્રકાર દ્વારા પેરામેટરાઇજ્ડ હોય છે, ટાઇપ સેફ્ટી અને પુનઃઉપયોગીયતા પ્રદાન કરે છે કોડ ડુપ્લીકેશન અથવા કાસ્ટિંગ વિના। કન્સ્ટ્રેઇન્ટ્સ ઘટાડે છે કે જેનરિક પેરામીટર કયા પ્રકાર હોઈ શકે છે, તેમના સભ્યોનો સલામત ઉપયોગ સક્ષમ કરે છે। જેનરિક્સ C# માં વ્યાપક છે (સમગ્ર કલેકશન્સ લાઇબ્રેરી તેમનો ઉપયોગ કરે છે)।
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
જેનરિક્સ ટાઇપ ભૂલોને રનટાઇમ (કાસ્ટિંગ 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;
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
કન્સ્ટ્રેઇન્ટ્સ (where T : ...) મર્યાદિત કરે છે કે T શું હોઈ શકે છે, જે તમને તે પ્રકારના સભ્યોનો સલામતથી ઉપયોગ કરવા દે છે (દા. તરીકે, IComparable<T> માં અવરોધ લગાવવો તમને CompareTo કહેવા દે છે)। કોઇ અવરોધ વિના, T કંઇ પણ હોઈ શકે છે, તેથી તમે કોઇ સભ્યો ધારણ કરી શકતા નથી।
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 નો ઉપયોગ અને કાસ્ટિંગ) કમ્પાઇલ-સમે સલામતીનો ત્યાગ કરે છે અને ભૂલ-પ્રવણ કાસ્ટ્સ જરૂરી કરે છે, જ્યારે પ્રતિ પ્રકાર કોડ ડુપ્લીકેટ કરવું અસ્થાયી છે।
જેનરિક્સ તમને પુનઃઉપયોગી, ટાઇપ-સલામત કોડ આપે છે કોઇ કાસ્ટિંગ અને કમ્પાઇલ-સમે ભૂલ તપાસ વિના। કન્સ્ટ્રેઇન્ટ્સ (where T : ...) એક મહત્વપૂર્ણ પૂરક છે: તેઓ મર્યાદિત કરે છે કે ટાઇપ પેરામીટર શું હોઈ શકે છે, જે તે પ્રકારના સભ્યોનો સલામત ઉપયોગ સક્ષમ કરે છે (ઇન્ટરફેસમાં અવરોધ લગાવવો તમને તેની મેથડ્સ કહેવા દે છે) અને સાચો ઉપયોગ સુનિશ્ચિત કરે છે।
જેનરિક ક્લાસ અને મેથડ્સને સમજવું, કીવી પ્રકાર અનુમાન કાર્ય કરે છે, અને કન્સ્ટ્રેઇન્ટ્સ (class, struct, new(), ઇન્ટરફેસ/બેઝ-ક્લાસ કન્સ્ટ્રેઇન્ટ્સ) કોઇ પણ જેનરિક-ભારે .NET લાઇબ્રેરીઓ અસરકારક રીતે ઉપયોગ કરવા અને તમારી પોતાની પુનઃઉપયોગી, ટાઇપ-સલામત અમુર્તીકરણ લખવા બંને માટે આવશ્યક છે।
ચૂંકે જેનરિક્સ C# ના કલેકશન્સ અને ફ્રેમવર્કના મોટા ભાગને અધોરણ આપે છે, અને કારણ કે તેઓ પુનઃઉપયોગી ટાઇપ-સલામત કોડની કી છે, જેનરિક્સ અને કન્સ્ટ્રેઇન્ટ્સમાં માસ્ટરી C# ડેવલપમેન્ટ માટે અસરકારક માટે મૂળ, વારંવાર-લાગુ જ્ઞાન છે અને ટાઇપ-સલામત, પુનઃઉપયોગી ડિઝાઇનને સમજવા પ્રતિબિંબિત કરતું સામાન્ય વિષય છે।
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો