where (Einschränkung des generischen Typs) (C#-Referenz)where (generic type constraint) (C# Reference)

In einer generischen Typdefinition wird die where-Klausel verwendet, um Einschränkungen für Typen anzugeben, die als Argumente für einen Typenparameter in generischen Typen, Methoden, Delegaten oder lokalen Funktionen verwendet werden können.The where clause in a generic definition specifies constraints on the types that are used as arguments for type parameters in a generic type, method, delegate, or local function. Einschränkungen können Schnittstellen und Basisklassen angeben oder erfordern einen generischen Typ als Verweis, Wert oder nicht verwalteten Typ.Constraints can specify interfaces, base classes, or require a generic type to be a reference, value or unmanaged type. Sie deklarieren die Funktionen, die das Typargument besitzen muss.They declare capabilities that the type argument must possess.

So können Sie beispielsweise eine generische Klasse erstellen, MyGenericClass, deren Typparameter T die Schnittstelle IComparable<T> implementiert:For example, you can declare a generic class, MyGenericClass, such that the type parameter T implements the IComparable<T> interface:

public class AGenericClass<T> where T : IComparable<T> { }

Hinweis

Weitere Informationen über die where-Klausel in einem Abfrageausdruck finden Sie unter where-Klausel.For more information on the where clause in a query expression, see where clause.

Die where-Klausel kann auch eine Basisklasseneinschränkung enthalten.The where clause can also include a base class constraint. Die Basisklasseneinschränkung gibt an, dass ein Typ, der als Typargument für den generischen Typ verwendet wird, über die angegebene Klasse als Basisklasse verfügen muss (oder diese Basisklasse sein muss), um als Typargument für diesen generischen Typ verwendet werden zu können.The base class constraint states that a type to be used as a type argument for that generic type has the specified class as a base class (or is that base class) to be used as a type argument for that generic type. Wenn eine Basisklasseneinschränkung verwendet wird, muss sie vor jeder anderen Einschränkung für den Typparameter angezeigt werden.If the base class constraint is used, it must appear before any other constraints on that type parameter. Einige Typen sind nicht als Basisklasseneinschränkungen zulässig: Object, Array und ValueType.Some types are disallowed as a base class constraint: Object, Array, and ValueType. Vor C# 7.3 waren Enum, Delegate und MulticastDelegate ebenfalls nicht als Basisklasseneinschränkungen zulässig.Prior to C# 7.3, Enum, Delegate, and MulticastDelegate were also disallowed as base class constraints. Das folgende Beispiel zeigt die Typen, die jetzt als Basisklasse angegeben werden können:The following example shows the types that can now be specified as a base class:

public class UsingEnum<T> where T : System.Enum { }

public class UsingDelegate<T> where T : System.Delegate { }

public class Multicaster<T> where T : System.MulticastDelegate { }

Die where-Klausel kann angeben, ob der Typ class oder struct ist.The where clause can specify that the type is a class or a struct. Aufgrund der struct-Einschränkung ist die Angabe einer Basisklasseneinschränkung von System.ValueType nicht notwendig.The struct constraint removes the need to specify a base class constraint of System.ValueType. Der System.ValueType-Typ darf nicht als Basisklasseneinschränkung verwendet werden.The System.ValueType type may not be used as a base class constraint. Im folgenden Beispiel werden die class- und struct-Einschränkungen dargestellt:The following example shows both the class and struct constraints:

class MyClass<T, U>
    where T : class
    where U : struct
{ }

Die where-Klausel kann auch eine unmanaged-Einschränkung einschließen.The where clause may also include an unmanaged constraint. Die unmanaged-Einschränkung schränkt den Typparameter auf Typen ein, die als nicht verwaltete Typen bekannt sind.The unmanaged constraint limits the type parameter to types known as unmanaged types. Ein nicht verwalteter Typ ist ein Typ, der kein Verweistyp ist, und keine Verweistypfelder auf Schachtelungsebenen aufweist.An unmanaged type is a type that isn't a reference type and doesn't contain reference type fields at any level of nesting. Die unmanaged-Einschränkung erleichtert das Schreiben von Interop-Code in C# auf niedriger Ebene.The unmanaged constraint makes it easier to write low-level interop code in C#. Diese Einschränkung ermöglicht wiederverwendbare Routinen für alle nicht verwalteten Typen.This constraint enables reusable routines across all unmanaged types. Die unmanaged-Einschränkung kann nicht mit der class- oder struct-Einschränkung kombiniert werden.The unmanaged constraint can't be combined with the class or struct constraint. Die unmanaged-Einschränkung erzwingt, dass der Typ struct sein muss:The unmanaged constraint enforces that the type must be a struct:

class UnManagedWrapper<T>
    where T : unmanaged
{ }

Die where-Klausel kann auch eine new()-Konstruktoreinschränkung einschließen.The where clause may also include a constructor constraint, new(). Diese Einschränkung ermöglicht das Erstellen einer Instanz eines Typparameters unter Verwendung des new-Operators.That constraint makes it possible to create an instance of a type parameter using the new operator. Die new()-Einschränkung informiert den Compiler, dass jedes angegebene Typargument über einen zugänglichen parameterlosen oder Standardkonstruktor verfügen muss.The new() Constraint lets the compiler know that any type argument supplied must have an accessible parameterless--or default-- constructor. Zum Beispiel:For example:

public class MyGenericClass<T> where T : IComparable<T>, new()
{
    // The following line is not possible without new() constraint:
    T item = new T();
}

Die new()-Einschränkung wird in der where-Klausel als Letztes angezeigt.The new() constraint appears last in the where clause. Die new()-Einschränkung kann nicht mit der struct- oder unmanaged-Einschränkung kombiniert werden.The new() constraint can't be combined with the struct or unmanaged constraints. Alle Typen, die diese Einschränkungen erfüllen, müssen einen zugänglichen parameterlosen Konstruktor aufweisen, wodurch die new()-Einschränkung redundant wird.All types satisfying those constraints must have an accessible parameterless constructor, making the new() constraint redundant.

Bei mehreren Typparametern müssen Sie für jeden davon eine eigene where-Klausel verwenden, z.B.:With multiple type parameters, use one where clause for each type parameter, for example:

public interface IMyInterface { }

namespace CodeExample
{
    class Dictionary<TKey, TVal>
        where TKey : IComparable<TKey>
        where TVal : IMyInterface
    {
        public void Add(TKey key, TVal val) { }
    }
}

Sie können auch Einschränkungen wie folgt an Typparameter generischer Methoden anfügen:You can also attach constraints to type parameters of generic methods, as shown in the following example:

public void MyMethod<T>(T t) where T : IMyInterface { }

Beachten Sie, dass die Syntax zum Beschreiben der Parametereinschränkungen für Delegaten mit der Syntax von Methoden identisch ist:Notice that the syntax to describe type parameter constraints on delegates is the same as that of methods:

delegate T MyDelegate<T>() where T : new();

Informationen zu generischen Delegaten finden Sie unter Generic Delegates (Generische Delegaten).For information on generic delegates, see Generic Delegates.

Weitere Informationen zur Syntax und der Verwendung von Einschränkungen finden Sie unter Einschränkungen für Typparameter.For details on the syntax and use of constraints, see Constraints on Type Parameters.

C#-SprachspezifikationC# language specification

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation.For more information, see the C# Language Specification. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.The language specification is the definitive source for C# syntax and usage.

Siehe auchSee also

C#-ReferenzC# Reference
C#-ProgrammierhandbuchC# Programming Guide
Einführung in GenerikaIntroduction to Generics
new-Einschränkungnew Constraint
Einschränkungen für TypparameterConstraints on Type Parameters