MethodInfo.GetGenericArguments Método

Definición

Espacio de nombres:

System.Reflection

Ensamblado:

System.Runtime.dll

Source:

MethodInfo.cs

Devuelve una matriz de objetos Type que representan los argumentos de tipo de un método genérico o los parámetros de tipo de una definición de método genérico.

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

public override Type[] GetGenericArguments ();

override this.GetGenericArguments : unit -> Type[]

Public Overrides Function GetGenericArguments () As Type()

Devoluciones

Type[]

Una matriz de objetos Type que representan los argumentos de tipo de un método genérico o los parámetros de tipo de una definición de método genérico. Devuelve una matriz vacía si el método actual no es un método genérico.

Excepciones

NotSupportedException

No se admite este método.

Ejemplos

En el ejemplo de código siguiente se muestra cómo obtener los argumentos de tipo de un método genérico y mostrarlos.

Este ejemplo forma parte de un ejemplo más grande proporcionado para el MakeGenericMethod método .

// 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

Comentarios

Los elementos de la matriz devuelta están en el orden en que aparecen en la lista de parámetros de tipo para el método genérico.

• Si el método actual es un método construido cerrado (es decir, la ContainsGenericParameters propiedad devuelve false), la matriz devuelta por el GetGenericArguments método contiene los tipos que se han asignado a los parámetros de tipo genérico de la definición de método genérico.

• Si el método actual es una definición de método genérico, la matriz contiene los parámetros de tipo.

• Si el método actual es un método construido abierto (es decir, la ContainsGenericParameters propiedad devuelve true) en la que se han asignado tipos específicos a algunos parámetros de tipo y parámetros de tipo de los tipos genéricos envolventes se han asignado a otros parámetros de tipo, la matriz contiene ambos tipos y parámetros de tipo. Utilice la IsGenericParameter propiedad para separarlas. Para ver una demostración de este escenario, vea el ejemplo de código de la ContainsGenericParameters propiedad .

Para obtener una lista de las condiciones invariables de los términos específicos de los métodos genéricos, vea la IsGenericMethod propiedad . Para obtener una lista de las condiciones invariables para otros términos usados en la reflexión genérica, vea la Type.IsGenericType propiedad .

Consulte también

• IsGenericMethod
• IsGenericMethodDefinition
• GetGenericMethodDefinition()
• IsGenericType
• Reflexión y tipos genéricos
• Introducción a los genéricos (Guía de programación de C#)