Generyki pozwalają pisać klasy i metody sparametryzowane typem, zapewniając bezpieczeństwo typów i ponowną użyteczność bez duplikacji kodu ani castowania. Ograniczenia ograniczają, jakie typy parametr generyczny może być, umożliwiając bezpieczne używanie ich członków. Generyki są wszechobecne w C# (cała biblioteka kolekcji ich używa).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generyki przenoszą błędy typów z czasu wykonania (castowanie object) na czas kompilacji i eliminują casts — bezpieczny, wielokrotnego użytku kod.
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
Ograniczenia (where T : ...) ograniczają, czym może być T, co pozwala ci bezpiecznie używać członków tego typu (np. ograniczenie do IComparable<T> pozwala wywoływać CompareTo). Bez ograniczenia, T mogłoby być czymkolwiek, więc nie możesz zakładać żadnych członków.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generyki są fundamentalne dla C# — są używane wszechobecnie (cała biblioteka kolekcji, Task<T>, IEnumerable<T> i niezliczone interfejsy API są generyczne), więc ich zrozumienie jest niezbędne dla każdego rozwoju w C#.
Generyki rozwiązują rzeczywisty problem: pisanie kodu wielokrotnego użytku, który działa dla wielu typów, jednocześnie zachowując bezpieczeństwo typów — alternatywa (używanie object i castowania) poświęca bezpieczeństwo czasu kompilacji i wymaga podatnych na błędy castów, podczas gdy duplikowanie kodu na typ jest nienadające się do utrzymania.
Generyki dają ci kod wielokrotnego użytku, bezpieczny typowo, bez castowania i sprawdzania błędów w czasie kompilacji. Ograniczenia (where T : ...) są ważnym uzupełnieniem: ograniczają, czym parametr typu może być, co zarówno umożliwia bezpieczne używanie członków tego typu (ograniczenie do interfejsu pozwala wywoływać jego metody) jak i zapewnia poprawne użycie.
Zrozumienie klas i metod generycznych, jak działa wnioskowanie typów i ograniczenia (class, struct, new(), ograniczenia interfejsu/klasy bazowej) jest niezbędne zarówno do efektywnego używania bibliotek .NET obciążonych generykami, jak i pisania własnych abstrakcji wielokrotnego użytku i bezpiecznych typowo.
Ponieważ generyki stanowią fundamenty kolekcji C# i większości frameworku, a ponieważ są kluczem do kodu wielokrotnego użytku i bezpiecznego typowo, opanowanie generyków i ograniczeń jest podstawową, często stosowaną wiedzą dla efektywnego rozwoju w C# i częstym tematem odzwierciedlającym rozumienie bezpiecznego typowo, wielokrotnego użytku projektu.