Generics vă permit să scrieți clase și metode parametrizate după tip, oferind type safety și reutilizabilitate fără duplicare de cod sau casting. Constraints restricționează ce tipuri poate fi un parametru generic, permițând utilizarea sigură a membrilor acestora. Generics sunt omniprezente în C# (întreaga bibliotecă de colecții le utilizează).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics mută erorile de tip de la runtime (casting object) la compile time și elimină castingurile — cod sigur și reutilizabil.
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 : ...) restricționează ce poate fi T, ceea ce vă permite să utilizați în siguranță membrii acelui tip (de exemplu, constrângerea la IComparable<T> vă permite să apelați CompareTo). Fără o constrângere, T ar putea fi orice, deci nu puteți presupune nici un membru.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generics sunt fundamentale pentru C# — sunt utilizate omniprezent (întreaga bibliotecă de colecții, Task<T>, IEnumerable<T> și nenumărate API-uri sunt generice), deci înțelegerea lor este esențială pentru orice dezvoltare C#.
Generics rezolvă o problemă reală: scrierea de cod reutilizabil care funcționează pentru mai multe tipuri, păstrând în același timp type safety — alternativa (utilizarea object și casting) sacrifică siguranța la compile time și necesită casting-uri predispuse la erori, în timp ce duplicarea codului pe tip este imposibil de întreținut.
Generics vă oferă cod reutilizabil și type-safe fără casting și verificare de erori la compile time. Constraints (where T : ...) sunt un complement important: restricționează ce poate fi un parametru de tip, ceea ce atât permite utilizarea sigură a membrilor tipului (constrângerea la o interfață vă permite să apelați metodele acesteia) cât și asigură utilizarea corectă.
Înțelegerea claselor și metodelor generice, modul în care funcționează deducția de tip și constraints (class, struct, new(), constrângeri de interfață/clasă de bază) este necesară atât pentru utilizarea eficientă a bibliotecilor .NET pline de generics cât și pentru scrierea propriilor abstracții reutilizabile și type-safe.
Deoarece generics stau la baza colecțiilor C# și a unei mari părți a framework-ului, și deoarece sunt cheia codului reutilizabil type-safe, stăpânirea generics și constraints este cunoaștere fundamentală, aplicată frecvent, pentru dezvoltarea eficientă a C# și un subiect obișnuit care reflectă înțelegerea design-ului type-safe și reutilizabil.