Type.GetGenericArguments Type.GetGenericArguments Type.GetGenericArguments Type.GetGenericArguments Method

Definizione

Restituisce una matrice di oggetti Type che rappresentano gli argomenti di tipo di un tipo generico chiuso o i parametri di tipo di una definizione di tipo generico.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()

Restituisce

Type[]

Matrice di oggetti Type che rappresentano gli argomenti di tipo di un tipo generico.An array of Type objects that represent the type arguments of a generic type. Restituisce una matrice vuota se il tipo corrente non è un tipo generico.Returns an empty array if the current type is not a generic type.

Eccezioni

Il metodo richiamato non è supportato nella classe base.The invoked method is not supported in the base class. Le classi derivate devono fornire un'implementazione.Derived classes must provide an implementation.

Esempi

Nell'esempio di codice seguente viene GetGenericArguments usato il metodo per visualizzare gli argomenti di tipo di un tipo costruito e i parametri di tipo della definizione di tipo generico.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.

Questo esempio di codice fa parte di un esempio più ampio fornito IsGenericTypeDefinition per la proprietà.This code example is part of a larger example provided for the IsGenericTypeDefinition property. Vedere l'esempio più ampio per l'output di esempio.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

Commenti

Gli elementi della matrice vengono restituiti nell'ordine in cui sono visualizzati nell'elenco di argomenti di tipo per il tipo generico.The array elements are returned in the order in which they appear in the list of type arguments for the generic type.

  • Se il tipo corrente è un tipo costruito chiuso (ovvero la ContainsGenericParameters proprietà restituisce false), GetGenericArguments la matrice restituita dal metodo contiene i tipi assegnati ai parametri di tipo generico della definizione di tipo generico. .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 il tipo corrente è una definizione di tipo generico, la matrice contiene i parametri di tipo.If the current type is a generic type definition, the array contains the type parameters.

  • Se il tipo corrente è un tipo costruito aperto (ovvero, la ContainsGenericParameters proprietà restituisce true) in cui non sono stati assegnati tipi specifici a tutti i parametri di tipo e ai parametri di tipo dei tipi o metodi generici di inclusione, la matrice contiene tipi e parametri di 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. Utilizzare la IsGenericParameter proprietà per distinguerli.Use the IsGenericParameter property to tell them apart. Per una dimostrazione di questo scenario, vedere l'esempio di codice per ContainsGenericParameters la proprietà.For a demonstration of this scenario, see the code example for the ContainsGenericParameters property.

Per un elenco delle condizioni invariabili relative ai termini usati dal processo di reflection generico, vedere i commenti sulla proprietà IsGenericType.For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.

Si applica a

Vedi anche