Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês
Esta documentação foi arquivada e não está sendo atualizada.

Propriedade Type.GenericParameterPosition

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

Namespace:  System
Assembly:  mscorlib (em mscorlib.dll)

public virtual int GenericParameterPosition { get; }

Valor de propriedade

Tipo: System.Int32
A posição de um parâmetro de tipo na lista Tipo de parâmetro de tipo genérico ou método que define o parâmetro.Os números de posição começam com 0.

ExceçãoCondição
InvalidOperationException

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

The 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 método genérico definição onde o parâmetro de tipo foi definido originalmente. The DeclaringType e DeclaringMethod Propriedades identificam a definição de tipo ou método genérica:

  • Se o DeclaringMethod propriedade para retornar uma MethodInfo, que MethodInfo representa uma definição de método genérica e corrente Type objeto representa um parâmetro de tipo de definição desse método genérico.

  • Se o DeclaringMethod propriedade para retornar null, o DeclaringType propriedade sempre retorna uma Type objeto que representa uma definição de tipo genérico e corrente Type objeto representa um parâmetro de tipo de definição desse tipo genérico.

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

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 varia de acordo com os argumentos de tipo fornecidos à classe A e GetSomething propriamente dito. Você pode obter um MethodInfo para GetSomething, e da que você pode obter o tipo de retorno. Quando você examinar 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 de classe A. A posição de X é 0 porque X é o primeiro parâmetro de tipo na lista de parâmetro de tipo GetSomething.

ObservaçãoObservação:

Chamando o GenericParameterPosition propriedade faz com que uma exceção se o corrente Type não representa um parâmetro de tipo. Ao examinar os argumentos de tipo de um tipo construído em aberto, use o IsGenericParameter propriedade dizer que são parâmetros de tipo e quais são os tipos. The IsGenericParameter propriedade para retornar true um parâmetro de tipo; em seguida, você pode usar o GenericParameterPosition método obter sua posição e usar o DeclaringMethod e DeclaringType propriedades para determinar o método genérico ou digite a definição de que a define.

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

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

// Define a base class with two type parameters.publicclass 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.publicclass Derived<V> : Base<int, V> { }

publicclass Test
{
    publicstaticvoid 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);
    }

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

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

o.NET Framework e.NET Compact Framework não oferecem suporte a todas as versões de cada plataforma. Para obter uma lista de versões suportadas, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0
Mostrar: