Leer en inglés

Compartir a través de


GenericParameterAttributes Enumeración

Definición

Describe las restricciones de un parámetro de tipo genérico de un tipo genérico o método.

Esta enumeración admite una combinación bit a bit de sus valores de miembro.

[System.Flags]
public enum GenericParameterAttributes
Herencia
GenericParameterAttributes
Atributos

Campos

AllowByRefLike 32

El parámetro de tipo genérico puede ser ByRefLike.

Contravariant 2

El parámetro de tipo genérico es contravariante. Un parámetro de tipo contravariante puede aparecer como un tipo de parámetro en firmas de método.

Covariant 1

El parámetro de tipo genérico es covariante. Un parámetro de tipo covariante puede aparecer como el tipo de resultado de un método, el tipo de un campo de solo lectura, un tipo base declarado o una interfaz implementada.

DefaultConstructorConstraint 16

Un tipo se puede sustituir por el parámetro de tipo genérico solo si tiene un constructor sin parámetros.

None 0

No hay banderas especiales.

NotNullableValueTypeConstraint 8

Un tipo se puede sustituir por el parámetro de tipo genérico solo si es un tipo de valor y no admite valores NULL.

ReferenceTypeConstraint 4

Un tipo se puede sustituir por el parámetro de tipo genérico solo si es un tipo de referencia.

SpecialConstraintMask 28

Selecciona la combinación de todas las marcas de restricción especiales. Este valor es el resultado del uso de OR lógico para combinar las marcas siguientes: DefaultConstructorConstraint, ReferenceTypeConstrainty NotNullableValueTypeConstraint.

VarianceMask 3

Selecciona la combinación de todas las marcas de varianza. Este valor es el resultado de usar or lógico para combinar las marcas siguientes: Contravariant y Covariant.

Ejemplos

En el ejemplo de código siguiente se define un tipo genérico Test con dos parámetros de tipo. El segundo parámetro de tipo tiene una restricción de clase base y una restricción de tipo de referencia. Cuando se ejecuta el programa, las restricciones se examinan mediante la propiedad Type.GenericParameterAttributes y el método Type.GetGenericParameterConstraints.

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

Comentarios

Los miembros de la enumeración GenericParameterAttributes se dividen en dos grupos, el grupo de varianza y el grupo de restricciones especiales. Para probar un valor de GenericParameterAttributes para las marcas de varianza, primero realice una operación AND bit a bit con VarianceMask. Si el resultado es None, no hay marcas de varianza. Del mismo modo, use SpecialConstraintMask para probar las marcas de restricción.

Se aplica a

Producto Versiones
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1
UWP 10.0