MethodInfo.GetGenericArguments Metodo

Definizione

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.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

public:
 override cli::array <Type ^> ^ GetGenericArguments();
[System.Runtime.InteropServices.ComVisible(true)]
public override Type[] GetGenericArguments ();
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.An array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition. Restituisce una matrice vuota se il metodo corrente non è un metodo generico.Returns an empty array if the current method is not a generic method.

Attributi

Eccezioni

Questo metodo non è supportato.This method is not supported.

Esempi

Nell'esempio di codice seguente viene illustrato come ottenere gli argomenti di tipo di un metodo generico e visualizzarli.The following code example shows how to get the type arguments of a generic method and display them.

Questo esempio fa parte di un esempio più ampio fornito per il metodo MakeGenericMethod.This example is part of a larger example provided for the MakeGenericMethod method.

// 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 si trovano nell'ordine in cui sono visualizzati nell'elenco dei parametri di tipo per il metodo generico.The elements of the returned array are in the order in which they appear in the list of type parameters for the generic method.

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

  • Se il metodo corrente è una definizione di metodo generico, la matrice contiene i parametri di tipo.If the current method is a generic method definition, the array contains the type parameters.

  • Se il metodo corrente è un metodo costruito aperto (ovvero, la proprietà ContainsGenericParameters restituisce true) in cui sono stati assegnati tipi specifici ad alcuni parametri di tipo e i parametri di tipo dei tipi generici di inclusione sono stati assegnati ad altri parametri di tipo, la matrice contiene sia i tipi che i parametri di tipo.If the current method is an open constructed method (that is, the ContainsGenericParameters property returns true) in which specific types have been assigned to some type parameters and type parameters of enclosing generic types have been assigned to other type parameters, the array contains both types and type parameters. Utilizzare la proprietà IsGenericParameter per distinguerli.Use the IsGenericParameter property to tell them apart. Per una dimostrazione di questo scenario, vedere l'esempio di codice per la proprietà ContainsGenericParameters.For a demonstration of this scenario, see the code example for the ContainsGenericParameters property.

Per un elenco delle condizioni invariabili per i termini specifici dei metodi generici, vedere la proprietà IsGenericMethod.For a list of the invariant conditions for terms specific to generic methods, see the IsGenericMethod property. Per un elenco delle condizioni invariabili per altri termini usati nella reflection generica, vedere la proprietà Type.IsGenericType.For a list of the invariant conditions for other terms used in generic reflection, see the Type.IsGenericType property.

Si applica a

Vedi anche