MethodInfo.GetGenericArguments Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Reflection

Assembly:: System.Reflection.dll

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 tipo di un metodo generico o i parametri di tipo della definizione di un metodo generico.

public:
 override cli::array <Type ^> ^ GetGenericArguments();

public override Type[] GetGenericArguments ();

[System.Runtime.InteropServices.ComVisible(true)]
public override Type[] GetGenericArguments ();

override this.GetGenericArguments : unit -> Type[]

[<System.Runtime.InteropServices.ComVisible(true)>]
override this.GetGenericArguments : unit -> Type[]

Public Overrides Function GetGenericArguments () As Type()

Restituisce

Type[]

Matrice di oggetti Type che rappresentano gli argomenti di tipo di un metodo generico o i parametri di tipo della definizione di un metodo generica. Restituisce una matrice vuota se il metodo corrente non è un metodo generico.

Attributi: ComVisibleAttribute

Eccezioni

NotSupportedException

Questo metodo non è supportato.

Esempio

Nell'esempio di codice seguente viene illustrato come ottenere gli argomenti di tipo di un metodo generico e visualizzarli.

Questo esempio fa parte di un esempio più esaustivo fornito per il MakeGenericMethod metodo .

// If this is a generic method, display its type arguments.
//
if (mi->IsGenericMethod)
{
    array<Type^>^ typeArguments = mi->GetGenericArguments();

    Console::WriteLine("\tList type arguments ({0}):", 
        typeArguments->Length);

    for each (Type^ tParam in typeArguments)
    {
        // IsGenericParameter is true only for generic type
        // parameters.
        //
        if (tParam->IsGenericParameter)
        {
            Console::WriteLine("\t\t{0}  parameter position {1}" +
                "\n\t\t   declaring method: {2}",
                tParam,
                tParam->GenericParameterPosition,
                tParam->DeclaringMethod);
        }
        else
        {
            Console::WriteLine("\t\t{0}", tParam);
        }
    }
}

// If this is a generic method, display its type arguments.
//
if (mi.IsGenericMethod)
{
    Type[] typeArguments = mi.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}  parameter position {1}" +
                "\n\t\t   declaring method: {2}",
                tParam,
                tParam.GenericParameterPosition,
                tParam.DeclaringMethod);
        }
        else
        {
            Console.WriteLine("\t\t{0}", tParam);
        }
    }
}

' If this is a generic method, display its type arguments.
'
If mi.IsGenericMethod Then
    Dim typeArguments As Type() = mi.GetGenericArguments()
    
    Console.WriteLine(vbTab & "List type arguments ({0}):", _
        typeArguments.Length)
    
    For Each tParam As Type In typeArguments
        ' IsGenericParameter is true only for generic type
        ' parameters.
        '
        If tParam.IsGenericParameter Then
            Console.WriteLine(vbTab & vbTab _
                & "{0}  parameter position: {1}" _
                & vbCrLf & vbTab & vbTab _
                & "   declaring method: {2}", _
                tParam,  _
                tParam.GenericParameterPosition, _
                tParam.DeclaringMethod)
        Else
            Console.WriteLine(vbTab & vbTab & tParam.ToString())
        End If
    Next tParam
End If

Commenti

Gli elementi della matrice restituita sono nell'ordine in cui vengono visualizzati nell'elenco dei parametri di tipo per il metodo generico.

Se il metodo corrente è un metodo costruito chiuso, ovvero la proprietà restituisce , la matrice restituita dal metodo contiene i tipi assegnati ai parametri di tipo generico della definizione del metodo ContainsGenericParameters false GetGenericArguments generico.
Se il metodo corrente è una definizione di metodo generico, la matrice contiene i parametri di tipo.
Se il metodo corrente è un metodo costruito aperto, ovvero la proprietà restituisce , in cui tipi specifici sono stati assegnati ad alcuni parametri di tipo e i parametri di tipo di tipi che racchiudno tipi generici sono stati assegnati ad altri parametri di tipo, 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 invarianti per termini specifici dei metodi generici, vedere la IsGenericMethod proprietà . Per un elenco delle condizioni invarianti per altri termini usati nella reflection generica, vedere la Type.IsGenericType proprietà .

Si applica a