Type.GenericParameterPosition Propriedade

Definição

Namespace:

System

Assemblies:

netstandard.dll, System.Runtime.dll

Origem:

Type.cs

Obtém a posição do parâmetro de tipo, na lista de parâmetros de tipo, do tipo genérico ou do método que declarou o parâmetro, quando o objeto Type representa um parâmetro de tipo de um tipo genérico ou método genérico.

C#

public virtual int GenericParameterPosition { get; }

Valor da propriedade

Int32

A posição de um parâmetro de tipo na lista de parâmetros de tipo do tipo genérico ou método que define o parâmetro . Os números de posição começam em 0.

Exceções

InvalidOperationException

O tipo atual não representa um parâmetro de tipo. Ou seja, IsGenericParameter retorna false.

Exemplos

O exemplo a seguir define uma classe genérica com dois parâmetros de tipo e define uma segunda classe genérica derivada da primeira classe. A classe base da classe derivada tem dois argumentos de tipo: o primeiro é Int32e o segundo é um parâmetro de tipo do tipo derivado. O exemplo exibe informações sobre essas classes genéricas, incluindo as posições relatadas pela GenericParameterPosition propriedade .

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

Comentários

A GenericParameterPosition propriedade retorna a posição de um parâmetro de tipo na lista de parâmetros da definição de tipo genérico ou da definição de método genérico em que o parâmetro de tipo foi originalmente definido. As DeclaringType propriedades e DeclaringMethod identificam o tipo genérico ou a definição de método:

• Se a DeclaringMethod propriedade retornar um MethodInfo, que MethodInfo representa uma definição de método genérico, e o objeto atual Type representará um parâmetro de tipo dessa definição de método genérico.

• Se a DeclaringMethod propriedade retornar null, a DeclaringType propriedade sempre retornará um Type objeto que representa uma definição de tipo genérico e o objeto atual Type representará um parâmetro de tipo dessa definição de tipo genérico.

Para fornecer o contexto correto para o valor da GenericParameterPosition propriedade, é necessário identificar o tipo genérico ou o método ao qual pertence um parâmetro de tipo. Por exemplo, considere o valor retornado do método GetSomething genérico no seguinte código:

C#

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

O tipo retornado por GetSomething depende dos argumentos de tipo fornecidos à classe A e a GetSomething si mesmo. Você pode obter um MethodInfo para e, a GetSomethingpartir disso, você pode obter o tipo de retorno. Quando você examina os parâmetros de tipo do tipo de retorno, GenericParameterPosition retorna 0 para ambos. A posição de V é 0 porque V é o primeiro parâmetro de tipo na lista de parâmetros de tipo para a classe A. A posição de X é 0 porque X é o primeiro parâmetro de tipo na lista de parâmetros de tipo para GetSomething.

Observação

Chamar a GenericParameterPosition propriedade causará uma exceção se o atual Type não representar um parâmetro de tipo. Ao examinar os argumentos de tipo de um tipo construído aberto, use a IsGenericParameter propriedade para informar quais são parâmetros de tipo e quais são tipos. A IsGenericParameter propriedade retorna true para um parâmetro de tipo; você pode usar o GenericParameterPosition método para obter sua posição e usar as DeclaringMethod propriedades e DeclaringType para determinar o método genérico ou a definição de tipo que o define.

Aplica-se a

Confira também

• MakeGenericType(Type[])
• ContainsGenericParameters
• IsGenericParameter
• Reflexão e tipos genéricos
• Como examinar tipos genéricos e criar instâncias deles com a reflexão