Einschränkungen (F#)

In diesem Thema werden Einschränkungen beschrieben, die Sie auf generische Typparameter anwenden können, um die Anforderungen für ein Typargument in einem generischen Typ oder einer generischen Funktion anzugeben.

type-parameter-list when constraint1 [ and constraint2]

Hinweise

Sie können verschiedene Einschränkungen anwenden, um die Typen zu begrenzen, die in einem generischen Typ verwendet werden können.Diese Einschränkungen werden in der folgenden Tabelle aufgeführt und beschrieben.

Sie müssen eine Einschränkung hinzufügen, wenn im Code eine Funktion verwendet werden muss, die für den Einschränkungstyp, jedoch nicht für Typen im Allgemeinen verfügbar ist.Wenn Sie beispielsweise mithilfe der Typeinschränkung einen Klassentyp angeben, können Sie in der generischen Funktion oder im generischen Typ jede Methode dieser Klasse verwenden.

Einschränkungen müssen beim expliziten Schreiben von Typparametern gelegentlich angegeben werden, da ohne Einschränkung der Compiler nicht überprüfen kann, ob die verwendeten Funktionen für jeden Typ verfügbar sind, der zur Laufzeit für den Typparameter angegeben werden kann.

Die häufigsten Einschränkungen, die Sie in F#-Code verwenden, sind Typeinschränkungen, die Basisklassen oder -schnittstellen angeben.Die anderen Einschränkungen werden entweder von der F#-Bibliothek verwendet, um eine bestimmte Funktionalität zu implementieren, z. B. die explizite Membereinschränkung, mithilfe derer Operatorüberladung für arithmetische Operatoren implementiert wird, oder sie werden hauptsächlich bereitgestellt, weil F# alle Einschränkungen unterstützt, die von der Common Language Runtime unterstützt werden.

Während des Typrückschlusses werden einige Einschränkungen automatisch vom Compiler abgeleitet.Wenn Sie z. B. den Operator + in einer Funktion verwenden, leitet der Compiler eine explizite Membereinschränkung für Variablentypen ab, die im Ausdruck verwendet werden.

Der folgende Code veranschaulicht einige Einschränkungsdeklarationen.

// Base Type Constraint
type Class1<'T when 'T :> System.Exception> =
    class end

// Interface Type Constraint
type Class2<'T when 'T :> System.IComparable> = 
    class end

// Null constraint
type Class3<'T when 'T : null> =
    class end

// Member constraint with static member
type Class4<'T when 'T : (static member staticMethod1 : unit -> 'T) > =
    class end

// Member constraint with instance member
type Class5<'T when 'T : (member Method1 : 'T -> int)> =
    class end

// Member constraint with property
type Class6<'T when 'T : (member Property1 : int)> =
    class end

// Constructor constraint
type Class7<'T when 'T : (new : unit -> 'T)>() =
   member val Field = new 'T()

// Reference type constraint
type Class8<'T when 'T : not struct> =
   class end

// Enumeration constraint with underlying value specified
type Class9<'T when 'T : enum<uint32>> =
   class end

// 'T must implement IComparable, or be an array type with comparable
// elements, or be System.IntPtr or System.UIntPtr. Also, 'T must not have
// the NoComparison attribute.
type Class10<'T when 'T : comparison> =
   class end

// 'T must support equality. This is true for any type that does not
// have the NoEquality attribute.
type Class11<'T when 'T : equality> =
   class end

type Class12<'T when 'T : delegate<obj * System.EventArgs, unit>> =
   class end

type Class13<'T when 'T : unmanaged> =
   class end
    
// Member constraints with two type parameters
// Most often used with static type parameters in inline functions
let inline add(value1 : ^T when ^T : (static member (+) : ^T * ^T -> ^T), value2: ^T) =
    value1 + value2

// ^T and ^U must support operator +
let inline heterogenousAdd(value1 : ^T when (^T or ^U) : (static member (+) : ^T * ^U -> ^T), value2 : ^U) =
    value1 + value2

// If there are multiple constraints, use the and keyword to separate them.
type Class14<'T,'U when 'T : equality and 'U : equality> =
    class end

Siehe auch

Referenz

Generika (F#)

Einschränkungen (F#)