Generics ermöglichen es dir, Klassen und Methoden mit einem Typparameter zu schreiben und bieten Typsicherheit und Wiederverwendbarkeit ohne Code-Duplikation oder Casting. Constraints beschränken, welche Typen ein generischer Parameter sein kann, und ermöglichen die sichere Verwendung ihrer Member. Generics sind in C# überall verbreitet (die gesamte Collections-Bibliothek verwendet sie).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics verlagern Typfehler von der Laufzeit (Casting von object) auf die Compile-Zeit und eliminieren Casts — sicherer, wiederverwendbarer Code.
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 : ...) beschränken, was T sein kann, was dir ermöglicht, die Member dieses Typs sicher zu verwenden (z. B. Constraining auf IComparable<T> ermöglicht dir, CompareTo aufzurufen). Ohne einen Constraint könnte T alles sein, daher kannst du keine Member annehmen.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generics sind fundamental für C# — sie werden überall verwendet (die gesamte Collections-Bibliothek, Task<T>, IEnumerable<T> und unzählige APIs sind generisch), daher ist das Verständnis dafür essentiell für jede C#-Entwicklung.
Generics lösen ein echtes Problem: Schreiben von wiederverwendbarem Code, der für mehrere Typen funktioniert, während Typsicherheit gewahrt bleibt — die Alternative (Verwendung von object und Casting) opfert Compile-Zeit-Sicherheit und erfordert fehleranfällige Casts, während Code-Duplikation pro Typ nicht wartbar ist.
Generics geben dir wiederverwendbaren, typsicheren Code ohne Casting und Compile-Zeit-Fehlerprüfung. Constraints (where T : ...) sind eine wichtige Ergänzung: Sie beschränken, was ein Typparameter sein kann, was sowohl die sichere Verwendung der Member des Typs ermöglicht (Constraining auf ein Interface ermöglicht dir, seine Methoden aufzurufen) als auch die korrekte Verwendung gewährleistet.
Das Verständnis von generischen Klassen und Methoden, wie Typinferenz funktioniert, und Constraints (class, struct, new(), Interface/Basis-Klassen-Constraints) ist notwendig, um sowohl die generisch-lastigen .NET-Bibliotheken effektiv zu nutzen als auch deine eigenen wiederverwendbaren, typsicheren Abstraktionen zu schreiben.
Da Generics C#'s Collections und einen großen Teil des Frameworks zugrunde liegen und da sie der Schlüssel zu wiederverwendbarem, typsicheren Code sind, ist das Beherrschen von Generics und Constraints Kernwissen für effektive C#-Entwicklung und ein häufiges Thema, das das Verständnis von typsicherer, wiederverwendbarer Gestaltung widerspiegelt.