Type.GenericParameterPosition Propiedad

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Source:

Type.cs

Obtiene la posición del parámetro de tipo en la lista de parámetros de tipo del tipo o método genérico que declaró el parámetro, siempre que el objeto Type represente un parámetro de tipo de un tipo genérico o de un método genérico.

C#

public virtual int GenericParameterPosition { get; }

Valor de propiedad

Int32

Posición de un parámetro de tipo en la lista de parámetros de tipo del método o tipo genérico que define el parámetro. Los números de posición comienzan en 0.

Excepciones

InvalidOperationException

El tipo actual no representa un parámetro de tipo. Es decir, IsGenericParameter devuelve false.

Ejemplos

En el ejemplo siguiente se define una clase genérica con dos parámetros de tipo y se define una segunda clase genérica que deriva de la primera clase. La clase base de la clase derivada tiene dos argumentos de tipo: el primero es Int32y el segundo es un parámetro de tipo del tipo derivado. En el ejemplo se muestra información sobre estas clases genéricas, incluidas las posiciones notificadas por la GenericParameterPosition propiedad .

C#

using System;
using System.Reflection;
using System.Collections.Generic;

// Define a base class with two type parameters.
public class Base<T, U> { }

// Define a derived class. The derived class inherits from a constructed
// class that meets the following criteria:
//   (1) Its generic type definition is Base<T, U>.
//   (2) It specifies int for the first type parameter.
//   (3) For the second type parameter, it uses the same type that is used
//       for the type parameter of the derived class.
// Thus, the derived class is a generic type with one type parameter, but
// its base class is an open constructed type with one type argument and
// one type parameter.
public class Derived<V> : Base<int, V> { }

public class Test
{
    public static void Main()
    {
        Console.WriteLine(
            "\r\n--- Display a generic type and the open constructed");
        Console.WriteLine("    type from which it is derived.");

        // Create a Type object representing the generic type definition 
        // for the Derived type, by omitting the type argument. (For
        // types with multiple type parameters, supply the commas but
        // omit the type arguments.) 
        //
        Type derivedType = typeof(Derived<>);
        DisplayGenericTypeInfo(derivedType);

        // Display its open constructed base type.
        DisplayGenericTypeInfo(derivedType.BaseType);
    }

    private static void DisplayGenericTypeInfo(Type t)
    {
        Console.WriteLine("\r\n{0}", t);

        Console.WriteLine("\tIs this a generic type definition? {0}", 
            t.IsGenericTypeDefinition);

        Console.WriteLine("\tIs it a generic type? {0}", 
            t.IsGenericType);

        Console.WriteLine("\tDoes it have unassigned generic parameters? {0}", 
            t.ContainsGenericParameters);

        if (t.IsGenericType)
        {
            // If this is a generic type, display the type arguments.
            //
            Type[] typeArguments = t.GetGenericArguments();

            Console.WriteLine("\tList type arguments ({0}):", 
                typeArguments.Length);

            foreach (Type tParam in typeArguments)
            {
                // IsGenericParameter is true only for generic type
                // parameters.
                //
                if (tParam.IsGenericParameter)
                {
                    Console.WriteLine(
                        "\t\t{0}  (unassigned - parameter position {1})",
                        tParam,
                        tParam.GenericParameterPosition);
                }
                else
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }
    }
}

/* This example produces the following output:

--- Display a generic type and the open constructed
    type from which it is derived.

Derived`1[V]
        Is this a generic type definition? True
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                V  (unassigned - parameter position 0)

Base`2[System.Int32,V]
        Is this a generic type definition? False
        Is it a generic type? True
        Does it have unassigned generic parameters? True
        List type arguments (2):
                System.Int32
                V  (unassigned - parameter position 0)
 */

Comentarios

La GenericParameterPosition propiedad devuelve la posición de un parámetro de tipo en la lista de parámetros de la definición de tipo genérico o la definición de método genérico donde se definió originalmente el parámetro de tipo. Las DeclaringType propiedades y DeclaringMethod identifican el tipo genérico o la definición del método:

• Si la DeclaringMethod propiedad devuelve un MethodInfo, que MethodInfo representa una definición de método genérico y el objeto actual Type representa un parámetro de tipo de esa definición de método genérico.

• Si la DeclaringMethod propiedad devuelve null, la DeclaringType propiedad siempre devuelve un Type objeto que representa una definición de tipo genérico y el objeto actual Type representa un parámetro de tipo de esa definición de tipo genérico.

Para proporcionar el contexto correcto para el valor de la GenericParameterPosition propiedad, es necesario identificar el tipo genérico o el método al que pertenece un parámetro de tipo. Por ejemplo, considere el valor devuelto del método GetSomething genérico en el código siguiente:

C#

public class B<T, U> { }
public class A<V>
{
    public B<V, X> GetSomething<X>()
    {
        return new B<V, X>();
    }
}

El tipo devuelto por GetSomething depende de los argumentos de tipo proporcionados a la clase A y a GetSomething sí mismos. Puede obtener un MethodInfo para GetSomethingy desde el que puede obtener el tipo de valor devuelto. Al examinar los parámetros de tipo del tipo de valor devuelto, GenericParameterPosition devuelve 0 para ambos. La posición de V es 0 porque V es el primer parámetro de tipo de la lista de parámetros de tipo para la clase A. La posición de X es 0 porque X es el primer parámetro de tipo de la lista de parámetros de tipo para GetSomething.

Nota

Al llamar a la GenericParameterPosition propiedad, se produce una excepción si el objeto actual Type no representa un parámetro de tipo. Cuando examine los argumentos de tipo de un tipo construido abierto, utilice la IsGenericParameter propiedad para indicar qué son parámetros de tipo y cuáles son los tipos. La IsGenericParameter propiedad devuelve true para un parámetro de tipo; a continuación, puede usar el GenericParameterPosition método para obtener su posición y usar las DeclaringMethod propiedades y DeclaringType para determinar el método genérico o la definición de tipo que lo define.

Se aplica a

Consulte también

• MakeGenericType(Type[])
• ContainsGenericParameters
• IsGenericParameter
• Reflexión y tipos genéricos
• Cómo: Estudio y creación de instancias de tipos genéricos mediante reflexión