GenericParameterAttributes Výčet

Definice

Obor názvů:

System.Reflection

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

GenericParameterAttributes.cs

Popisuje omezení obecného typu parametru obecného typu nebo metody.

Tento výčet podporuje bitové kombinace hodnot jeho členů.

public enum class GenericParameterAttributes

[System.Flags]
public enum GenericParameterAttributes

[<System.Flags>]
type GenericParameterAttributes = 

Public Enum GenericParameterAttributes

Dědičnost

Object

ValueType

Enum

GenericParameterAttributes

Atributy

FlagsAttribute

Pole

Name	Hodnota	Description
None	0	Neexistují žádné zvláštní příznaky.
Covariant	1	Parametr obecného typu je kovariantní. Kovariantní parametr typu se může objevit jako typ výsledku metody, typ pole jen pro čtení, deklarovaný základní typ nebo implementované rozhraní.
Contravariant	2	Parametr obecného typu je kontravariantní. Parametr kontravariantního typu se může zobrazit jako typ parametru v podpisech metody.
VarianceMask	3	Vybere kombinaci všech příznaků rozptylu. Tato hodnota je výsledkem použití logického operátoru OR ke kombinování následujících příznaků: Contravariant a Covariant.
ReferenceTypeConstraint	4	Typ lze nahradit parametrem obecného typu pouze v případě, že se jedná o odkazový typ.
NotNullableValueTypeConstraint	8	Typ může být nahrazen parametrem obecného typu pouze v případě, že se jedná o typ hodnoty a není nullable.
DefaultConstructorConstraint	16	Typ lze nahradit parametrem obecného typu pouze v případě, že má konstruktor bez parametrů.
SpecialConstraintMask	28	Vybere kombinaci všech speciálních příznaků omezení. Tato hodnota je výsledkem použití logického operátoru OR ke kombinování následujících příznaků: DefaultConstructorConstraint, ReferenceTypeConstrainta NotNullableValueTypeConstraint.
AllowByRefLike	32	Parametr obecného typu může být ByRefLike.

Příklady

Následující příklad kódu definuje obecný typ Test se dvěma parametry typu. Druhý parametr typu má omezení základní třídy a omezení typu odkazu. Při spuštění programu jsou omezení zkoumána pomocí Type.GenericParameterAttributes vlastnosti a Type.GetGenericParameterConstraints metody.

using System;
using System.Reflection;

// Define a sample interface to use as an interface constraint.
public interface ITest {}

// Define a base type to use as a base class constraint.
public class Base {}

// Define the generic type to examine. The first generic type parameter,
// T, derives from the class Base and implements ITest. This demonstrates
// a base class constraint and an interface constraint. The second generic 
// type parameter, U, must be a reference type (class) and must have a 
// default constructor (new()). This demonstrates special constraints.
//
public class Test<T,U> 
    where T : Base, ITest 
    where U : class, new() {}

// Define a type that derives from Base and implements ITest. This type
// satisfies the constraints on T in class Test.
public class Derived : Base, ITest {}

public class Example
{
    public static void Main()
    {
        // To get the generic type definition, omit the type
        // arguments but retain the comma to indicate the number
        // of type arguments. 
        //
        Type def = typeof(Test<,>);
        Console.WriteLine("\r\nExamining generic type {0}", def);

        // Get the type parameters of the generic type definition,
        // and display them.
        //
        Type[] defparams = def.GetGenericArguments();
        foreach (Type tp in defparams)
        {
            Console.WriteLine("\r\nType parameter: {0}", tp.Name);
            Console.WriteLine("\t{0}", 
                ListGenericParameterAttributes(tp));

            // List the base class and interface constraints. The
            // constraints are returned in no particular order. If 
            // there are no class or interface constraints, an empty
            // array is returned.
            //
            Type[] tpConstraints = tp.GetGenericParameterConstraints();
            foreach (Type tpc in tpConstraints)
            {
                Console.WriteLine("\t{0}", tpc);
            }
        }
    }

    // List the variance and special constraint flags. 
    //
    private static string ListGenericParameterAttributes(Type t)
    {
        string retval;
        GenericParameterAttributes gpa = t.GenericParameterAttributes;
        GenericParameterAttributes variance = gpa & 
            GenericParameterAttributes.VarianceMask;

        // Select the variance flags.
        if (variance == GenericParameterAttributes.None)
        {
            retval = "No variance flag;";
        }
        else
        {
            if ((variance & GenericParameterAttributes.Covariant) != 0)
                retval = "Covariant;";
            else
                retval = "Contravariant;";
        }

        // Select 
        GenericParameterAttributes constraints = gpa & 
            GenericParameterAttributes.SpecialConstraintMask;

        if (constraints == GenericParameterAttributes.None)
        {
            retval += " No special constraints";
        }
        else
        {
            if ((constraints & GenericParameterAttributes.ReferenceTypeConstraint) != 0)
                retval += " ReferenceTypeConstraint";
            if ((constraints & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0)
                retval += " NotNullableValueTypeConstraint";
            if ((constraints & GenericParameterAttributes.DefaultConstructorConstraint) != 0)
                retval += " DefaultConstructorConstraint";
        }

        return retval;
    }
}
/* This example produces the following output:

Examining generic type Test`2[T,U]

Type parameter: T
        No variance flag; no special constraints.
        Base
        ITest

Type parameter: U
        No variance flag; ReferenceTypeConstraint DefaultConstructorConstraint
 */

Imports System.Reflection

' Define a sample interface to use as an interface constraint.
Public Interface ITest
End Interface 

' Define a base type to use as a base class constraint.
Public Class Base
End Class 

' Define the generic type to examine. The first generic type parameter,
' T, derives from the class Base and implements ITest. This demonstrates
' a base class constraint and an interface constraint. The second generic 
' type parameter, U, must be a reference type (Class) and must have a 
' default constructor (New). This demonstrates special constraints.
'
Public Class Test(Of T As {Base, ITest}, U As {New, Class}) 
End Class

' Define a type that derives from Base and implements ITtest. This type
' satisfies the constraints on T in class Test.
Public Class Derived
    Inherits Base
    Implements ITest
End Class 

Public Class Example
    
    Public Shared Sub Main() 
        ' To get the generic type definition, omit the type
        ' arguments but retain the comma to indicate the number
        ' of type arguments. 
        '
        Dim def As Type = GetType(Test(Of ,))
        Console.WriteLine(vbCrLf & "Examining generic type {0}", def)
        
        ' Get the type parameters of the generic type definition,
        ' and display them.
        '
        Dim defparams() As Type = def.GetGenericArguments()
        For Each tp As Type In defparams

            Console.WriteLine(vbCrLf & "Type parameter: {0}", tp.Name)
            Console.WriteLine(vbTab & ListGenericParameterAttributes(tp))
            
            ' List the base class and interface constraints. The
            ' constraints do not appear in any particular order. An
            ' empty array is returned if there are no constraints.
            '
            Dim tpConstraints As Type() = _
                tp.GetGenericParameterConstraints()
            For Each tpc As Type In  tpConstraints
                Console.WriteLine(vbTab & tpc.ToString())
            Next tpc
        Next tp
    
    End Sub 
    
    ' List the variance and special constraint flags.
    '
    Private Shared Function ListGenericParameterAttributes(ByVal t As Type) As String 
        Dim retval As String
        Dim gpa As GenericParameterAttributes = t.GenericParameterAttributes

        ' Select the variance flags.
        Dim variance As GenericParameterAttributes = _
            gpa And GenericParameterAttributes.VarianceMask
        
        If variance = GenericParameterAttributes.None Then
            retval = "No variance flag;"
        Else
            If (variance And GenericParameterAttributes.Covariant) <> 0 Then
                retval = "Covariant;"
            Else
                retval = "Contravariant;"
            End If
        End If 

        ' Select the constraint flags.
        Dim constraints As GenericParameterAttributes = _
            gpa And GenericParameterAttributes.SpecialConstraintMask
        
        If constraints = GenericParameterAttributes.None Then
            retval &= " no special constraints."
        Else
            If (constraints And GenericParameterAttributes.ReferenceTypeConstraint) <> 0 Then
                retval &= " ReferenceTypeConstraint"
            End If
            If (constraints And GenericParameterAttributes.NotNullableValueTypeConstraint) <> 0 Then
                retval &= " NotNullableValueTypeConstraint"
            End If
            If (constraints And GenericParameterAttributes.DefaultConstructorConstraint) <> 0 Then
                retval &= " DefaultConstructorConstraint"
            End If
        End If 
        Return retval
    
    End Function 
End Class 
' This example produces the following output:
'
'Examining generic type Test`2[T,U]
'
'Type parameter: T
'        No variance flag; no special constraints.
'        Base
'        ITest
'
'Type parameter: U
'        No variance flag; ReferenceTypeConstraint DefaultConstructorConstraint
'

Poznámky

Členové výčtu GenericParameterAttributes jsou rozděleni do dvou skupin, skupiny odchylek a zvláštní skupiny omezení. Chcete-li otestovat GenericParameterAttributes hodnotu pro příznaky rozptylu, nejprve proveďte bitové operace AND s varianceMask. Pokud je výsledkem Žádný, nejsou žádné příznaky odchylky. Podobně použijte SpeciálníConstraintMask k otestování pro příznaky omezení.