Generics ਤੁਹਾਨੂੰ classes ਅਤੇ methods ਲਿਖਣ ਦਿੰਦੇ ਹਨ ਜੋ ਕਿ type ਦੁਆਰਾ parameterized ਹੋਣ, type safety ਅਤੇ reusability ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋਏ code ਦੀ duplication ਜਾਂ casting ਤੋਂ ਬਿਨਾਂ। Constraints ਇਹ ਸੀਮਿਤ ਕਰਦੇ ਹਨ ਕਿ generic parameter ਕਿਹੜੀ type ਹੋ ਸਕਦੀ ਹੈ, ਉਨ੍ਹਾਂ ਦੇ members ਦੀ safe ਵਰਤੋਂ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦੇ ਹਨ। Generics C# ਵਿੱਚ ਸਰਵ ਵਿਆਪਕ ਹਨ (ਸਾਰੀ collections library ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ)।
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics type ਦੀਆਂ errors ਨੂੰ runtime (casting object) ਤੋਂ 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> ਤੱਕ constraining ਤੁਹਾਨੂੰ 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# ਲਈ fundamental ਹਨ — ਉਹ ਸਰਵ ਵਿਆਪਕ ਤੌਰ ਉੱਤੇ ਵਰਤੇ ਜਾਂਦੇ ਹਨ (ਸਾਰੀ collections library, Task<T>, IEnumerable<T>, ਅਤੇ ਬਹੁਤ ਸਾਰੇ APIs generic ਹਨ), ਇਸ ਲਈ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਕਿਸੇ ਵੀ C# development ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
Generics ਇੱਕ real problem ਹੱਲ ਕਰਦੇ ਹਨ: reusable code ਲਿਖਣਾ ਜੋ ਕਿ ਕਈ types ਲਈ ਕਾਮ ਕਰਦਾ ਹੈ type safety ਨੂੰ ਸੰਭਾਲਦੇ ਹੋਏ — ਬਦਲ (using object ਅਤੇ casting) compile-time safety ਨੂੰ ਅਜਾਵਕ ਕਰਦਾ ਹੈ ਅਤੇ error-prone casts ਦੀ ਲੋੜ ਕਰਦਾ ਹੈ, ਜਦਕਿ per type code ਨੂੰ duplicate ਕਰਨਾ unmaintainable ਹੈ।
Generics ਤੁਹਾਨੂੰ reusable, type-safe code ਦਿੰਦੇ ਹਨ casting ਤੋਂ ਬਿਨਾਂ ਅਤੇ compile-time error checking ਦੇ ਨਾਲ। Constraints (where T : ...) ਇੱਕ ਮਹੱਤਵਪੂਰਨ complement ਹਨ: ਉਹ type parameter ਨੂੰ ਸੀਮਿਤ ਕਰਦੇ ਹਨ, ਜੋ ਕਿ type ਦੇ members ਦੀ safe ਵਰਤੋਂ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ (interface ਤੱਕ constraining ਤੁਹਾਨੂੰ ਇਸਦੀ methods ਕਾਲ ਕਰਨ ਦਿੰਦਾ ਹੈ) ਅਤੇ correct usage ਨੂੰ ਯਕੀਨੀ ਬਣਾਂਦਾ ਹੈ।
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 ਦੇ ਬਹੁਤ ਸਾਰੇ ਹਿੱਸਿਆਂ ਨੂੰ, ਅਤੇ ਕਿਉਂਕਿ ਉਹ reusable type-safe code ਦੀ ਕੁੰਜੀ ਹਨ, generics ਅਤੇ constraints ਨੂੰ ਮਾਸਟਰ ਕਰਨਾ core, frequently-applied knowledge ਹੈ effective C# development ਅਤੇ type-safe, reusable design ਦੀ ਸਮਝ ਨੂੰ reflect ਕਰਨ ਵਾਲਾ ਇੱਕ ਆਮ ਵਿਸ਼ਾ।