Generiker låter dig skriva klasser och metoder parametriserade med en typ, vilket ger typsäkerhet och återanvändbarhet utan kodduplicering eller casting. Constraints begränsar vilka typer en generisk parameter kan vara, vilket möjliggör säker användning av dess medlemmar. Generiker är genomgripande i C# (hela collections-biblioteket använder dem).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generiker flyttar typfel från runtime (casting object) till kompilering, och eliminerar casts — säker, återanvändbar 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
Constraints (where T : ...) begränsar vad T kan vara, vilket låter dig säkert använda den typens medlemmar (t.ex. begränsning till IComparable<T> låter dig anropa CompareTo). Utan en constraint kan T vara vad som helst, så du kan inte anta några medlemmar.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generiker är fundamentala för C# — de används genomgripande (hela collections-biblioteket, Task<T>, IEnumerable<T> och otaliga API:er är generiska), så att förstå dem är väsentligt för all C#-utveckling.
Generiker löser ett verkligt problem: att skriva återanvändbar kod som fungerar för flera typer samtidigt som typsäkerhet bevaras — alternativet (att använda object och casting) offrar kompileringssäkerhet och kräver felbenägna casts, medan kodduplicering per typ är omaintainable.
Generiker ger dig återanvändbar, typsäker kod utan casting och kompileringstidskontroll av fel. Constraints (where T : ...) är ett viktigt komplement: de begränsar vad en typparameter kan vara, vilket både möjliggör säker användning av typens medlemmar (begränsning till ett gränssnitt låter dig anropa dess metoder) och säkerställer korrekt användning.
Att förstå generiska klasser och metoder, hur typinferens fungerar och constraints (class, struct, new(), gränssnitt/basklass-constraints) är nödvändigt både för att använda de generik-tunga .NET-biblioteken effektivt och för att skriva dina egna återanvändbara, typsäkra abstraktioner.
Säkerhet generiker underbygger C#:s collections och mycket av ramverket, och eftersom de är nyckeln till återanvändbar typsäker kod, är att behärska generiker och constraints grundläggande, ofta använd kunskap för effektiv C#-utveckling och ett vanligt ämne som återspeglar förståelse för typsäker, återanvändbar design.