Generics lader dig skrive klasser og metoder, der er parametriseret efter en type, og giver typesikkerhed og genbrug uden kodeduplikering eller casting. Constraints begrænser hvilke typer en generic parameter kan være, hvilket muliggør sikker brug af deres medlemmer. Generics er udbredt i C# (hele samlingsbiblioteket bruger dem).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics flytter typefejl fra runtime (casting af object) til compiletid og eliminerer casts — sikker, genanvendeligt kode.
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 : ...) begrænser hvad T kan være, hvilket lader dig sikkert bruge den types medlemmer (f.eks. constraint til IComparable<T> lader dig kalde CompareTo). Uden en constraint kunne T være hvad som helst, så du kan ikke antage nogen medlemmer.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generics er fundamental for C# — de bruges udbredt (hele samlingsbiblioteket, Task<T>, IEnumerable<T> og utallige API'er er generic), så forståelse af dem er essentiel for enhver C#-udvikling.
Generics løser et reelt problem: at skrive genanvendeligt kode, der fungerer for flere typer, mens typesikkerhed bevares — alternativet (brug af object og casting) ofrer compiletidssikkerhed og kræver fejlbeviste casts, mens duplikering af kode pr. type er ikke vedligeholdelsesbar.
Generics giver dig genanvendeligt, typesikkert kode uden casting og compile-time fejltjek. Constraints (where T : ...) er et vigtig supplement: de begrænser hvad en typeparameter kan være, hvilket både muliggør sikker brug af typens medlemmer (constraint til et interface lader dig kalde dets metoder) og sikrer korrekt brug.
Forståelse af generic klasser og metoder, hvordan typeinferens virker, og constraints (class, struct, new(), interface/basisklasse-constraints) er nødvendig både for at bruge de generic-intensive .NET-biblioteker effektivt og for at skrive dine egne genanvendelige, typesikre abstraktioner.
Da generics understøtter C#'s samlinger og meget af frameworket, og da de er nøglen til genanvendeligt typesikkert kode, er det at mestre generics og constraints kernekompetence, hyppigt anvendt viden for effektiv C#-udvikling og et almindeligt emne der afspejler forståelse af typesikker, genanvendeligt design.