Korlátok

Ez a témakör azokat a korlátozásokat ismerteti, amelyeket általános típusparaméterekre alkalmazhat egy típusargumentum követelményeinek általános típusban vagy függvényben való megadásához.

Szintaxis

type-parameter-list when constraint1 [ and constraint2]

Megjegyzések

Az általános típusban használható típusok korlátozására számos különböző korlátozás alkalmazható. Az alábbi táblázat felsorolja és ismerteti ezeket a korlátozásokat.

Kényszer	Szintaxis	Leírás
Típusmegkötés	típusparaméter:>típus	A megadott típusnak meg kell egyenlõnek vagy származnia a megadott típusból, vagy ha a típus interfész, akkor a megadott típusnak implementálnia kell az interfészt.
Null kényszer	típusparaméter: null	A megadott típusnak támogatnia kell a null értéket. Ez magában foglalja az összes .NET-objektumtípust, de nem az F# listát, a rekordot, a függvényt, az osztályt, a rekordot vagy az egyesítő típust.
Nem nullelem korlát	típus-paraméter : nem nullás	A megadott típus nem támogatja a null értéket. Ez nem engedélyezi null jegyzetekkel ellátott típusokat és olyan típusokat, amelyek ábrázolási értéke null (például az AllowNullLiteral attribútummal definiált beállítástípus vagy típusok). Ez az általános korlátozás engedélyezi az értéktípusokat, mivel ezek soha nem lehetnek null értékűek.
Explicit tagkorlátozás	[(]típusparaméter [vagy ... vagy típusparaméter)] : (tag-aláírás)	A megadott típusargumentumok legalább egyikének rendelkeznie kell a megadott aláírással rendelkező tagdal; nem közös használatra szántak. A tagokat explicit módon kell definiálni egy implicit típusú bővítmény típusán vagy részén, hogy érvényes célként szerepeljenek egy explicit tagkorlátozás esetében.
Konstruktor korlátozás	type-parameter: ( new : unit -> 'a )	A megadott típusnak paraméter nélküli konstruktorsal kell rendelkeznie.
Értéktípus-korlátozás	type-parameter: struct	A megadott típusnak .NET-értéktípusnak kell lennie.
Hivatkozástípus-korlátozás	típus-paraméter: nem struct	A megadott típusnak .NET-referenciatípusnak kell lennie.
Enumerációs típus korlátozása	típusparaméter: enumeráció<alapértelmezett típusa>	A megadott típusnak felsorolt típusnak kell lennie, amelynek a megadott mögöttes típusa van; nem rendeltetésszerű használatra szánva.
Delegálási kényszer	típusparaméter: delegátum<rekordparaméter-típusú, visszatérési típusú>	A megadott típusnak olyan meghatalmazotttípusnak kell lennie, amely rendelkezik a megadott argumentumokkal és visszatérési értékkel; nem közös használatra szántak.
Összehasonlító kényszer	típusparaméter: összehasonlítás	A megadott típusnak támogatnia kell az összehasonlítást.
Egyenlőségi kényszer	típusparaméter: egyenlőség	A megadott típusnak támogatnia kell az egyenlőséget.
Nem felügyelt kényszer	típusparaméter: nem felügyelt	A megadott típusnak nem felügyelt típusnak kell lennie. A nem felügyelt típusok vagy bizonyos primitív típusok (sbyte, byte, char, nativeint, unativeint, float32, float, int16, uint16, int32, uint32, int64, uint64vagy decimal), enumerálási típusok, nativeptr<_>vagy nem általános szerkezetek, amelyek mezői mind nem felügyelt típusok.

Kényszert kell hozzáadnia, ha a kódnak olyan funkciót kell használnia, amely elérhető a kényszertípuson, de általában nem a típusokon. Ha például a típusmegkötést használja egy osztálytípus megadásához, az osztály bármely metódusát használhatja az általános függvényben vagy típusban.

A típusparaméterek explicit írásakor néha szükség van korlátozások megadására, mert kényszer nélkül a fordító nem tudja ellenőrizni, hogy a használt funkciók elérhetők lesznek-e a típusparaméter futásidejű verziójában.

Az F#-kódban leggyakrabban használt kényszerek az alaposztályokat vagy interfészeket meghatározó típuskorlátozások. A többi korlátozást az F#-kódtár bizonyos funkciók implementálásához használja, például az explicit tagkorlátot, amely az operátorok túlterhelését valósítja meg az aritmetikai operátorok esetében, vagy főként azért, mert az F# támogatja a közös nyelvi futtatókörnyezet által támogatott korlátozások teljes készletét.

A típuskövetkeztetési folyamat során a fordító bizonyos korlátozásokat automatikusan kikövetkeztet. Ha például a + operátort használja egy függvényben, a fordító explicit tagkorlátozást állapít meg a kifejezésben használt változótípusokra vonatkozóan.

Az alábbi kód néhány kényszerdeklarációt szemléltet:

// 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

// Not Null constraint
type Class4<'T when 'T : not null> =
    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

Lásd még:

• Általánosítások