Type.GetGenericArguments Método

Definição

Retorna uma matriz de objetos Type que representam os argumentos de tipo de um tipo genérico fechado ou os parâmetros de tipo de uma definição de tipo genérico.Returns an array of Type objects that represent the type arguments of a closed generic type or the type parameters of a generic type definition.

public:
 virtual cli::array <Type ^> ^ GetGenericArguments();
public virtual Type[] GetGenericArguments ();
abstract member GetGenericArguments : unit -> Type[]
override this.GetGenericArguments : unit -> Type[]
Public Overridable Function GetGenericArguments () As Type()

Retornos

Type[]

Uma matriz de objetos Type que representam os argumentos de tipo de um tipo genérico.An array of Type objects that represent the type arguments of a generic type. Retorna uma matriz vazia se o tipo atual não é um tipo genérico.Returns an empty array if the current type is not a generic type.

Exceções

O método chamado não é suportado na classe base.The invoked method is not supported in the base class. As classes derivadas devem fornecer uma implementação.Derived classes must provide an implementation.

Exemplos

O exemplo de código a seguir GetGenericArguments usa o método para exibir os argumentos de tipo de um tipo construído e os parâmetros de tipo de sua definição de tipo genérico.The following code example uses the GetGenericArguments method to display the type arguments of a constructed type and the type parameters of its generic type definition.

Este exemplo de código faz parte de um exemplo maior fornecido para IsGenericTypeDefinition a propriedade.This code example is part of a larger example provided for the IsGenericTypeDefinition property. Consulte o exemplo maior para saída de exemplo.See the larger example for sample output.

if ( t->IsGenericType )
{
   
   // If this is a generic type, display the type arguments.
   //
   array<Type^>^typeArguments = t->GetGenericArguments();
   Console::WriteLine( L"\tList type arguments ({0}):",
      typeArguments->Length );
   System::Collections::IEnumerator^ myEnum =
      typeArguments->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Type^ tParam = safe_cast<Type^>(myEnum->Current);
      
      // If this is a type parameter, display its
      // position.
      //
      if ( tParam->IsGenericParameter )
      {
         Console::WriteLine(
            L"\t\t{0}\t(unassigned - parameter position {1})",
            tParam, tParam->GenericParameterPosition );
      }
      else
      {
         Console::WriteLine( L"\t\t{0}", tParam );
      }
   }
}
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)
    {
        // If this is a type parameter, display its
        // position.
        //
        if (tParam.IsGenericParameter)
        {
            Console.WriteLine("\t\t{0}\t(unassigned - parameter position {1})",
                tParam,
                tParam.GenericParameterPosition);
        }
        else
        {
            Console.WriteLine("\t\t{0}", tParam);
        }
    }
}
If t.IsGenericType Then
    ' If this is a generic type, display the type arguments.
    '
    Dim typeArguments As Type() = t.GetGenericArguments()
    
    Console.WriteLine(vbTab & "List type arguments (" _
        & typeArguments.Length & "):")
    
    For Each tParam As Type In typeArguments
        ' If this is a type parameter, display its position.
        '
        If tParam.IsGenericParameter Then
            Console.WriteLine(vbTab & vbTab & tParam.ToString() _
                & vbTab & "(unassigned - parameter position " _
                & tParam.GenericParameterPosition & ")")
        Else
            Console.WriteLine(vbTab & vbTab & tParam.ToString())
        End If
    Next tParam
End If

Comentários

Os elementos da matriz são retornados na ordem em que aparecem na lista de argumentos de tipo para o tipo genérico.The array elements are returned in the order in which they appear in the list of type arguments for the generic type.

  • Se o tipo atual for um tipo construído fechado (ou seja, a ContainsGenericParameters Propriedade retornar false), GetGenericArguments a matriz retornada pelo método conterá os tipos que foram atribuídos aos parâmetros de tipo genérico da definição de tipo genérico .If the current type is a closed constructed type (that is, the ContainsGenericParameters property returns false), the array returned by the GetGenericArguments method contains the types that have been assigned to the generic type parameters of the generic type definition.

  • Se o tipo atual for uma definição de tipo genérico, a matriz conterá os parâmetros de tipo.If the current type is a generic type definition, the array contains the type parameters.

  • Se o tipo atual for um tipo construído aberto (ou seja, o ContainsGenericParameters retorno trueda propriedade) no qual tipos específicos não foram atribuídos a todos os parâmetros de tipo e parâmetros de tipo de tipos genéricos delimitadores ou métodos, a matriz conterá os tipos e os parâmetros de tipo.If the current type is an open constructed type (that is, the ContainsGenericParameters property returns true) in which specific types have not been assigned to all of the type parameters and type parameters of enclosing generic types or methods, the array contains both types and type parameters. Use a IsGenericParameter propriedade para diferenciá-las.Use the IsGenericParameter property to tell them apart. Para ver uma demonstração desse cenário, consulte o exemplo de código para ContainsGenericParameters a propriedade.For a demonstration of this scenario, see the code example for the ContainsGenericParameters property.

Para obter uma lista das condições invariáveis para termos usados na reflexão genérica, consulte os comentários da propriedade IsGenericType.For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.

Aplica-se a

Veja também