Type.DeclaringMethod Właściwość

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Źródło:: Type.cs

Źródło:: Type.cs

Źródło:: Type.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Pobiera obiekt MethodBase reprezentujący metodę deklaratowania, jeśli bieżący Type reprezentuje parametr typu metody ogólnej.

public:
 virtual property System::Reflection::MethodBase ^ DeclaringMethod { System::Reflection::MethodBase ^ get(); };

public virtual System.Reflection.MethodBase? DeclaringMethod { get; }

public virtual System.Reflection.MethodBase DeclaringMethod { get; }

member this.DeclaringMethod : System.Reflection.MethodBase

Public Overridable ReadOnly Property DeclaringMethod As MethodBase

Wartość właściwości

MethodBase

Jeśli bieżący Type reprezentuje parametr typu metody ogólnej, który MethodBase reprezentuje metodę deklaratowania; w przeciwnym razie null.

Przykłady

Poniższy przykład kodu definiuje klasę, która ma metodę ogólną, przypisuje argument typu do metody i wywołuje wynikową skonstruowaną metodę ogólną. Wyświetla również informacje o definicji metody ogólnej i skonstruowanej metodzie. Podczas wyświetlania informacji o parametrach typu definicji metody ogólnej w DisplayGenericMethodInfo metodzie przykładowy kod pokazuje wartość DeclaringMethod właściwości parametru typu ogólnego metody.

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

 */

open System.Reflection

// Define a class with a generic method.
type Example =
    static member Generic<'T>(toDisplay: 'T) =
        printfn $"\r\nHere it is: {toDisplay}"

let displayGenericMethodInfo (mi: MethodInfo) =
    printfn $"\n{mi}"

    printfn $"\tIs this a generic method definition? {mi.IsGenericMethodDefinition}"

    printfn $"\tIs it a generic method? {mi.IsGenericMethod}"

    printfn $"\tDoes it have unassigned generic parameters? {mi.ContainsGenericParameters}"

    // If this is a generic method, display its type arguments.
    //
    if mi.IsGenericMethod then
        let typeArguments = mi.GetGenericArguments()

        printfn $"\tList type arguments ({typeArguments.Length}):"

        for tParam in typeArguments do
            // IsGenericParameter is true only for generic type
            // parameters.
            if tParam.IsGenericParameter then
                printfn $"\t\t{tParam}  parameter position {tParam.GenericParameterPosition}\n\t\t   declaring method: {tParam.DeclaringMethod}"
            else
                printfn $"\t\t{tParam}"

printfn "\r\n--- Examine a generic method."

// Create a Type object representing class Example, and
// get a MethodInfo representing the generic method.
//
let ex = typeof<Example>
let mi = ex.GetMethod "Generic"

displayGenericMethodInfo mi

// Assign the int type to the type parameter of the Example
// method.
//
let miConstructed = mi.MakeGenericMethod typeof<int>

displayGenericMethodInfo miConstructed

// Invoke the method.
let args = [| box 42 |]
miConstructed.Invoke(null, args) |> ignore

// 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.
//
let miDef = miConstructed.GetGenericMethodDefinition()
printfn $"\r\nThe definition is the same: {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

 *)

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
'

Uwagi

Metoda deklarowania jest definicją metody ogólnej. Oznacza to, że jeśli DeclaringMethod nie zwraca nullwartości , funkcja DeclaringMethod.IsGenericMethodDefinition zwraca wartość true.

Właściwości DeclaringType i DeclaringMethod identyfikują definicję typu ogólnego lub definicję metody ogólnej, w której pierwotnie zdefiniowano parametr typu ogólnego:

DeclaringMethod Jeśli właściwość zwraca MethodInfowartość , która MethodInfo reprezentuje definicję metody ogólnej, a bieżący Type obiekt reprezentuje parametr typu tej definicji metody ogólnej.
DeclaringMethod Jeśli właściwość zwraca nullwartość , DeclaringType właściwość zawsze zwraca obiekt reprezentujący definicję Type typu ogólnego, a bieżący Type obiekt reprezentuje parametr typu tej definicji typu ogólnego.
DeclaringMethod Pobieranie właściwości typu, którego IsGenericParameter właściwość jest false zgłaszana jako InvalidOperationException.

Wartość MethodBase zwracana przez DeclaringMethod właściwość jest albo MethodInfo elementem w przypadku metody ogólnej, albo ConstructorInfo w przypadku konstruktora ogólnego.

Uwaga

W .NET Framework w wersji 2.0 konstruktory ogólne nie są obsługiwane.

Aby zapoznać się z listą niezmiennych warunków warunków używanych w odbiciu ogólnym, zobacz IsGenericType uwagi dotyczące właściwości.

Dotyczy

Udostępnij za pośrednictwem