DynamicMethod Sınıf

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kod:

System.Reflection.Emit.Lightweight.dll

Kaynak:

DynamicMethod.cs

Derlenebilen, yürütülebilen ve atılabilir dinamik bir yöntemi tanımlar ve temsil eder. Çöp toplama için atılan yöntemler kullanılabilir.

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

Devralma

Object

MemberInfo

MethodBase

MethodInfo

DynamicMethod

Örnekler

Aşağıdaki kod örneği, iki parametre alan dinamik bir yöntem oluşturur. Örnek, ilk parametreyi konsola yazdıran basit bir işlev gövdesi yayar ve örnek, ikinci parametreyi yöntemin dönüş değeri olarak kullanır. Örnek, bir temsilci oluşturarak yöntemini tamamlar, temsilciyi farklı parametrelerle çağırır ve son olarak yöntemini kullanarak Invoke dinamik yöntemi çağırır.

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

Açıklamalar

Bu API hakkında daha fazla bilgi için bkz. DynamicMethod için ek API açıklamaları.

Oluşturucular

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)	Yöntem adını, özniteliklerini, çağırma kuralını, dönüş türünü, parametre türlerini, modülünü ve dinamik yöntemin Microsoft ara dili (MSIL) tarafından erişilen türler ve üyeler için tam zamanında (JIT) görünürlük denetimlerinin atlanıp atlanmayacağını belirterek bir modül için genel olan dinamik bir yöntem oluşturur.
DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)	Yöntem adını, özniteliklerini, çağırma kuralını, dönüş türünü, parametre türlerini, dinamik yöntemin mantıksal olarak ilişkilendirildiği türü ve dinamik yöntemin Microsoft ara dili (MSIL) tarafından erişilen türler ve üyeler için tam zamanında (JIT) görünürlük denetimlerinin atlanıp atlanmayacağını belirten dinamik bir yöntem oluşturur.
DynamicMethod(String, Type, Type[])	Anonim olarak barındırılan bir dinamik yöntem başlatır ve yöntem adını, dönüş türünü ve parametre türlerini belirtir.
DynamicMethod(String, Type, Type[], Boolean)	Yöntem adını, dönüş türünü, parametre türlerini ve dinamik yöntemin Microsoft ara dili (MSIL) tarafından erişilen türler ve üyeler için tam zamanında (JIT) görünürlük denetimlerinin atlanıp atlanmayacağını belirterek anonim olarak barındırılan bir dinamik yöntemi başlatır.
DynamicMethod(String, Type, Type[], Module)	Yöntem adını, dönüş türünü, parametre türlerini ve modülü belirterek bir modül için genel olan dinamik bir yöntem oluşturur.
DynamicMethod(String, Type, Type[], Module, Boolean)	Yöntem adını, dönüş türünü, parametre türlerini, modülü ve dinamik yöntemin Microsoft ara dili (MSIL) tarafından erişilen türler ve üyeler için tam zamanında (JIT) görünürlük denetimlerinin atlanıp atlanmayacağını belirterek bir modül için genel olan dinamik bir yöntem oluşturur.
DynamicMethod(String, Type, Type[], Type)	Yöntem adını, dönüş türünü, parametre türlerini ve dinamik yöntemin mantıksal olarak ilişkilendirildiği türü belirterek dinamik bir yöntem oluşturur.
DynamicMethod(String, Type, Type[], Type, Boolean)	Yöntem adını, dönüş türünü, parametre türlerini, dinamik yöntemin mantıksal olarak ilişkilendirildiği türü ve dinamik yöntemin Microsoft ara dili (MSIL) tarafından erişilen türler ve üyeler için tam zamanında (JIT) görünürlük denetimlerinin atlanıp atlanmayacağını belirten dinamik bir yöntem oluşturur.

Özellikler

Attributes	Dinamik yöntem oluşturulduğunda belirtilen öznitelikleri alır.
CallingConvention	Dinamik yöntem oluşturulduğunda belirtilen çağırma kuralını alır.
ContainsGenericParameters	Genel bir yöntemin atanmamış genel tür parametreleri içerip içermediğini gösteren bir değer alır. (Devralındığı yer: MethodInfo)
CustomAttributes	Bu üyenin özel özniteliklerini içeren bir koleksiyon alır. (Devralındığı yer: MemberInfo)
DeclaringType	Her zaman null dinamik yöntemler için olan yöntemini bildiren türü alır.
InitLocals	yöntemindeki yerel değişkenlerin sıfırdan başlatılıp başlatılmadığını belirten bir değer alır veya ayarlar.
IsAbstract	Yöntemin soyut olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsAssembly	Bu yöntemin veya oluşturucunun olası görünürlüğünün ile Assemblyaçıklanıp açıklanmadığını belirten bir değer alır; başka bir deyişle, yöntem veya oluşturucu aynı derlemedeki diğer türler için en fazla görünürdür ve derleme dışındaki türetilmiş türler tarafından görünmez. (Devralındığı yer: MethodBase)
IsCollectible	Bu MemberInfo nesnenin bir collectible AssemblyLoadContextiçinde tutulan derlemenin parçası olup olmadığını gösteren bir değer alır. (Devralındığı yer: MemberInfo)
IsConstructedGenericMethod	Derlenebilen, yürütülebilen ve atılabilir dinamik bir yöntemi tanımlar ve temsil eder. Çöp toplama için atılan yöntemler kullanılabilir. (Devralındığı yer: MethodBase)
IsConstructor	Yöntemin bir oluşturucu olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsFamily	Bu yöntemin veya oluşturucunun görünürlüğünün tarafından Familyaçıklanıp tanımlanmadığını belirten bir değer alır; başka bir ifadeyle, yöntem veya oluşturucu yalnızca kendi sınıfı ve türetilmiş sınıfları içinde görünür. (Devralındığı yer: MethodBase)
IsFamilyAndAssembly	Bu yöntemin veya oluşturucunun görünürlüğünün tarafından FamANDAssemaçıklanıp tanımlanmadığını belirten bir değer alır; başka bir ifadeyle, yöntem veya oluşturucu türetilmiş sınıflar tarafından çağrılabilir, ancak yalnızca aynı derlemedeyseler. (Devralındığı yer: MethodBase)
IsFamilyOrAssembly	Bu yöntemin veya oluşturucunun olası görünürlüğünün ile FamORAssemaçıklanıp açıklanmadığını belirten bir değer alır; başka bir ifadeyle, yöntem veya oluşturucu nerede olurlarsa olsunlar türetilmiş sınıflar tarafından ve aynı derlemedeki sınıflar tarafından çağrılabilir. (Devralındığı yer: MethodBase)
IsFinal	Bu yöntemin finalolup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsGenericMethod	Geçerli yöntemin genel bir yöntem olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodInfo)
IsGenericMethodDefinition	Geçerlinin MethodInfo genel bir yöntemin tanımını temsil edip etmediğini belirten bir değer alır. (Devralındığı yer: MethodInfo)
IsHideBySig	Türetilmiş sınıfta yalnızca aynı türdeki aynı imzaya sahip bir üyenin gizlenip gizlenmediğini belirten bir değer alır. (Devralındığı yer: MethodBase)
IsPrivate	Bu üyenin özel olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsPublic	Bunun genel bir yöntem olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsSecurityCritical	Geçerli dinamik yöntemin güvenlik açısından kritik mi yoksa güvenlik açısından güvenli mi olduğunu belirten bir değer alır ve bu nedenle kritik işlemler gerçekleştirebilir.
IsSecuritySafeCritical	Geçerli dinamik yöntemin geçerli güven düzeyinde güvenlik açısından güvenli-kritik olup olmadığını gösteren bir değer alır; yani, kritik işlemler gerçekleştirip gerçekleştiremeyeceğini ve saydam kodla erişilip erişilemeyeceğini gösterir.
IsSecurityTransparent	Geçerli dinamik yöntemin geçerli güven düzeyinde saydam olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemler gerçekleştiremez.
IsSpecialName	Bu yöntemin özel bir ada sahip olup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsStatic	yönteminin staticolup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
IsVirtual	yönteminin virtualolup olmadığını belirten bir değer alır. (Devralındığı yer: MethodBase)
MemberType	Bu üyenin bir MemberTypes yöntem olduğunu belirten bir değer alır. (Devralındığı yer: MethodInfo)
MetadataToken	Meta veri öğesini tanımlayan bir değer alır. (Devralındığı yer: MemberInfo)
MethodHandle	Dinamik yöntemler için desteklenmez.
MethodImplementationFlags	MethodImplAttributes Bir yöntem uygulamasının özniteliklerini belirten bayrakları alır. (Devralındığı yer: MethodBase)
Module	Dinamik yöntemin mantıksal olarak ilişkilendirildiği modülü alır.
Name	Dinamik yöntemin adını alır.
ReflectedType	yöntemini almak için yansımada kullanılan sınıfını alır.
ReturnParameter	Dinamik yöntemin dönüş parametresini alır.
ReturnType	Dinamik yöntem için dönüş değerinin türünü alır.
ReturnTypeCustomAttributes	Dinamik yöntem için dönüş türünün özel özniteliklerini alır.

Yöntemler

CreateDelegate(Type)	Dinamik yöntemi tamamlar ve yürütmek için kullanılabilecek bir temsilci oluşturur.
CreateDelegate(Type, Object)	Dinamik yöntemi tamamlar ve temsilci türünü ve temsilcinin bağlı olduğu nesneyi belirterek yürütmek için kullanılabilecek bir temsilci oluşturur.
CreateDelegate<T>()	Bu yöntemden türünde T bir temsilci oluşturur. (Devralındığı yer: MethodInfo)
CreateDelegate<T>(Object)	Bu yöntemden belirtilen hedefle türünde T bir temsilci oluşturur. (Devralındığı yer: MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)	Dinamik yöntemin parametresini tanımlar.
Equals(Object)	Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür. (Devralındığı yer: MethodInfo)
GetBaseDefinition()	yöntemi için temel uygulamayı döndürür.
GetCustomAttributes(Boolean)	yöntemi için tanımlanan tüm özel öznitelikleri döndürür.
GetCustomAttributes(Type, Boolean)	Yöntemine uygulanmış belirtilen türdeki özel öznitelikleri döndürür.
GetCustomAttributesData()	Hedef üyeye CustomAttributeData uygulanmış özniteliklerle ilgili verileri temsil eden nesnelerin listesini döndürür. (Devralındığı yer: MemberInfo)
GetDynamicILInfo()	DynamicILInfo Meta veri belirteçlerinden, kapsamlardan ve Microsoft ara dil (MSIL) akışlarından yöntem gövdesi oluşturmak için kullanılabilecek bir nesne döndürür.
GetGenericArguments()	Genel bir yöntemin Type tür bağımsız değişkenlerini veya genel bir yöntem tanımının tür parametrelerini temsil eden bir nesne dizisi döndürür. (Devralındığı yer: MethodInfo)
GetGenericMethodDefinition()	MethodInfo Geçerli yöntemin oluşturulabileceği genel bir yöntem tanımını temsil eden bir nesnesi döndürür. (Devralındığı yer: MethodInfo)
GetHashCode()	Bu örneğe ilişkin karma kodu döndürür. (Devralındığı yer: MethodInfo)
GetILGenerator()	Yöntemi için varsayılan MSIL akış boyutu 64 bayt olan bir Microsoft ara dil (MSIL) oluşturucusu döndürür.
GetILGenerator(Int32)	Belirtilen MSIL akış boyutuna sahip yöntemi için bir Microsoft ara dil (MSIL) oluşturucu döndürür.
GetMethodBody()	Türetilmiş bir sınıfta geçersiz kılındığında, MSIL akışına, yerel değişkenlere ve geçerli yöntem için özel durumlara erişim sağlayan bir MethodBody nesnesi alır. (Devralındığı yer: MethodBase)
GetMethodImplementationFlags()	yöntemi için uygulama bayraklarını döndürür.
GetParameters()	Dinamik yöntemin parametrelerini döndürür.
GetType()	Bir yöntemin özniteliklerini bulur ve yöntem meta verilerine erişim sağlar. (Devralındığı yer: MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	Derlenebilen, yürütülebilen ve atılabilir dinamik bir yöntemi tanımlar ve temsil eder. Çöp toplama için atılan yöntemler kullanılabilir. (Devralındığı yer: MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	Belirtilen kültür bilgileriyle belirtilen bağlayıcının kısıtlamaları altında belirtilen parametreleri kullanarak dinamik yöntemi çağırır.
Invoke(Object, Object[])	Belirtilen parametreleri kullanarak geçerli örnek tarafından temsil edilen yöntemi veya oluşturucuyu çağırır. (Devralındığı yer: MethodInfo)
IsDefined(Type, Boolean)	Belirtilen özel öznitelik türünün tanımlanıp tanımlanmadığını gösterir.
MakeGenericMethod(Type[])	Geçerli genel yöntem tanımının tür parametreleri için bir tür dizisinin öğelerinin yerini alır ve sonuçta elde edilen yöntemi temsil eden bir MethodInfo nesne döndürür. (Devralındığı yer: MethodInfo)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
ToString()	Dize olarak temsil edilen yönteminin imzasını döndürür.

Uzantı Metotları

GetCustomAttribute(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türde bir özel özniteliği alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
GetCustomAttribute<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türde bir özel özniteliği alır ve isteğe bağlı olarak bu üyenin üstlerini inceler.
GetCustomAttributes(MemberInfo)	Belirtilen üyeye uygulanan özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes(MemberInfo, Boolean)	Belirtilen üyeye uygulanan özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttributes(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin üst öğelerini inceler.
GetCustomAttributes<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliklerden oluşan bir koleksiyonu alır ve isteğe bağlı olarak bu üyenin üst öğelerini inceler.
IsDefined(MemberInfo, Type)	Belirtilen türe ait özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını gösterir.
IsDefined(MemberInfo, Type, Boolean)	Belirtilen türe ait özel özniteliklerin belirtilen bir üyeye uygulanıp uygulanmadığını ve isteğe bağlı olarak üstlerine uygulanıp uygulanmadığını gösterir.
GetMetadataToken(MemberInfo)	Varsa, verilen üye için bir meta veri belirteci alır.
HasMetadataToken(MemberInfo)	Belirtilen üye için bir meta veri belirtecinin kullanılabilir olup olmadığını gösteren bir değer döndürür.
GetBaseDefinition(MethodInfo)	Derlenebilen, yürütülebilen ve atılabilir dinamik bir yöntemi tanımlar ve temsil eder. Çöp toplama için atılan yöntemler kullanılabilir.
GetRuntimeBaseDefinition(MethodInfo)	Yöntemin ilk bildirildiği doğrudan veya dolaylı temel sınıfta belirtilen yöntemi temsil eden bir nesnesi alır.

Ayrıca bkz.

• Nasıl yapılır: Dinamik Yöntemleri Tanımlama ve Yürütme
• Yansıma Yaymadaki Güvenlik Sorunları
• İzlenecek yol: Kısmi Güven Senaryolarında Kod Yayma