DynamicMethod 類別

定義

命名空間:

System.Reflection.Emit

組件:

System.Reflection.Emit.Lightweight.dll

來源:

DynamicMethod.cs

定義及代表可以編譯、執行和捨棄的動態方法。 已捨棄的方法可供記憶體回收所用。

public ref class DynamicMethod sealed : System::Reflection::MethodInfo

public sealed class DynamicMethod : System.Reflection.MethodInfo

type DynamicMethod = class
    inherit MethodInfo

Public NotInheritable Class DynamicMethod
Inherits MethodInfo

繼承

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

範例

下列程式代碼範例會建立採用兩個參數的動態方法。 此範例會發出將第一個參數列印至主控台的簡單函式主體，而此範例會使用第二個參數做為 方法的傳回值。 此範例會藉由建立委派來完成方法、使用不同的參數叫用委派，最後使用 方法叫用 Invoke 動態方法。

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Globalization;

// Declare a delegate type that can be used to execute the completed
// dynamic method. 
private delegate int HelloDelegate(String^ msg, int ret);

void main()
{
    // Create an array that specifies the types of the parameters
    // of the dynamic method. This dynamic method has a String
    // parameter and an Integer parameter.
    array<Type^>^ helloArgs = { String::typeid, int::typeid };

    // Create a dynamic method with the name "Hello", a return type
    // of Integer, and two parameters whose types are specified by
    // the array helloArgs. Create the method in the module that
    // defines the String class.
    DynamicMethod^ hello = gcnew DynamicMethod("Hello", 
        int::typeid, 
        helloArgs, 
        String::typeid->Module);

    // Create an array that specifies the parameter types of the
    // overload of Console::WriteLine to be used in Hello.
    array<Type^>^ writeStringArgs = { String::typeid };
    // Get the overload of Console::WriteLine that has one
    // String parameter.
    MethodInfo^ writeString = Console::typeid->GetMethod("WriteLine", 
        writeStringArgs);

    // Get an ILGenerator and emit a body for the dynamic method,
    // using a stream size larger than the IL that will be
    // emitted.
    ILGenerator^ il = hello->GetILGenerator(256);
    // Load the first argument, which is a string, onto the stack.
    il->Emit(OpCodes::Ldarg_0);
    // Call the overload of Console::WriteLine that prints a string.
    il->EmitCall(OpCodes::Call, writeString, nullptr);
    // The Hello method returns the value of the second argument;
    // to do this, load the onto the stack and return.
    il->Emit(OpCodes::Ldarg_1);
    il->Emit(OpCodes::Ret);

    // Add parameter information to the dynamic method. (This is not
    // necessary, but can be useful for debugging.) For each parameter,
    // identified by position, supply the parameter attributes and a 
    // parameter name.
    hello->DefineParameter(1, ParameterAttributes::In, "message");
    hello->DefineParameter(2, ParameterAttributes::In, "valueToReturn");

    // Create a delegate that represents the dynamic method. This
    // action completes the method. Any further attempts to
    // change the method are ignored.
    HelloDelegate^ hi = 
        (HelloDelegate^) hello->CreateDelegate(HelloDelegate::typeid);

    // Use the delegate to execute the dynamic method.
    Console::WriteLine("\r\nUse the delegate to execute the dynamic method:");
    int retval = hi("\r\nHello, World!", 42);
    Console::WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

    // Execute it again, with different arguments.
    retval = hi("\r\nHi, Mom!", 5280);
    Console::WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

    Console::WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
    // Create an array of arguments to use with the Invoke method.
    array<Object^>^ invokeArgs = { "\r\nHello, World!", 42 };
    // Invoke the dynamic method using the arguments. This is much
    // slower than using the delegate, because you must create an
    // array to contain the arguments, and value-type arguments
    // must be boxed.
    Object^ objRet = hello->Invoke(nullptr, BindingFlags::ExactBinding, nullptr, invokeArgs, gcnew CultureInfo("en-us"));
    Console::WriteLine("hello.Invoke returned: " + objRet);

    Console::WriteLine("\r\n ----- Display information about the dynamic method -----");
    // Display MethodAttributes for the dynamic method, set when 
    // the dynamic method was created.
    Console::WriteLine("\r\nMethod Attributes: {0}", hello->Attributes);

    // Display the calling convention of the dynamic method, set when the 
    // dynamic method was created.
    Console::WriteLine("\r\nCalling convention: {0}", hello->CallingConvention);

    // Display the declaring type, which is always null for dynamic
    // methods.
    if (hello->DeclaringType == nullptr)
    {
        Console::WriteLine("\r\nDeclaringType is always null for dynamic methods.");
    }
    else
    {
        Console::WriteLine("DeclaringType: {0}", hello->DeclaringType);
    }

    // Display the default value for InitLocals.
    if (hello->InitLocals)
    {
        Console::Write("\r\nThis method contains verifiable code.");
    }
    else
    {
        Console::Write("\r\nThis method contains unverifiable code.");
    }
    Console::WriteLine(" (InitLocals = {0})", hello->InitLocals);

    // Display the module specified when the dynamic method was created.
    Console::WriteLine("\r\nModule: {0}", hello->Module);

    // Display the name specified when the dynamic method was created.
    // Note that the name can be blank.
    Console::WriteLine("\r\nName: {0}", hello->Name);

    // For dynamic methods, the reflected type is always null.
    if (hello->ReflectedType == nullptr)
    {
        Console::WriteLine("\r\nReflectedType is null.");
    }
    else
    {
        Console::WriteLine("\r\nReflectedType: {0}", hello->ReflectedType);
    }

    if (hello->ReturnParameter == nullptr)
    {
        Console::WriteLine("\r\nMethod has no return parameter.");
    }
    else
    {
        Console::WriteLine("\r\nReturn parameter: {0}", hello->ReturnParameter);
    }

    // If the method has no return type, ReturnType is System.Void.
    Console::WriteLine("\r\nReturn type: {0}", hello->ReturnType);

    // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
    // that can be used to enumerate the custom attributes of the
    // return value. At present, there is no way to set such custom
    // attributes, so the list is empty.
    if (hello->ReturnType == Void::typeid)
    {
        Console::WriteLine("The method has no return type.");
    }
    else
    {
        ICustomAttributeProvider^ caProvider = hello->ReturnTypeCustomAttributes;
        array<Object^>^ returnAttributes = caProvider->GetCustomAttributes(true);
        if (returnAttributes->Length == 0)
        {
            Console::WriteLine("\r\nThe return type has no custom attributes.");
        }
        else
        {
            Console::WriteLine("\r\nThe return type has the following custom attributes:");
            for each (Object^ attr in returnAttributes)
            {
                Console::WriteLine("\t{0}", attr->ToString());
            }
        }
    }

    Console::WriteLine("\r\nToString: {0}", hello->ToString());

    // Display parameter information.
    array<ParameterInfo^>^ parameters = hello->GetParameters();
    Console::WriteLine("\r\nParameters: name, type, ParameterAttributes");
    for each (ParameterInfo^ p in parameters)
    {
        Console::WriteLine("\t{0}, {1}, {2}", 
            p->Name, p->ParameterType, p->Attributes);
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;

public class Test
{
    // Declare a delegate type that can be used to execute the completed
    // dynamic method.
    private delegate int HelloDelegate(string msg, int ret);

    public static void Main()
    {
        // Create an array that specifies the types of the parameters
        // of the dynamic method. This dynamic method has a String
        // parameter and an Integer parameter.
        Type[] helloArgs = {typeof(string), typeof(int)};

        // Create a dynamic method with the name "Hello", a return type
        // of Integer, and two parameters whose types are specified by
        // the array helloArgs. Create the method in the module that
        // defines the String class.
        DynamicMethod hello = new DynamicMethod("Hello",
            typeof(int),
            helloArgs,
            typeof(string).Module);

        // Create an array that specifies the parameter types of the
        // overload of Console.WriteLine to be used in Hello.
        Type[] writeStringArgs = {typeof(string)};
        // Get the overload of Console.WriteLine that has one
        // String parameter.
        MethodInfo writeString = typeof(Console).GetMethod("WriteLine",
            writeStringArgs);

        // Get an ILGenerator and emit a body for the dynamic method,
        // using a stream size larger than the IL that will be
        // emitted.
        ILGenerator il = hello.GetILGenerator(256);
        // Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0);
        // Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, null);
        // The Hello method returns the value of the second argument;
        // to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ret);

        // Add parameter information to the dynamic method. (This is not
        // necessary, but can be useful for debugging.) For each parameter,
        // identified by position, supply the parameter attributes and a
        // parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message");
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");

        // Create a delegate that represents the dynamic method. This
        // action completes the method. Any further attempts to
        // change the method are ignored.
        HelloDelegate hi =
            (HelloDelegate) hello.CreateDelegate(typeof(HelloDelegate));

        // Use the delegate to execute the dynamic method.
        Console.WriteLine("\r\nUse the delegate to execute the dynamic method:");
        int retval = hi("\r\nHello, World!", 42);
        Console.WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

        // Execute it again, with different arguments.
        retval = hi("\r\nHi, Mom!", 5280);
        Console.WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

        Console.WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
        // Create an array of arguments to use with the Invoke method.
        object[] invokeArgs = {"\r\nHello, World!", 42};
        // Invoke the dynamic method using the arguments. This is much
        // slower than using the delegate, because you must create an
        // array to contain the arguments, and value-type arguments
        // must be boxed.
        object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
        Console.WriteLine("hello.Invoke returned: " + objRet);

        Console.WriteLine("\r\n ----- Display information about the dynamic method -----");
        // Display MethodAttributes for the dynamic method, set when
        // the dynamic method was created.
        Console.WriteLine("\r\nMethod Attributes: {0}", hello.Attributes);

        // Display the calling convention of the dynamic method, set when the
        // dynamic method was created.
        Console.WriteLine("\r\nCalling convention: {0}", hello.CallingConvention);

        // Display the declaring type, which is always null for dynamic
        // methods.
        if (hello.DeclaringType == null)
        {
            Console.WriteLine("\r\nDeclaringType is always null for dynamic methods.");
        }
        else
        {
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType);
        }

        // Display the default value for InitLocals.
        if (hello.InitLocals)
        {
            Console.Write("\r\nThis method contains verifiable code.");
        }
        else
        {
            Console.Write("\r\nThis method contains unverifiable code.");
        }
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals);

        // Display the module specified when the dynamic method was created.
        Console.WriteLine("\r\nModule: {0}", hello.Module);

        // Display the name specified when the dynamic method was created.
        // Note that the name can be blank.
        Console.WriteLine("\r\nName: {0}", hello.Name);

        // For dynamic methods, the reflected type is always null.
        if (hello.ReflectedType == null)
        {
            Console.WriteLine("\r\nReflectedType is null.");
        }
        else
        {
            Console.WriteLine("\r\nReflectedType: {0}", hello.ReflectedType);
        }

        if (hello.ReturnParameter == null)
        {
            Console.WriteLine("\r\nMethod has no return parameter.");
        }
        else
        {
            Console.WriteLine("\r\nReturn parameter: {0}", hello.ReturnParameter);
        }

        // If the method has no return type, ReturnType is System.Void.
        Console.WriteLine("\r\nReturn type: {0}", hello.ReturnType);

        // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        // that can be used to enumerate the custom attributes of the
        // return value. At present, there is no way to set such custom
        // attributes, so the list is empty.
        if (hello.ReturnType == typeof(void))
        {
            Console.WriteLine("The method has no return type.");
        }
        else
        {
            ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
            object[] returnAttributes = caProvider.GetCustomAttributes(true);
            if (returnAttributes.Length == 0)
            {
                Console.WriteLine("\r\nThe return type has no custom attributes.");
            }
            else
            {
                Console.WriteLine("\r\nThe return type has the following custom attributes:");
                foreach( object attr in returnAttributes )
                {
                    Console.WriteLine("\t{0}", attr.ToString());
                }
            }
        }

        Console.WriteLine("\r\nToString: {0}", hello.ToString());

        // Display parameter information.
        ParameterInfo[] parameters = hello.GetParameters();
        Console.WriteLine("\r\nParameters: name, type, ParameterAttributes");
        foreach( ParameterInfo p in parameters )
        {
            Console.WriteLine("\t{0}, {1}, {2}",
                p.Name, p.ParameterType, p.Attributes);
        }
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */

Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Globalization

Public Class Test
    ' Declare a delegate type that can be used to execute the completed
    ' dynamic method. 
    Private Delegate Function HelloDelegate(ByVal msg As String, _
        ByVal ret As Integer) As Integer

    Public Shared Sub Main()
        ' Create an array that specifies the types of the parameters
        ' of the dynamic method. This dynamic method has a String
        ' parameter and an Integer parameter.
        Dim helloArgs() As Type = {GetType(String), GetType(Integer)}

        ' Create a dynamic method with the name "Hello", a return type
        ' of Integer, and two parameters whose types are specified by
        ' the array helloArgs. Create the method in the module that
        ' defines the String class.
        Dim hello As New DynamicMethod("Hello", _
            GetType(Integer), _
            helloArgs, _
            GetType(String).Module)

        ' Create an array that specifies the parameter types of the
        ' overload of Console.WriteLine to be used in Hello.
        Dim writeStringArgs() As Type = {GetType(String)}
        ' Get the overload of Console.WriteLine that has one
        ' String parameter.
        Dim writeString As MethodInfo = GetType(Console). _
            GetMethod("WriteLine", writeStringArgs) 

        ' Get an ILGenerator and emit a body for the dynamic method,
        ' using a stream size larger than the IL that will be
        ' emitted.
        Dim il As ILGenerator = hello.GetILGenerator(256)
        ' Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0)
        ' Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, Nothing)
        ' The Hello method returns the value of the second argument;
        ' to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1)
        il.Emit(OpCodes.Ret)

        ' Add parameter information to the dynamic method. (This is not
        ' necessary, but can be useful for debugging.) For each parameter,
        ' identified by position, supply the parameter attributes and a 
        ' parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message")
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn")

        ' Create a delegate that represents the dynamic method. This
        ' action completes the method. Any further attempts to
        ' change the method are ignored.
    Dim hi As HelloDelegate = _
            CType(hello.CreateDelegate(GetType(HelloDelegate)), HelloDelegate)

        ' Use the delegate to execute the dynamic method.
        Console.WriteLine(vbCrLf & "Use the delegate to execute the dynamic method:")
        Dim retval As Integer = hi(vbCrLf & "Hello, World!", 42)
        Console.WriteLine("Invoking delegate hi(""Hello, World!"", 42) returned: " _
            & retval & ".")

        ' Execute it again, with different arguments.
        retval = hi(vbCrLf & "Hi, Mom!", 5280)
        Console.WriteLine("Invoking delegate hi(""Hi, Mom!"", 5280) returned: " _
            & retval & ".")

        Console.WriteLine(vbCrLf & "Use the Invoke method to execute the dynamic method:")
        ' Create an array of arguments to use with the Invoke method.
        Dim invokeArgs() As Object = {vbCrLf & "Hello, World!", 42}
        ' Invoke the dynamic method using the arguments. This is much
        ' slower than using the delegate, because you must create an
        ' array to contain the arguments, and value-type arguments
        ' must be boxed.
        Dim objRet As Object = hello.Invoke(Nothing, _
            BindingFlags.ExactBinding, Nothing, invokeArgs, _
            New CultureInfo("en-us"))
        Console.WriteLine("hello.Invoke returned: {0}", objRet)

        Console.WriteLine(vbCrLf & _
            " ----- Display information about the dynamic method -----")
        ' Display MethodAttributes for the dynamic method, set when 
        ' the dynamic method was created.
        Console.WriteLine(vbCrLf & "Method Attributes: {0}", _
            hello.Attributes)

        ' Display the calling convention of the dynamic method, set when the 
        ' dynamic method was created.
        Console.WriteLine(vbCrLf & "Calling convention: {0}", _ 
            hello.CallingConvention)

        ' Display the declaring type, which is always Nothing for dynamic
        ' methods.
        If hello.DeclaringType Is Nothing Then
            Console.WriteLine(vbCrLf & "DeclaringType is always Nothing for dynamic methods.")
        Else
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType)
        End If

        ' Display the default value for InitLocals.
        If hello.InitLocals Then
            Console.Write(vbCrLf & "This method contains verifiable code.")
        Else
            Console.Write(vbCrLf & "This method contains unverifiable code.")
        End If
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals)

        ' Display the module specified when the dynamic method was created.
        Console.WriteLine(vbCrLf & "Module: {0}", hello.Module)

        ' Display the name specified when the dynamic method was created.
        ' Note that the name can be blank.
        Console.WriteLine(vbCrLf & "Name: {0}", hello.Name)

        ' For dynamic methods, the reflected type is always Nothing.
        If hello.ReflectedType Is Nothing Then
            Console.WriteLine(vbCrLf & "ReflectedType is Nothing.")
        Else
            Console.WriteLine(vbCrLf & "ReflectedType: {0}", _
                hello.ReflectedType)
        End If

        If hello.ReturnParameter Is Nothing Then
            Console.WriteLine(vbCrLf & "Method has no return parameter.")
        Else
            Console.WriteLine(vbCrLf & "Return parameter: {0}", _
                hello.ReturnParameter)
        End If

        ' If the method has no return type, ReturnType is System.Void.
        Console.WriteLine(vbCrLf & "Return type: {0}", hello.ReturnType)           

        ' ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        ' that can be used to enumerate the custom attributes of the
        ' return value. At present, there is no way to set such custom
        ' attributes, so the list is empty.
        If hello.ReturnType Is GetType(System.Void) Then
            Console.WriteLine("The method has no return type.")
        Else
            Dim caProvider As ICustomAttributeProvider = _
                hello.ReturnTypeCustomAttributes
            Dim returnAttributes() As Object = _
                caProvider.GetCustomAttributes(True)
            If returnAttributes.Length = 0 Then
                Console.WriteLine(vbCrLf _
                    & "The return type has no custom attributes.")
            Else
                Console.WriteLine(vbCrLf _
                    & "The return type has the following custom attributes:")
                For Each attr As Object In returnAttributes
                    Console.WriteLine(vbTab & attr.ToString())
                Next attr
            End If
        End If

        Console.WriteLine(vbCrLf & "ToString: " & hello.ToString())

        ' Display parameter information.
        Dim parameters() As ParameterInfo = hello.GetParameters()
        Console.WriteLine(vbCrLf & "Parameters: name, type, ParameterAttributes")
        For Each p As ParameterInfo In parameters
            Console.WriteLine(vbTab & "{0}, {1}, {2}", _ 
                p.Name, p.ParameterType, p.Attributes)
        Next p
    End Sub
End Class

' This code example produces the following output:
'
'Use the delegate to execute the dynamic method:
'
'Hello, World!
'Invoking delegate hi("Hello, World!", 42) returned: 42.
'
'Hi, Mom!
'Invoking delegate hi("Hi, Mom!", 5280) returned: 5280.
'
'Use the Invoke method to execute the dynamic method:
'
'Hello, World!
'hello.Invoke returned: 42
'
' ----- Display information about the dynamic method -----
'
'Method Attributes: PrivateScope, Public, Static
'
'Calling convention: Standard
'
'DeclaringType is always Nothing for dynamic methods.
'
'This method contains verifiable code. (InitLocals = True)
'
'Module: CommonLanguageRuntimeLibrary
'
'Name: Hello
'
'ReflectedType is Nothing.
'
'Method has no return parameter.
'
'Return type: System.Int32
'
'The return type has no custom attributes.
'
'ToString: Int32 Hello(System.String, Int32)
'
'Parameters: name, type, ParameterAttributes
'        message, System.String, In
'        valueToReturn, System.Int32, In

備註

如需此 API 的詳細資訊，請參閱 DynamicMethod 補充 API 備註。

建構函式

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	建立對模組而言全域的動態方法，並指定方法名稱、屬性、呼叫慣例、傳回類型、參數類型、模組，以及是否應該略過動態方法的 Microsoft Intermediate Language (MSIL) 所存取之類型和成員的 Just-In-Time (JIT) 可見度檢查。
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	建立動態方法、指定方法名稱、屬性、呼叫慣例、傳回類型、參數類型、動態方法在邏輯上相關聯的類型，以及是否應該略過動態方法的 Microsoft Intermediate Language (MSIL) 所存取之類型和成員的 Just-In-Time (JIT) 可見度檢查。
DynamicMethod(String, Type, Type[])	初始化匿名裝載的動態方法，並指定方法名稱、傳回型別和參數類型。
DynamicMethod(String, Type, Type[], Boolean)	初始化匿名裝載的動態方法，並指定方法名稱、傳回類型、參數類型、以及是否應該略過動態方法的 Microsoft Intermediate Language (MSIL) 所存取之類型和成員的 Just-In-Time (JIT) 可見度檢查。
DynamicMethod(String, Type, Type[], Module)	建立對模組通用的動態方法，並指定方法名稱、傳回型別、參數類型和模組。
DynamicMethod(String, Type, Type[], Module, Boolean)	建立對模組而言全域的動態方法，並指定方法名稱、傳回型別、參數類型、模組，以及是否應該略過動態方法的 Microsoft Intermediate Language (MSIL) 所存取之類型和成員的 Just-In-Time (JIT) 可見度檢查。
DynamicMethod(String, Type, Type[], Type)	建立動態方法，指定方法名稱、傳回型別、參數類型及與動態方法在邏輯上相關聯的類型。
DynamicMethod(String, Type, Type[], Type, Boolean)	建立動態方法，並指定方法名稱、傳回型別、參數類型、動態方法在邏輯上相關聯的類型，以及是否應該略過動態方法的 Microsoft Intermediate Language (MSIL) 所存取之類型和成員的 Just-In-Time (JIT) 可見度檢查。

屬性

Attributes	取得建立動態方法時所指定的屬性。
CallingConvention	取得建立動態方法時所指定的呼叫慣例。
ContainsGenericParameters	取得值，指出泛型方法是否包含未指派的泛型型別參數。 (繼承來源 MethodInfo)
CustomAttributes	取得包含此成員之自訂屬性的集合。 (繼承來源 MemberInfo)
DeclaringType	取得宣告方法的類型，如果是動態方法，則一律為 null。
InitLocals	取得或設定值，表示在此方法中的區域變數是否以零起始。
IsAbstract	取得值，指出方法是否為抽象。 (繼承來源 MethodBase)
IsAssembly	取得值，指出 Assembly 是否描述此方法或建構函式 (Constructor) 的潛在可視性；亦即，最多只有相同組件 (Assembly) 中的其他型別可以看見該方法或建構函式，組件外部的衍生型別 (Derived Type) 則看不見它們。 (繼承來源 MethodBase)
IsCollectible	取得指出此 MemberInfo 物件是否為可回收 AssemblyLoadContext 中保存之組件一部分的值。 (繼承來源 MemberInfo)
IsConstructedGenericMethod	定義及代表可以編譯、執行和捨棄的動態方法。 已捨棄的方法可供記憶體回收所用。 (繼承來源 MethodBase)
IsConstructor	取得值，指出方法是否為建構函示。 (繼承來源 MethodBase)
IsFamily	取得值，指出 Family 是否描述此方法或建構函式的可視性；亦即，您只能在其類別和衍生類別內看見該方法或建構函式。 (繼承來源 MethodBase)
IsFamilyAndAssembly	取得值，指出 FamANDAssem 是否描述此方法或建構函式的可視性；亦即，只有當該方法或建構函式位於相同的組件時，衍生類別才能呼叫它們。 (繼承來源 MethodBase)
IsFamilyOrAssembly	取得值，指出 FamORAssem 是否描述此方法或建構函式的潛在可視性；亦即，無論該方法或建構函式位於何處，衍生類別以及相同組件中的類別都可以呼叫它們。 (繼承來源 MethodBase)
IsFinal	取得值，指出這個方法是否為 final。 (繼承來源 MethodBase)
IsGenericMethod	取得值，指出目前的方法是否為泛型方法。 (繼承來源 MethodInfo)
IsGenericMethodDefinition	取得值，表示目前的 MethodInfo是否代表泛型方法的定義。 (繼承來源 MethodInfo)
IsHideBySig	取得值，指出是否只有簽章完全一樣的同類成員隱藏於衍生類別中。 (繼承來源 MethodBase)
IsPrivate	取得值，指出這個成員是否為私用的 (Private)。 (繼承來源 MethodBase)
IsPublic	取得值，指出這是否為公用的方法。 (繼承來源 MethodBase)
IsSecurityCritical	取得值，這個值表示目前動態方法是否為安全性關鍵或安全性安全關鍵，因而可以執行重要的作業。
IsSecuritySafeCritical	取得值，這個值表示目前動態方法在目前信任層級上是否為安全性安全關鍵，也就是說，它是否能執行重要作業並由安全性透明的程式碼存取。
IsSecurityTransparent	取得值，這個值表示目前動態方法在目前信任層級上是否為安全性透明，因此無法執行重要作業。
IsSpecialName	取得值，指出這個方法是否有特別的名稱。 (繼承來源 MethodBase)
IsStatic	取得值指出方法是否為 static。 (繼承來源 MethodBase)
IsVirtual	取得值指出方法是否為 virtual。 (繼承來源 MethodBase)
MemberType	取得 MemberTypes 值，表示這個成員為方法。 (繼承來源 MethodInfo)
MetadataToken	取得值，這個值可識別中繼資料項目。 (繼承來源 MemberInfo)
MethodHandle	不支援動態方法。
MethodImplementationFlags	取得 MethodImplAttributes 旗標，這些旗標會指定方法實作的屬性。 (繼承來源 MethodBase)
Module	取得動態方法在邏輯上相關聯的模組。
Name	取得動態方法的名稱。
ReflectedType	取得用於反映中以取得方法的類別。
ReturnParameter	取得動態方法的傳回參數。
ReturnType	取得此動態方法傳回值的類型。
ReturnTypeCustomAttributes	取得動態方法之傳回類型的自訂屬性。

方法

CreateDelegate(Type)	完成動態方法並建立可以用來執行它的委派。
CreateDelegate(Type, Object)	完成動態方法並建立可以用來執行它的委派，同時指定委派類型和委派繫結至的物件。
CreateDelegate<T>()	從這個方法建立類型 T 的委派。 (繼承來源 MethodInfo)
CreateDelegate<T>(Object)	從此方法建立具有指定目標之型別 T 的委派。 (繼承來源 MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)	定義動態方法的參數。
Equals(Object)	傳回值，這個值指出此執行個體是否與指定的物件相等。 (繼承來源 MethodInfo)
GetBaseDefinition()	傳回此方法的基底實作。
GetCustomAttributes(Boolean)	傳回為這個方法定義的所有自訂屬性。
GetCustomAttributes(Type, Boolean)	傳回已套用至該方法之指定類型的自訂屬性。
GetCustomAttributesData()	傳回 CustomAttributeData 物件的清單，表示已套用至目標成員之屬性的資料。 (繼承來源 MemberInfo)
GetDynamicILInfo()	傳回 DynamicILInfo 物件，其可用於從中繼資料語彙基元、範圍以及 Microsoft 中繼語言 (MSIL) 資料流中產生方法主體。
GetGenericArguments()	傳回 Type 物件的陣列，這些物件代表泛型方法的類型引數，或泛型方法定義的類型參數。 (繼承來源 MethodInfo)
GetGenericMethodDefinition()	傳回表示泛型方法定義的 MethodInfo 物件，利用此泛型方法定義就可以建構出目前的方法。 (繼承來源 MethodInfo)
GetHashCode()	傳回這個執行個體的雜湊碼。 (繼承來源 MethodInfo)
GetILGenerator()	針對方法，傳回具有預設 Microsoft Intermediate Language (MSIL) 資料流大小 64 位元組的 MSIL 產生器。
GetILGenerator(Int32)	針對方法，傳回具有指定 Microsoft Intermediate Language (MSIL) 資料流大小的 MSIL 產生器。
GetMethodBody()	在衍生類別中覆寫時，取得 MethodBody 物件，其提供對目前方法之 MSIL 資料流、區域變數和例外狀況的存取。 (繼承來源 MethodBase)
GetMethodImplementationFlags()	傳回方法的實作旗標。
GetParameters()	傳回動態方法的參數。
GetType()	探索方法的屬性 (Attribute) 並提供方法中繼資料 (Metadata) 的存取。 (繼承來源 MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	定義及代表可以編譯、執行和捨棄的動態方法。 已捨棄的方法可供記憶體回收所用。 (繼承來源 MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	使用指定的文化特性資訊，在指定繫結器的條件約束下，以指定的參數叫用動態方法。
Invoke(Object, Object[])	使用指定的參數叫用由目前執行個體代表的方法或建構函式。 (繼承來源 MethodInfo)
IsDefined(Type, Boolean)	指出是否已定義指定的自訂屬性類型。
MakeGenericMethod(Type[])	使用類型陣列的項目取代目前泛型方法定義的類型參數，並傳回代表所產生之建構方法的 MethodInfo 物件。 (繼承來源 MethodInfo)
MemberwiseClone()	建立目前 Object 的淺層複製。 (繼承來源 Object)
ToString()	傳回方法的簽章，以字串表示。

擴充方法

GetCustomAttribute(MemberInfo, Type)	擷取指定型別的自訂屬性，此屬性套用至指定成員。
GetCustomAttribute(MemberInfo, Type, Boolean)	擷取只訂型別的自訂屬性，此屬性套用至指定成員，並且可選擇性檢查該成員的祖系。
GetCustomAttribute<T>(MemberInfo)	擷取指定型別的自訂屬性，此屬性套用至指定成員。
GetCustomAttribute<T>(MemberInfo, Boolean)	擷取只訂型別的自訂屬性，此屬性套用至指定成員，並且可選擇性檢查該成員的祖系。
GetCustomAttributes(MemberInfo)	擷取套用至指定成員的自訂屬性集合。
GetCustomAttributes(MemberInfo, Boolean)	擷取自訂屬性集合，此集合套用至指定成員，並且可選擇性檢查該成員的祖系。
GetCustomAttributes(MemberInfo, Type)	擷取指定型別的自訂屬性集合，此集合套用至指定成員。
GetCustomAttributes(MemberInfo, Type, Boolean)	擷取指定型別的自訂屬性集合，此集合套用至指定成員，並且可選擇性檢查該成員的祖系。
GetCustomAttributes<T>(MemberInfo)	擷取指定型別的自訂屬性集合，此集合套用至指定成員。
GetCustomAttributes<T>(MemberInfo, Boolean)	擷取指定型別的自訂屬性集合，此集合套用至指定成員，並且可選擇性檢查該成員的祖系。
IsDefined(MemberInfo, Type)	指出是否將所指定型別的自訂屬性套用至指定的成員。
IsDefined(MemberInfo, Type, Boolean)	指出指定之型別的自訂屬性是否會套用至指定的成員，以及選擇性地套用到其上階。
GetMetadataToken(MemberInfo)	取得指定成員的中繼資料語彙基元 (如果有)。
HasMetadataToken(MemberInfo)	傳回值，指出所指定成員是否有可用的中繼資料語彙基元。
GetBaseDefinition(MethodInfo)	定義及代表可以編譯、執行和捨棄的動態方法。 已捨棄的方法可供記憶體回收所用。
GetRuntimeBaseDefinition(MethodInfo)	擷取物件，表示直接或間接基底類別上的指定方法 (在這個類別上首次宣告這個方法)。

另請參閱

• 作法：定義和執行動態方法
• 反映發出中的安全性問題
• 逐步解說：在部分信任情節中發出程式碼