Generikk lar deg skrive klasser og metoder parameterisert av en type, og gir typesikkerhet og gjenbrukbarhet uten kodeduplisering eller typekonvertering. Constraints begrenser hvilke typer en generisk parameter kan være, og muliggjør sikker bruk av deres medlemmer. Generikk er allestedsstede i C# (hele samlingslibrariet bruker dem).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generikk flytter typefeil fra kjøretid (typekonvertering av object) til kompileringstid, og eliminerer typekonverteringer — sikker, gjenbrukbar 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 : ...) begrenser hva T kan være, noe som lar deg trygt bruke medlemmene til den typen (f.eks. å begrense til IComparable<T> lar deg kalle CompareTo). Uten en constraint kunne T være hva som helst, så du kan ikke anta noen medlemmer.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generikk er grunnleggende for C# — de brukes allestedsstede (hele samlingslibrariet, Task<T>, IEnumerable<T>, og utallige APIer er generiske), så forståelse av dem er essensielt for all C#-utvikling.
Generikk løser et reelt problem: å skrive gjenbrukbar kode som fungerer for flere typer og samtidig bevarer typesikkerhet — alternativet (bruke object og typekonvertering) oppgir kompileringstidssikkerhet og krever feilbare typekonverteringer, mens duplisering av kode per type er ikke vedlikeholdbar.
Generikk gir deg gjenbrukbar, typesikker kode uten typekonvertering og kompileringtidskontroll. Constraints (where T : ...) er et viktig supplement: de begrenser hva en typeparameter kan være, noe som både muliggjør sikker bruk av typens medlemmer (begrensning til et interface lar deg kalle metodene) og sikrer riktig bruk.
Forståelse av generiske klasser og metoder, hvordan typeinferens fungerer, og constraints (class, struct, new(), interface/baseklasse-constraints) er nødvendig både for å bruke de generisk-tungvektede .NET-bibliotekene effektivt og for å skrive dine egne gjenbrukbare, typesikre abstraksjoner.
Da generikk ligger til grunn for C#s samlinger og mye av rammeverket, og siden de er nøkkelen til gjenbrukbar typesikker kode, er det å mestre generikk og constraints kjernekompetanse som brukes hyppig for effektiv C#-utvikling og et vanlig emne som gjenspeiler forståelse av typesikker, gjenbrukbar design.