Exportar (0) Imprimir
Expandir todo
Expandir Minimizar
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Type.DeclaringMethod (Propiedad)

Obtiene un objeto MethodBase que representa el método de declaración siempre que el objeto Type actual represente un parámetro de tipo de un método genérico.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

public virtual MethodBase DeclaringMethod { get; }

Valor de propiedad

Tipo: System.Reflection.MethodBase
MethodBase que representa el método de declaración si el objeto Type actual representa un parámetro de tipo de un método genérico; de lo contrario, null.

El método de declaración es una definición de método genérico. Es decir, si la propiedad DeclaringMethod no devuelve null, DeclaringMethod.IsGenericMethodDefinition devuelve true.

Las propiedades DeclaringType y DeclaringMethod identifican la definición de tipo genérico o la definición de método genérico en la que se definió inicialmente el parámetro de tipo genérico.

  • Si la propiedad DeclaringMethod devuelve una clase MethodInfo, esa clase MethodInfo representa una definición de método genérico y el objeto Type actual representa un parámetro de tipo de esa definición de método genérico.

  • Si la propiedad DeclaringMethod devuelve null, la propiedad DeclaringType siempre devuelve un objeto Type que representa una definición de tipo genérico y el objeto Type actual representa un parámetro de tipo de esa definición de tipo genérico.

  • La obtención de la propiedad DeclaringMethod en un tipo cuya propiedad IsGenericParameter es false produce una excepción InvalidOperationException.

El objeto MethodBase que devuelve la propiedad DeclaringMethod puede ser MethodInfo en el caso de un método genérico o ConstructorInfo en el caso de un constructor genérico.

NotaNota

En .NET Framework versión 2.0, no se admiten los constructores genéricos.

Si desea obtener una lista de las condiciones invariables para términos que se utilizan en la reflexión genérica, vea los comentarios de la propiedad IsGenericType.

En el código de ejemplo siguiente se define una clase que tiene un método genérico, se asigna un argumento de tipo al método y se invoca al método genérico construido resultante. También se muestra información acerca de la definición de método genérico y del método construido. Cuando se muestra información acerca de los parámetros de tipo de la definición de método genérico, en el método DisplayGenericMethodInfo, el código de ejemplo muestra el valor de la propiedad DeclaringMethod para el parámetro de tipo genérico del método.


using System;
using System.Reflection;

// Define a class with a generic method.
public class Example
{
    public static void Generic<T>(T toDisplay)
    {
        Console.WriteLine("\r\nHere it is: {0}", toDisplay);
    }
}

public class Test
{
    public static void Main()
    {
        Console.WriteLine("\r\n--- Examine a generic method.");

        // Create a Type object representing class Example, and
        // get a MethodInfo representing the generic method.
        //
        Type ex = typeof(Example);
        MethodInfo mi = ex.GetMethod("Generic");

        DisplayGenericMethodInfo(mi);

        // Assign the int type to the type parameter of the Example 
        // method.
        //
        MethodInfo miConstructed = mi.MakeGenericMethod(typeof(int));

        DisplayGenericMethodInfo(miConstructed);

        // Invoke the method.
        object[] args = {42};
        miConstructed.Invoke(null, args);

        // Invoke the method normally.
        Example.Generic<int>(42);

        // Get the generic type definition from the closed method,
        // and show it's the same as the original definition.
        //
        MethodInfo miDef = miConstructed.GetGenericMethodDefinition();
        Console.WriteLine("\r\nThe definition is the same: {0}",
            miDef == mi);
    }

    private static void DisplayGenericMethodInfo(MethodInfo mi)
    {
        Console.WriteLine("\r\n{0}", mi);

        Console.WriteLine("\tIs this a generic method definition? {0}", 
            mi.IsGenericMethodDefinition);

        Console.WriteLine("\tIs it a generic method? {0}", 
            mi.IsGenericMethod);

        Console.WriteLine("\tDoes it have unassigned generic parameters? {0}", 
            mi.ContainsGenericParameters);

        // 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);
                }
            }
        }
    }
}

/* This example produces the following output:

--- Examine a generic method.

Void Generic[T](T)
        Is this a generic method definition? True
        Is it a generic method? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                T  parameter position 0
                   declaring method: Void Generic[T](T)

Void Generic[Int32](Int32)
        Is this a generic method definition? False
        Is it a generic method? True
        Does it have unassigned generic parameters? False
        List type arguments (1):
                System.Int32

Here it is: 42

Here it is: 42

The definition is the same: True

 */


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft