Type.GetGenericArguments Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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.

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. Restituisce una matrice vuota se il tipo corrente non è un tipo generico.

Eccezioni

NotSupportedException

Il metodo richiamato non è supportato nella classe base. Le classi derivate devono fornire un'implementazione.

Esempio

Nell'esempio di codice seguente viene utilizzato il metodo per visualizzare gli argomenti di tipo di un tipo costruito e GetGenericArguments i parametri di tipo della relativa definizione di tipo generico.

Questo esempio di codice fa parte di un esempio più ampio fornito per la IsGenericTypeDefinition proprietà . Vedere l'esempio più ampio per l'output di esempio.

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 vengono visualizzati nell'elenco di argomenti di tipo per il tipo generico.

Se il tipo corrente è un tipo costruito chiuso (ovvero la proprietà restituisce ), la matrice restituita dal metodo contiene i tipi assegnati ai parametri di tipo generico della definizione di ContainsGenericParameters false tipo GetGenericArguments generico.
Se il tipo corrente è una definizione di tipo generico, la matrice contiene i parametri di tipo.
Se il tipo corrente è un tipo costruito aperto ,ovvero la proprietà restituisce , in cui tipi specifici non sono stati assegnati a tutti i parametri di tipo e a tutti i parametri di tipo dei tipi o dei metodi generici che racchiudno, la matrice contiene sia tipi che parametri di ContainsGenericParameters true tipo. Usare la IsGenericParameter proprietà per distinguerle. Per una dimostrazione di questo scenario, vedere l'esempio di codice per la ContainsGenericParameters proprietà .

Per un elenco delle condizioni invariabili relative ai termini usati dal processo di reflection generico, vedere i commenti sulla proprietà IsGenericType.

Si applica a