Generics stellen je in staat om klassen en methoden te schrijven die geparameteriseerd zijn op een type, wat typeveiligheid en herbruikbaarheid biedt zonder codeduplicatie of casting. Constraints beperken welke typen een generieke parameter kan zijn, wat veilig gebruik van hun leden mogelijk maakt. Generics zijn alomtegenwoordig in C# (de volledige collections-bibliotheek gebruikt ze).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics verplaatsen typefout van runtime (casting object) naar compile-time, en elimineren casts — veilige, herbruikbare 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 : ...) beperken wat T kan zijn, wat je veilig gebruik van dat type's leden mogelijk maakt (bijv. constraining naar IComparable<T> laat je CompareTo aanroepen). Zonder een constraint kan T alles zijn, dus je kunt geen leden aannemen.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generics zijn fundamenteel voor C# — ze worden alomtegenwoordig gebruikt (de volledige collections-bibliotheek, Task<T>, IEnumerable<T>, en talloze API's zijn generiek), dus begrijpen ervan is essentieel voor enige C#-ontwikkeling.
Generics lossen een echt probleem op: herbruikbare code schrijven die voor meerdere typen werkt terwijl je typeveiligheid bewaart — het alternatief (met object en casting) offert compile-time veiligheid op en vereist foutgevoelige casts, terwijl codeduplicatie per type onbeheersbaar is.
Generics geven je herbruikbare, typeveilige code zonder casting en compile-time foutcontrole. Constraints (where T : ...) zijn een belangrijk complement: ze beperken wat een typeparameter kan zijn, wat zowel veilig gebruik van het type's leden mogelijk maakt (constraining naar een interface laat je zijn methoden aanroepen) als correct gebruik garandeert.
Begrijpen van generieke klassen en methoden, hoe type-inferentie werkt, en constraints (class, struct, new(), interface/base-class-constraints) is nodig voor zowel effectief gebruik van de generiek-zware .NET-bibliotheken als het schrijven van je eigen herbruikbare, typeveilige abstracties.
Angezien generics C#'s collections ondersteunen en veel van het framework, en aangezien ze de sleutel zijn tot herbruikbare typeveilige code, is beheersing van generics en constraints kernkennis die frequent wordt toegepast voor effectieve C#-ontwikkeling en een veelvoorkomend onderwerp dat begrijpen van typeveilige, herbruikbare ontwerp weerspiegelt.