C# Academy · Lektion

where-Einschränkungen

Schränken Sie Typparameter ein.

where-Einschränkungen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum es Constraints gibt

Standardmäßig wird ein Typparameter T fast wie object behandelt, sodass der Compiler nur sehr wenige Operationen darauf zulässt. Constraints, die mit where geschrieben werden, teilen dem Compiler mehr über T mit.

Mit diesem Wissen können Sie Methoden aufrufen, Instanzen erstellen oder Werte sicher vergleichen.

void Show<T>(T value) where T : IFormattable
{
    // now ToString(format, provider) is available
}

Interface-Constraints

Ein Interface-Constraint verlangt, dass T ein bestimmtes Interface implementiert. Der Methodenrumpf kann dann die Member dieses Interfaces aufrufen.

Unten garantiert where T : IComparable<T>, dass eine CompareTo-Methode vorhanden ist.

T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

Constraints für Basisklassen

Sie können verlangen, dass T von einer bestimmten Basisklasse abgeleitet ist. Dann können Member dieses Basistyps im generischen Code verwendet werden.

Das ist in Frameworks üblich, in denen alle Entitäten einen gemeinsamen Basistyp haben.

class Animal { public string Name = ""; }

string NameOf<T>(T a) where T : Animal => a.Name;

Der class-Constraint

where T : class verlangt, dass T ein Referenztyp ist. Dadurch sind die Zuweisung von null und Vergleiche auf Referenzgleichheit möglich.

Das ist typisch für Repositories, Caches und alles, was möglicherweise null enthaltende Referenzen speichert.

T? FindOrNull<T>(bool found, T value) where T : class
    => found ? value : null;

Der struct-Constraint

where T : struct verlangt, dass T ein nicht nullfähiger Werttyp ist. Dadurch können Sie T als Werttyp behandeln und T? als nullfähigen Werttyp verwenden.

Das wird von Hilfsfunktionen verwendet, die nur mit Zahlen, Enumerationen oder kleinen Strukturen arbeiten.

T? AsNullable<T>(T value) where T : struct
    => value;

Der new()-Constraint

Der Constraint new() verlangt, dass T einen öffentlichen parameterlosen Konstruktor besitzt. Im Methodenrumpf kann dann new T() geschrieben werden.

Factories und Object Pools nutzen dies, um generisch Instanzen zu erstellen.

using System;

class Program
{
    static T Make<T>() where T : new() => new T();

    static void Main()
    {
        var list = Make<System.Collections.Generic.List<int>>();
        Console.WriteLine(list.Count);
    }
}

Constraints kombinieren

Sie können mehrere Constraints auf einen Parameter anwenden. Die Reihenfolge verlangt zuerst class oder struct, danach die Basisklasse, dann die Interfaces und zuletzt new().

Die Constraints werden nach einem einzelnen where durch Kommas getrennt aufgelistet.

T Build<T>() where T : class, IComparable<T>, new()
    => new T();

Mehrere where-Klauseln

Wenn eine Methode oder Klasse mehrere Typparameter besitzt, erhält jeder seine eigene where-Klausel. Diese werden nacheinander geschrieben.

So bleiben die Constraints für jeden Parameter klar voneinander getrennt.

TResult Convert<TInput, TResult>(TInput x)
    where TInput : class
    where TResult : new()
    => new TResult();

Ein ausführbares Constraint-Beispiel

Dieses vollständige Programm verwendet einen IComparable<T>-Constraint, um den größeren von zwei Werten zu ermitteln, und funktioniert sowohl mit Ganzzahlen als auch mit Zeichenfolgen.

Der Constraint macht den Aufruf von CompareTo innerhalb der Methode zulässig.

using System;

class Program
{
    static T Max<T>(T a, T b) where T : IComparable<T>
        => a.CompareTo(b) >= 0 ? a : b;

    static void Main()
    {
        Console.WriteLine(Max(3, 9));
        Console.WriteLine(Max("apple", "pear"));
    }
}

Die Constraints notnull und unmanaged

Neuere C#-Versionen fügen weitere Constraints hinzu. where T : notnull verbietet nullfähige Typen und ist für Dictionary-Schlüssel nützlich. where T : unmanaged beschränkt T für hardwarenahe Programmierung auf blittable Werttypen.

Diese Constraints erhöhen die Sicherheit in spezialisierten Szenarien.

void Use<T>(T key) where T : notnull { }

unsafe void Raw<T>(T v) where T : unmanaged { }

Constraints ermöglichen mehr, statt nur einzuschränken

Obwohl sie wie Einschränkungen aussehen, erschließen Constraints tatsächlich zusätzliche Möglichkeiten. Ohne einen Constraint können Sie kaum auf T zugreifen; mit einem Constraint erhalten Sie Zugriff auf seine Member.

Wählen Sie den kleinstmöglichen Constraint, der Ihren Algorithmus ermöglicht, damit der Typparameter so flexibel wie möglich bleibt.

// No constraint: only object members available
string Name<T>(T x) => x.ToString();

Kurztest

Testen Sie Ihr Verständnis von where-Constraints.

Zusammenfassung

Die where-Klausel schränkt Typparameter ein: durch ein Interface, eine Basisklasse, class, struct, new(), notnull oder unmanaged. Jeder Constraint erschließt bestimmte Operationen für T.

Halten Sie die richtige Reihenfolge ein, verwenden Sie eine Klausel pro Parameter und wählen Sie den kleinstmöglichen Constraint, den Ihr Algorithmus benötigt.

Häufig gestellte Fragen

Ist die Lektion „where-Einschränkungen“ kostenlos?

Ja — der vollständige Text von „where-Einschränkungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „where-Einschränkungen“?

Schränken Sie Typparameter ein. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „where-Einschränkungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy