Type.DeclaringMethod Свойство

Определение

Возвращает метод MethodBase, который представляет объявляемый метод, если текущий Type представляет параметр типа универсального метода.Gets a MethodBase that represents the declaring method, if the current Type represents a type parameter of a generic method.

public:
 virtual property System::Reflection::MethodBase ^ DeclaringMethod { System::Reflection::MethodBase ^ get(); };
public virtual System.Reflection.MethodBase DeclaringMethod { get; }
member this.DeclaringMethod : System.Reflection.MethodBase
Public Overridable ReadOnly Property DeclaringMethod As MethodBase

Значение свойства

Если текущий объект Type представляет параметр типа универсального метода, класс MethodBase, представляющий объявляемый метод; в противном случае — значение null.If the current Type represents a type parameter of a generic method, a MethodBase that represents declaring method; otherwise, null.

Примеры

В следующем примере кода определяется класс, имеющий универсальный метод, который присваивает методу аргумент типа и вызывает созданный универсальный метод.The following code example defines a class that has a generic method, assigns a type argument to the method, and invokes the resulting constructed generic method. Он также отображает сведения об определении универсального метода и сконструированном методе.It also displays information about the generic method definition and the constructed method. При отображении сведений о параметрах типа определения универсального метода в DisplayGenericMethodInfo методе в примере кода показано значение DeclaringMethod свойства для параметра универсального типа метода.When displaying information about the type parameters of the generic method definition, in the DisplayGenericMethodInfo method, the example code shows the value of the DeclaringMethod property for the method's generic type parameter.

using namespace System;
using namespace System::Reflection;

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

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

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 = Example::typeid;
    MethodInfo^ mi = ex->GetMethod("Generic");

    DisplayGenericMethodInfo(mi);

    // Assign the int type to the type parameter of the Example 
    // method.
    //
    MethodInfo^ miConstructed = mi->MakeGenericMethod(int::typeid);

    DisplayGenericMethodInfo(miConstructed);

    // Invoke the method.
    array<Object^>^ args = { 42 };
    miConstructed->Invoke((Object^) 0, 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);
};
        
/* 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

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

 */
Imports System.Reflection

' Define a class with a generic method.
Public Class Example
    Public Shared Sub Generic(Of T)(ByVal toDisplay As T)
        Console.WriteLine(vbCrLf & "Here it is: {0}", toDisplay)
    End Sub
End Class

Public Class Test
    Public Shared Sub Main() 
        Console.WriteLine(vbCrLf & "--- Examine a generic method.")
        
        ' Create a Type object representing class Example, and
        ' get a MethodInfo representing the generic method.
        '
        Dim ex As Type = GetType(Example)
        Dim mi As MethodInfo = ex.GetMethod("Generic")
        
        DisplayGenericMethodInfo(mi)
        
        ' Assign the Integer type to the type parameter of the Example 
        ' method.
        '
        Dim arguments() As Type = { GetType(Integer) }
        Dim miConstructed As MethodInfo = mi.MakeGenericMethod(arguments)
        
        DisplayGenericMethodInfo(miConstructed)

        ' Invoke the method.
        Dim args() As Object = { 42 }
        miConstructed.Invoke(Nothing, args)
        
        ' Invoke the method normally.
        Example.Generic(Of Integer)(42)
        
        ' Get the generic type definition from the constructed method,
        ' and show that it's the same as the original definition.
        '
        Dim miDef As MethodInfo = miConstructed.GetGenericMethodDefinition()
        Console.WriteLine(vbCrLf & "The definition is the same: {0}", _
            miDef Is mi)
    End Sub
      
    Private Shared Sub DisplayGenericMethodInfo(ByVal mi As MethodInfo) 
        Console.WriteLine(vbCrLf & mi.ToString())
        
        Console.WriteLine(vbTab _
            & "Is this a generic method definition? {0}", _
            mi.IsGenericMethodDefinition)

        Console.WriteLine(vbTab & "Is it a generic method? {0}", _
            mi.IsGenericMethod)

        Console.WriteLine(vbTab _
            & "Does it have unassigned generic parameters? {0}", _
            mi.ContainsGenericParameters)

        ' 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
    End Sub 
End Class 

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

Комментарии

Объявляющий метод является определением универсального метода.The declaring method is a generic method definition. То есть если DeclaringMethod не возвращает null, то DeclaringMethod.IsGenericMethodDefinition возвращает true.That is, if DeclaringMethod does not return null, then DeclaringMethod.IsGenericMethodDefinition returns true.

Свойства DeclaringType иDeclaringMethod определяют определение универсального типа или определение универсального метода, в котором был изначально определен параметр универсального типа:The DeclaringType and DeclaringMethod properties identify the generic type definition or generic method definition in which the generic type parameter was originally defined:

  • Если свойство возвращает объект MethodInfo, MethodInfo представляющий определение универсального метода, а текущий Type объект представляет параметр типа этого определения универсального метода. DeclaringMethodIf the DeclaringMethod property returns a MethodInfo, that MethodInfo represents a generic method definition, and the current Type object represents a type parameter of that generic method definition.

  • null Type Если свойство возвращает Type , DeclaringType свойство всегда возвращает объект, представляющий определение универсального типа, а текущий объект представляет параметр типа этого универсального типа. DeclaringMethod макроопределения.If the DeclaringMethod property returns null, then the DeclaringType property always returns a Type object representing a generic type definition, and the current Type object represents a type parameter of that generic type definition.

  • Получение свойства для типа, false свойство которого IsGenericParameter создает InvalidOperationExceptionисключение. DeclaringMethodGetting the DeclaringMethod property on a type whose IsGenericParameter property is false throws an InvalidOperationException.

Свойство, возвращаемое MethodInfo свойством, является либо в ConstructorInfo случае универсального метода, либо в случае с универсальным конструктором. MethodBase DeclaringMethodThe MethodBase that is returned by the DeclaringMethod property is either a MethodInfo in the case of a generic method, or a ConstructorInfo in the case of a generic constructor.

Примечание

В .NET Framework версии 2,0 Универсальные конструкторы не поддерживаются.In the .NET Framework version 2.0, generic constructors are not supported.

Список неизменяемых условий для терминов, используемых в отражении универсальных типов, см. в примечаниях к описанию свойства IsGenericType.For a list of the invariant conditions for terms used in generic reflection, see the IsGenericType property remarks.

Применяется к

Дополнительно