Type.GenericParameterAttributes Propriedade

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Obtém uma combinação de GenericParameterAttributes sinalizadores que descrevem a covariância e restrições especiais do parâmetro de tipo genérico atual.

C#

public virtual System.Reflection.GenericParameterAttributes GenericParameterAttributes { get; }

Valor da propriedade

GenericParameterAttributes

Uma combinação bit a bit de valores GenericParameterAttributes que descrevem a covariância e restrições especiais do parâmetro de tipo genérico atual.

Exceções

InvalidOperationException

O objeto Type atual não é um parâmetro de tipo genérico. Ou seja, a propriedade IsGenericParameter do método retorna false.

NotSupportedException

O método chamado não é suportado na classe base.

Exemplos

O exemplo de código a seguir define um tipo genérico Test com dois parâmetros de tipo que têm restrições diferentes. Quando o programa é executado, as restrições são examinadas usando a GenericParameterAttributes propriedade e o método GetGenericParameterConstraints .

C#

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

Comentários

O valor dessa propriedade contém sinalizadores que descrevem se o parâmetro de tipo genérico atual é covariante e sinalizadores que descrevem quaisquer restrições especiais. Use o GenericParameterAttributes.VarianceMask valor para selecionar os sinalizadores de covariância e use o valor para selecionar os GenericParameterAttributes.SpecialConstraintMask sinalizadores de restrição.

Para obter uma lista das condições invariáveis para termos usados na reflexão genérica, consulte os comentários da propriedade IsGenericType.

Aplica-se a

Confira também

• GetGenericParameterConstraints()
• IsGenericParameter
• Reflexão e tipos genéricos
• Como examinar tipos genéricos e criar instâncias deles com a reflexão