DynamicMethod Kelas

Definisi

Ruang nama:

System.Reflection.Emit

Rakitan:

netstandard.dll, System.Reflection.Emit.Lightweight.dll

Sumber:

DynamicMethod.cs

Menentukan dan mewakili metode dinamis yang dapat dikompilasi, dijalankan, dan dibuang. Metode yang dibuang tersedia untuk pengumpulan sampah.

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

Warisan

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

Contoh

Contoh kode berikut membuat metode dinamis yang mengambil dua parameter. Contoh menghasilkan isi fungsi sederhana yang mencetak parameter pertama ke konsol, dan menggunakan parameter kedua sebagai nilai pengembalian dari metode tersebut. Contoh menyelesaikan metode dengan membuat delegasi, memanggil delegasi dengan parameter yang berbeda, dan akhirnya memanggil metode dinamis menggunakan metode .Invoke

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

Keterangan

Anda dapat menggunakan kelas DynamicMethod untuk menghasilkan dan menjalankan metode saat runtime, tanpa harus menghasilkan rakitan dinamis dan tipe dinamis untuk berisi metode tersebut. Kode yang dapat dieksekusi yang dibuat oleh kompilator just-in-time (JIT) diklaim kembali ketika DynamicMethod objek diklaim kembali. Metode dinamis adalah cara paling efisien untuk menghasilkan dan menjalankan sejumlah kecil kode.

Metode dinamis dapat dihosting secara anonim, atau dapat dikaitkan secara logis dengan modul atau dengan jenis.

• Jika metode dinamis dihosting secara anonim, metode ini terletak di rakitan yang disediakan sistem, dan karenanya diisolasi dari kode lain. Secara default, ia tidak memiliki akses ke data non-publik apa pun. Metode dinamis yang dihosting secara anonim dapat memiliki kemampuan terbatas untuk melewati pemeriksaan visibilitas kode dari pengompilasi JIT, jika telah diberikan ReflectionPermission dengan parameter ReflectionPermissionFlag.RestrictedMemberAccess. Tingkat kepercayaan rakitan yang anggota non-publiknya diakses oleh metode dinamis harus setara dengan, atau merupakan subset dari, tingkat kepercayaan tumpukan pemanggilan yang menghasilkan metode dinamis. Untuk informasi selengkapnya tentang metode dinamis yang dihosting secara anonim, lihat Panduan: Memancarkan Kode dalam Skenario Kepercayaan Parsial.

• Jika metode dinamis dikaitkan dengan modul yang Anda tentukan, metode dinamis secara efektif bersifat global ke modul tersebut. Ini dapat mengakses semua tipe dalam modul dan semua anggota tipe internal (Friend di Visual Basic). Anda dapat mengaitkan metode dinamis dengan modul apa pun, terlepas dari apakah Anda membuat modul tersebut, asalkan permintaan untuk ReflectionPermission dengan parameter RestrictedMemberAccess dapat dipenuhi oleh tumpukan panggilan yang menyertakan kode Anda. ReflectionPermissionFlag.MemberAccess Jika flag disertakan dalam pemberian, metode dinamis dapat melewati pemeriksaan visibilitas pengkompilasi JIT dan mengakses data privat dari semua jenis yang dideklarasikan dalam modul atau dalam modul lain di rakitan mana pun.

  Note

  Ketika Anda menentukan modul tempat metode dinamis dikaitkan, modul tersebut tidak boleh berada di rakitan yang disediakan sistem yang digunakan untuk hosting anonim.

• Jika metode dinamis dikaitkan dengan jenis yang Anda tentukan, metode ini memiliki akses ke semua anggota jenis, terlepas dari tingkat akses. Selain itu, pemeriksaan visibilitas JIT dapat dilewati. Ini memberikan akses metode dinamis ke data privat dari jenis lain yang dideklarasikan dalam modul yang sama atau dalam modul lain di perakitan apa pun. Anda dapat mengaitkan metode dinamis dengan jenis apa pun, tetapi kode Anda harus diberikan ReflectionPermission dengan flag RestrictedMemberAccess dan MemberAccess.

Tabel berikut menunjukkan jenis dan anggota mana yang dapat diakses oleh metode dinamis yang dihosting secara anonim, dengan dan tanpa pemeriksaan visibilitas JIT, tergantung pada apakah ReflectionPermission dengan flag RestrictedMemberAccess diberikan.

Pemeriksaan visibilitas	Tanpa RestrictedMemberAccess	Dengan RestrictedMemberAccess
Tanpa melewati pemeriksaan visibilitas JIT	Anggota publik dari jenis publik di rakitan apa pun.	Anggota publik dari jenis publik di rakitan apa pun.
Melompati pemeriksaan visibilitas JIT, dengan pembatasan	Anggota publik dari jenis publik di rakitan apa pun.	Semua anggota dari semua jenis, hanya dalam kumpulan dengan tingkat kepercayaan yang sama dengan atau kurang dari tingkat kepercayaan kumpulan yang memanggil metode dinamis.

Tabel berikut menunjukkan jenis dan anggota mana yang dapat diakses oleh metode dinamis yang terkait dengan modul atau dengan jenis dalam modul.

Lewati pemeriksaan visibilitas JIT	Terkait dengan modul	Terkait dengan jenis
No	Anggota publik dan internal dari jenis publik, internal, dan privat dalam modul. Anggota publik dari jenis publik di rakitan apa pun.	Semua anggota jenis terkait. Anggota publik dan internal dari semua tipe lain dalam modul. Anggota publik dari jenis publik di rakitan apa pun.
Yes	Semua anggota dari semua jenis dalam majelis apa pun.	Semua anggota dari semua jenis dalam majelis apa pun.

Metode dinamis yang terkait dengan modul memiliki izin modul tersebut. Metode dinamis yang terkait dengan jenis memiliki izin modul yang berisi jenis tersebut.

Metode dinamis dan parameternya tidak harus dinamai, tetapi Anda dapat memberikan nama untuk membantu proses debugging. Atribut kustom tidak didukung pada metode dinamis atau parameternya.

Meskipun metode dinamis adalah static metode (Shared metode di Visual Basic), aturan yang dilonggarkan untuk pengikatan delegasi memungkinkan metode dinamis terikat ke objek, sehingga bertindak seperti metode instans saat dipanggil menggunakan instans delegasi tersebut. Contoh yang menunjukkan ini disediakan untuk CreateDelegate(Type, Object) metode kelebihan beban.

Verifikasi

Daftar berikut ini meringkas kondisi di mana metode dinamis dapat berisi kode yang tidak dapat diverifikasi. (Misalnya, metode dinamis tidak dapat diverifikasi jika propertinya InitLocals diatur ke false.)

• Metode dinamis yang terkait dengan rakitan penting keamanan juga penting bagi keamanan, dan dapat melewati verifikasi. Misalnya, rakitan tanpa atribut keamanan yang dijalankan sebagai aplikasi desktop diperlakukan sebagai kritis keamanan oleh runtime. Jika Anda mengaitkan metode dinamis dengan rakitan, metode dinamis dapat berisi kode yang tidak dapat diverifikasi.
• Jika metode dinamis yang berisi kode yang tidak dapat diverifikasi dikaitkan dengan rakitan yang memiliki transparansi tingkat 1, kompilator just-in-time (JIT) menyuntikkan permintaan keamanan. Permintaan hanya berhasil jika metode dinamis dijalankan oleh kode yang sepenuhnya tepercaya. Lihat KodeSecurity-Transparent, Tingkat 1.
• Jika metode dinamis yang berisi kode yang tidak dapat diverifikasi dikaitkan dengan rakitan yang memiliki transparansi tingkat 2 (seperti mscorlib.dll), itu melemparkan pengecualian (disuntikkan oleh pengkompilasi JIT) alih-alih membuat permintaan keamanan. Lihat KodeSecurity-Transparent, Tingkat 2.
• Metode dinamis yang dihosting secara anonim yang berisi kode yang tidak dapat diverifikasi selalu memberikan pengecualian. Ini tidak pernah dapat melewati verifikasi, bahkan jika dibuat dan dijalankan oleh kode yang sepenuhnya tepercaya.

Pengecualian yang dilemparkan untuk kode yang tidak dapat diverifikasi bervariasi tergantung pada cara metode dinamis dipanggil. Jika Anda memanggil metode dinamis dengan menggunakan delegasi yang dikembalikan dari metode CreateDelegate, VerificationException akan dilemparkan. Jika Anda memanggil metode dinamis dengan menggunakan metode Invoke, maka TargetInvocationException akan dilemparkan dengan bagian dalam VerificationException.

Konstruktor

Nama	Deskripsi
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	Membuat metode dinamis yang bersifat global ke modul, menentukan nama metode, atribut, konvensi panggilan, jenis pengembalian, jenis parameter, modul, dan apakah pemeriksaan visibilitas just-in-time (JIT) harus dilewati untuk jenis dan anggota yang diakses oleh Microsoft bahasa perantara (MSIL) dari metode dinamis.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	Membuat metode dinamis, menentukan nama metode, atribut, konvensi panggilan, jenis pengembalian, jenis parameter, jenis yang metode dinamisnya terkait secara logis, dan apakah pemeriksaan visibilitas just-in-time (JIT) harus dilewati untuk jenis dan anggota yang diakses oleh bahasa perantara (MSIL) Microsoft dari metode dinamis.
DynamicMethod(String, Type, Type[], Boolean)	Menginisialisasi metode dinamis yang dihosting secara anonim, menentukan nama metode, jenis pengembalian, jenis parameter, dan apakah pemeriksaan visibilitas just-in-time (JIT) harus dilewati untuk jenis dan anggota yang diakses oleh Microsoft bahasa perantara (MSIL) dari metode dinamis.
DynamicMethod(String, Type, Type[], Module, Boolean)	Membuat metode dinamis yang bersifat global ke modul, menentukan nama metode, jenis pengembalian, jenis parameter, modul, dan apakah pemeriksaan visibilitas just-in-time (JIT) harus dilewati untuk jenis dan anggota yang diakses oleh Microsoft bahasa perantara (MSIL) dari metode dinamis.
DynamicMethod(String, Type, Type[], Module)	Membuat metode dinamis yang bersifat global ke modul, menentukan nama metode, jenis pengembalian, jenis parameter, dan modul.
DynamicMethod(String, Type, Type[], Type, Boolean)	Membuat metode dinamis, menentukan nama metode, jenis pengembalian, jenis parameter, jenis yang metode dinamisnya terkait secara logis, dan apakah pemeriksaan visibilitas just-in-time (JIT) harus dilewati untuk jenis dan anggota yang diakses oleh Microsoft bahasa perantara (MSIL) dari metode dinamis.
DynamicMethod(String, Type, Type[], Type)	Membuat metode dinamis, menentukan nama metode, jenis pengembalian, jenis parameter, dan jenis yang terkait dengan metode dinamis secara logis.
DynamicMethod(String, Type, Type[])	Menginisialisasi metode dinamis yang dihosting secara anonim, menentukan nama metode, jenis pengembalian, dan jenis parameter.

Properti

Nama	Deskripsi
Attributes	Mendapatkan atribut yang ditentukan ketika metode dinamis dibuat.
CallingConvention	Mendapatkan konvensi panggilan yang ditentukan ketika metode dinamis dibuat.
CustomAttributes	Mendapatkan koleksi yang berisi atribut kustom anggota ini. (Diperoleh dari MemberInfo)
DeclaringType	Mendapatkan jenis yang mendeklarasikan metode , yang selalu null untuk metode dinamis.
InitLocals	Mendapatkan atau menetapkan nilai yang menunjukkan apakah variabel lokal dalam metode diinisialisasi nol.
IsAbstract	Mendapatkan nilai yang menunjukkan apakah metode tersebut abstrak. (Diperoleh dari MethodBase)
IsAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas potensial metode atau konstruktor ini dijelaskan oleh Assembly; artinya, metode atau konstruktor paling banyak terlihat oleh jenis lain dalam rakitan yang sama, dan tidak terlihat oleh jenis turunan di luar rakitan. (Diperoleh dari MethodBase)
IsCollectible	Mendapatkan nilai yang menunjukkan apakah objek ini MemberInfo mereferensikan satu atau beberapa rakitan yang disimpan dalam koleksi AssemblyLoadContext. (Diperoleh dari MemberInfo)
IsConstructedGenericMethod	Menentukan dan mewakili metode dinamis yang dapat dikompilasi, dijalankan, dan dibuang. Metode yang dibuang tersedia untuk pengumpulan sampah. (Diperoleh dari MethodBase)
IsConstructor	Mendapatkan nilai yang menunjukkan apakah metode tersebut adalah konstruktor. (Diperoleh dari MethodBase)
IsFamily	Mendapatkan nilai yang menunjukkan apakah visibilitas metode atau konstruktor ini dijelaskan oleh Family; artinya, metode atau konstruktor hanya terlihat dalam kelas dan kelas turunannya. (Diperoleh dari MethodBase)
IsFamilyAndAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas metode atau konstruktor ini dijelaskan oleh FamANDAssem; artinya, metode atau konstruktor dapat dipanggil oleh kelas turunan, tetapi hanya jika mereka berada dalam rakitan yang sama. (Diperoleh dari MethodBase)
IsFamilyOrAssembly	Mendapatkan nilai yang menunjukkan apakah visibilitas potensial metode atau konstruktor ini dijelaskan oleh FamORAssem; artinya, metode atau konstruktor dapat dipanggil oleh kelas turunan di mana pun mereka berada, dan berdasarkan kelas dalam rakitan yang sama. (Diperoleh dari MethodBase)
IsFinal	Mendapatkan nilai yang menunjukkan apakah metode ini final. (Diperoleh dari MethodBase)
IsHideBySig	Mendapatkan nilai yang menunjukkan apakah hanya anggota dengan jenis yang sama dengan tanda tangan yang sama persis yang disembunyikan di kelas turunan. (Diperoleh dari MethodBase)
IsPrivate	Mendapatkan nilai yang menunjukkan apakah anggota ini bersifat privat. (Diperoleh dari MethodBase)
IsPublic	Mendapatkan nilai yang menunjukkan apakah ini adalah metode publik. (Diperoleh dari MethodBase)
IsSecurityCritical	Mendapatkan nilai yang menunjukkan apakah metode dinamis saat ini kritis keamanan atau keamanan-aman-kritis, dan oleh karena itu dapat melakukan operasi penting.
IsSecuritySafeCritical	Mendapatkan nilai yang menunjukkan apakah metode dinamis saat ini adalah keamanan-aman-kritis pada tingkat kepercayaan saat ini; yaitu, apakah dapat melakukan operasi penting dan dapat diakses dengan kode transparan.
IsSecurityTransparent	Mendapatkan nilai yang menunjukkan apakah metode dinamis saat ini transparan pada tingkat kepercayaan saat ini, dan karenanya tidak dapat melakukan operasi penting.
IsSpecialName	Mendapatkan nilai yang menunjukkan apakah metode ini memiliki nama khusus. (Diperoleh dari MethodBase)
IsStatic	Mendapatkan nilai yang menunjukkan apakah metode static. (Diperoleh dari MethodBase)
IsVirtual	Mendapatkan nilai yang menunjukkan apakah metode virtual. (Diperoleh dari MethodBase)
MemberType	Mendapatkan nilai MemberTypes yang menunjukkan bahwa anggota ini adalah metode . (Diperoleh dari MethodInfo)
MetadataToken	Mendapatkan nilai yang mengidentifikasi elemen metadata. (Diperoleh dari MemberInfo)
MethodHandle	Tidak didukung untuk metode dinamis.
MethodImplementationFlags	Mendapatkan bendera MethodImplAttributes yang menentukan atribut implementasi metode. (Diperoleh dari MethodBase)
Module	Mendapatkan modul yang metode dinamisnya terkait secara logis.
Name	Mendapatkan nama metode dinamis.
ReflectedType	Mendapatkan kelas yang digunakan dalam refleksi untuk mendapatkan metode .
ReturnParameter	Mendapatkan parameter pengembalian dari metode dinamis.
ReturnType	Mendapatkan jenis nilai pengembalian untuk metode dinamis.
ReturnTypeCustomAttributes	Mendapatkan atribut kustom dari jenis pengembalian untuk metode dinamis.

Metode

Nama	Deskripsi
CreateDelegate(Type, Object)	Menyelesaikan metode dinamis dan membuat delegasi yang dapat digunakan untuk menjalankannya, menentukan jenis delegasi dan objek tempat delegasi terikat.
CreateDelegate(Type)	Menyelesaikan metode dinamis dan membuat delegasi yang dapat digunakan untuk menjalankannya.
CreateDelegate<T>()	Membuat delegasi jenis T dari metode ini. (Diperoleh dari MethodInfo)
CreateDelegate<T>(Object)	Membuat delegasi jenis T dengan target yang ditentukan dari metode ini. (Diperoleh dari MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)	Menentukan parameter metode dinamis.
Equals(Object)	Mengembalikan nilai yang menunjukkan apakah instans ini sama dengan objek tertentu. (Diperoleh dari MethodInfo)
GetBaseDefinition()	Mengembalikan implementasi dasar untuk metode .
GetCustomAttributes(Boolean)	Mengembalikan semua atribut kustom yang ditentukan untuk metode .
GetCustomAttributes(Type, Boolean)	Mengembalikan atribut kustom dari jenis yang ditentukan yang telah diterapkan ke metode .
GetCustomAttributesData()	Mengembalikan daftar objek CustomAttributeData yang mewakili data tentang atribut yang telah diterapkan ke anggota target. (Diperoleh dari MemberInfo)
GetDynamicILInfo()	Mengembalikan objek DynamicILInfo yang dapat digunakan untuk menghasilkan isi metode dari token metadata, cakupan, dan aliran bahasa perantara (MSIL) Microsoft.
GetGenericArguments()	Mengembalikan array Type objek yang mewakili argumen jenis metode generik atau parameter jenis definisi metode generik. (Diperoleh dari MethodInfo)
GetGenericMethodDefinition()	Mengembalikan MethodInfo objek yang mewakili definisi metode generik tempat metode saat ini dapat dibangun. (Diperoleh dari MethodInfo)
GetHashCode()	Mengembalikan kode hash untuk instans ini. (Diperoleh dari MethodInfo)
GetILGenerator()	Mengembalikan generator bahasa perantara (MSIL) Microsoft untuk metode dengan ukuran aliran MSIL default 64 byte.
GetILGenerator(Int32)	Mengembalikan generator bahasa perantara Microsoft (MSIL) untuk metode dengan ukuran aliran MSIL yang ditentukan.
GetMethodBody()	Ketika ditimpa di kelas turunan, mendapatkan objek MethodBody yang menyediakan akses ke aliran MSIL, variabel lokal, dan pengecualian untuk metode saat ini. (Diperoleh dari MethodBase)
GetMethodImplementationFlags()	Mengembalikan bendera implementasi untuk metode .
GetParameters()	Mengembalikan parameter metode dinamis.
HasSameMetadataDefinitionAs(MemberInfo)	Menentukan dan mewakili metode dinamis yang dapat dikompilasi, dijalankan, dan dibuang. Metode yang dibuang tersedia untuk pengumpulan sampah. (Diperoleh dari MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Memanggil metode dinamis menggunakan parameter yang ditentukan, di bawah batasan pengikat yang ditentukan, dengan informasi budaya yang ditentukan.
IsDefined(Type, Boolean)	Menunjukkan apakah jenis atribut kustom yang ditentukan ditentukan.
MakeGenericMethod(Type[])	Mengganti elemen array jenis untuk parameter jenis definisi metode generik saat ini, dan mengembalikan objek yang MethodInfo mewakili metode yang dihasilkan. (Diperoleh dari MethodInfo)
MemberwiseClone()	Membuat salinan dangkal dari Objectsaat ini. (Diperoleh dari Object)
ToString()	Mengembalikan tanda tangan metode, yang direpresentasikan sebagai string.

Metode Ekstensi

Nama	Deskripsi
GetBaseDefinition(MethodInfo)	Menentukan dan mewakili metode dinamis yang dapat dikompilasi, dijalankan, dan dibuang. Metode yang dibuang tersedia untuk pengumpulan sampah.
GetCustomAttribute(MemberInfo, Type, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttribute(MemberInfo, Type)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttribute<T>(MemberInfo, Boolean)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttribute<T>(MemberInfo)	Mengambil atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo, Type, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes(MemberInfo, Type)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetCustomAttributes(MemberInfo)	Mengambil kumpulan atribut kustom yang diterapkan ke anggota tertentu.
GetCustomAttributes<T>(MemberInfo, Boolean)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu, dan secara opsional memeriksa leluhur anggota tersebut.
GetCustomAttributes<T>(MemberInfo)	Mengambil kumpulan atribut kustom dari jenis tertentu yang diterapkan ke anggota tertentu.
GetMetadataToken(MemberInfo)	Mendapatkan token metadata untuk anggota tertentu, jika tersedia.
GetRuntimeBaseDefinition(MethodInfo)	Mengambil objek yang mewakili metode yang ditentukan pada kelas dasar langsung atau tidak langsung tempat metode pertama kali dideklarasikan.
HasMetadataToken(MemberInfo)	Mengembalikan nilai yang menunjukkan apakah token metadata tersedia untuk anggota yang ditentukan.
IsDefined(MemberInfo, Type, Boolean)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu, dan, secara opsional, diterapkan ke leluhurnya.
IsDefined(MemberInfo, Type)	Menunjukkan apakah atribut kustom dari jenis tertentu diterapkan ke anggota tertentu.

Lihat juga

• Cara: Menentukan dan Menjalankan Metode Dinamis
• Masalah Keamanan dalam Reflection Emit
• Panduan: Memancarkan Kode dalam Skenario Kepercayaan Parsial