DynamicMethod Sınıf

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kodlar:

netstandard.dll, 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 örnekte yöntemin dönüş değeri olarak ikinci parametre kullanılı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 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

sınıfını DynamicMethod kullanarak çalışma zamanında bir yöntemi oluşturmak ve yürütmek için, bir dinamik derleme ve yöntemini içerecek dinamik bir tür oluşturmak zorunda kalmadan kullanabilirsiniz. Tam zamanında (JIT) derleyicisi tarafından oluşturulan yürütülebilir kod, DynamicMethod nesnesi geri alındığında geri kazanılır. Dinamik yöntemler, az miktarda kod oluşturmanın ve yürütmenin en verimli yoludur.

Dinamik bir yöntem anonim olarak barındırılabilir veya mantıksal olarak bir modülle veya bir türle ilişkilendirilebilir.

• Dinamik yöntem anonim olarak barındırılıyorsa, sistem tarafından sağlanan bir derlemede bulunur ve bu nedenle diğer kodlardan yalıtılır. Varsayılan olarak, genel olmayan verilere erişimi yoktur. Anonim bir şekilde barındırılan bir dinamik yöntem, ReflectionPermission bayrağıyla yetkilendirilmişse, ReflectionPermissionFlag.RestrictedMemberAccess JIT derleyicisinin görünürlük denetimlerini atlama yeteneği sınırlı olabilir. Dinamik yöntem tarafından erişilen özel üyeleri olan derlemenin güven düzeyi, dinamik yöntemin yaydığı çağrı yığınının güven düzeyine eşit veya onun bir alt kümesi olmalıdır. Anonim olarak barındırılan dinamik yöntemler hakkında daha fazla bilgi için bkz . İzlenecek Yol: Kısmi Güven Senaryolarında Kod Yayma.

• Dinamik yöntem belirttiğiniz bir modülle ilişkiliyse, dinamik yöntem bu modül için etkili bir şekilde geneldir. Modüldeki tüm türlere ve türlerin internal üyelerinin tümüne (Friend Visual Basic'te) erişebilir. Kodunuzu içeren çağrı yığını, ReflectionPermission bayrağı ile bir RestrictedMemberAccess talebini karşılayabildiği sürece, modülü kendiniz oluşturmuş olmasanız bile herhangi bir modülle dinamik bir yöntem ilişkilendirebilirsiniz. Eğer ReflectionPermissionFlag.MemberAccess bayrağı izin kapsamında dahil edilirse, dinamik yöntem JIT derleyicisinin görünürlük denetimlerini atlayabilir ve modülde veya herhangi bir derlemedeki diğer herhangi bir modülde bildirilen tüm türlerin özel verilerine erişebilir.

  Note

  Bir dinamik yöntemin ilişkilendirildiği modülü belirttiğinizde, bu modül anonim barındırma için kullanılan sistem tarafından sağlanan derlemede olmamalıdır.

• Dinamik yöntem belirttiğiniz bir türle ilişkiliyse, erişim düzeyinden bağımsız olarak türün tüm üyelerine erişimi olur. Ayrıca JIT görünürlük denetimleri atlanabilir. Bu, dinamik yönteme aynı modülde veya herhangi bir derlemedeki diğer modüllerde bildirilen diğer türlerin özel verilerine erişim verir. Bir dinamik yöntemi herhangi bir türle ilişkilendirebilirsiniz, ancak kodunuza hem ReflectionPermission hem de RestrictedMemberAccess bayraklarıyla MemberAccess yetki verilmesi gereklidir.

Anonim olarak barındırılan dinamik bir yöntemin, bayrak ReflectionPermission veya RestrictedMemberAccess verildiğinde, JIT görünürlüğü denetimleri olsun ya da olmasın, hangi tür ve üyelerin erişilebilir olduğunu gösteren tablo aşağıda yer almaktadır.

Görünürlük denetimleri	RestrictedMemberAccess olmadan	RestrictedMemberAccess ile
JIT görünürlük denetimlerini atlamadan	Herhangi bir derlemedeki ortak türlerin genel üyeleri.	Herhangi bir derlemedeki ortak türlerin genel üyeleri.
Kısıtlamalarla birlikte JIT görünürlük denetimlerini atlama	Herhangi bir derlemedeki ortak türlerin genel üyeleri.	Tüm türlerin tüm üyeleri, yalnızca dinamik yöntemi yayan derlemenin güven düzeyine eşit veya daha düşük güven düzeyine sahip derlemelerde yer alabilir.

Aşağıdaki tabloda, bir modülle veya modüldeki bir türle ilişkilendirilmiş dinamik bir yöntem için hangi türlerin ve üyelerin erişilebilir olduğu gösterilmektedir.

JIT görünürlük denetimlerini atlama	Modülle ilişkilendirilmiş	Türle ilişkilendirilmiş
Hayı	Modüldeki genel, iç ve özel türlerin genel ve iç üyeleri. Herhangi bir derlemedeki ortak türlerin genel üyeleri.	İlişkili türün tüm üyeleri. Modüldeki diğer tüm türlerin genel ve dahili üyeleri. Herhangi bir derlemedeki ortak türlerin genel üyeleri.
Yes	Herhangi bir bütünlemedeki tüm türlerin tüm üyeleri.	Herhangi bir bütünlemedeki tüm türlerin tüm üyeleri.

Bir modülle ilişkili dinamik yöntem, bu modülün izinlerine sahiptir. Bir türle ilişkili dinamik yöntem, bu türü içeren modülün izinlerine sahiptir.

Dinamik yöntemlerin ve parametrelerinin adlandırılması gerekmez, ancak hata ayıklamaya yardımcı olması için adları belirtebilirsiniz. Özel öznitelikler dinamik yöntemlerde veya parametrelerinde desteklenmez.

Dinamik yöntemler static yöntemler (Shared Visual Basic'teki yöntemler) olsa da, temsilci bağlamaya yönelik gevşek kurallar, dinamik bir yöntemin bir nesneye bağlanmasına olanak tanır, böylece bu temsilci örneği kullanılarak çağrıldığında örnek yöntemi gibi davranır. Bu CreateDelegate(Type, Object) yöntem aşırı yüklemesi için bir örnek sağlanmıştır.

Verification

Aşağıdaki liste, dinamik yöntemlerin hangi koşullar altında doğrulanamaz kod içerebileceğini özetlemektedir. (Örneğin, dinamik bir yöntem, özelliği InitLocals olarak ayarlanırsa false onaylanamaz.)

• Güvenlik açısından kritik bir derlemeyle ilişkili dinamik bir yöntem de güvenlik açısından kritiktir ve doğrulamayı atlayabilir. Örneğin, masaüstü uygulaması olarak çalıştırılan güvenlik öznitelikleri olmayan bir derleme, çalışma zamanı tarafından güvenlik açısından kritik olarak değerlendirilir. Bir dinamik yöntemi derlemeyle ilişkilendirirseniz, dinamik yöntem doğrulanamaz kod içerebilir.
• Onaylanamayan kod içeren dinamik bir yöntem düzey 1 saydamlığı olan bir derlemeyle ilişkiliyse, tam zamanında (JIT) derleyicisi bir güvenlik talebi ekler. Talep yalnızca dinamik yöntem tam güvenilir kod tarafından yürütülürse başarılı olur. Bkz. Security-Transparent Kodu, Düzey 1.
• Doğrulanamayan kod içeren dinamik bir yöntem düzey 2 saydamlığı (mscorlib.dllgibi) olan bir derlemeyle ilişkiliyse, güvenlik talebi oluşturmak yerine bir özel durum oluşturur (JIT derleyicisi tarafından eklenir). Bkz. Security-Transparent Kodu, Düzey 2.
• Doğrulanamayan kod içeren anonim olarak barındırılan dinamik yöntem her zaman bir özel durum oluşturur. Tam olarak güvenilen kod tarafından oluşturulup yürütülse bile doğrulamayı asla atlayabilir.

Doğrulanamayan kod için oluşan özel durum, dinamik yöntemin çağrılma şekline bağlı olarak değişir. CreateDelegate yönteminden döndürülen bir temsilciyi kullanarak dinamik bir yöntem çağırırsanız, bir VerificationException fırlatılır. Eğer Invoke yöntemini kullanarak dinamik yöntemi çağırırsanız, bir iç TargetInvocationException ile bir VerificationException fırlatılır.

Oluşturucular

Name	Description
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ü 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[], 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, 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[], 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[], 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.
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[])	Yöntem adını, dönüş türünü ve parametre türlerini belirterek anonim olarak barındırılan bir dinamik yöntem başlatır.

Özellikler

Name	Description
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.
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 tarafından Assemblyaçıklanıp açıklanmadığını belirten bir değer alır; diğer 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 bir veya daha fazla derlemeye başvurup başvurmadığı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 açıklanmadığını, yani yöntemin veya oluşturucunun yalnızca sınıfı ve türetilmiş sınıfları içinde görünür olduğunu belirten bir değer alır. (Devralındığı yer: MethodBase)
IsFamilyAndAssembly	Bu yöntemin veya oluşturucunun görünürlüğünün tarafından FamANDAssemaçıklanıp açıklanmadığını belirten bir değer alır; yani, yöntem veya oluşturucu türetilmiş sınıflar tarafından çağrılabilir, ancak yalnızca aynı derlemedeyse. (Devralındığı yer: MethodBase)
IsFamilyOrAssembly	Bu yöntemin veya oluşturucunun olası görünürlüğünün tarafından 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 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)
IsHideBySig	Türetilmiş sınıfta yalnızca aynı türde tam olarak 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; başka bir ifadeyle, kritik işlemler gerçekleştirip gerçekleştiremeyeceği ve saydam kodla erişilip erişilemeyeceği.
IsSecurityTransparent	Geçerli dinamik yöntemin geçerli güven düzeyinde saydam olup olmadığını ve bu nedenle kritik işlemleri gerçekleştiremeyeceğini gösteren bir değer alır.
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 elde etmek 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

Name	Description
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(Type)	Dinamik yöntemi tamamlar ve yürütmek için kullanılabilecek bir temsilci oluşturur.
CreateDelegate<T>()	Bu yöntemden tür T temsilcisi 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ğer 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ış olan belirtilen türün özel özniteliklerini döndürür.
GetCustomAttributesData()	Hedef üyeye CustomAttributeData uygulanmış öznitelikler hakkındaki verileri temsil eden nesnelerin listesini döndürür. (Devralındığı yer: MemberInfo)
GetDynamicILInfo()	Meta veri belirteçlerinden, kapsamlardan ve Microsoft ara dil (MSIL) akışlarından bir yöntem gövdesi oluşturmak için kullanılabilecek bir DynamicILInfo nesnesi 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 yöntem tanımını temsil eden bir nesne döndürür. (Devralındığı yer: MethodInfo)
GetHashCode()	Bu örneğin karma kodunu döndürür. (Devralındığı yer: MethodInfo)
GetILGenerator()	Varsayılan MSIL akış boyutu 64 bayt olan yöntem için 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 nesne 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.
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.
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 oluşturulur yöntemi temsil eden bir MethodInfo nesne döndürür. (Devralındığı yer: MethodInfo)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
ToString()	Dize olarak temsil edilen yönteminin imzasını döndürür.

Uzantı Metotları

Name	Description
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.
GetCustomAttribute(MemberInfo, Type, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliği alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttribute(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttribute<T>(MemberInfo, Boolean)	Belirtilen bir üyeye uygulanan belirtilen türdeki özel özniteliği alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
GetCustomAttribute<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde bir özel özniteliği alır.
GetCustomAttributes(MemberInfo, Boolean)	Belirli bir üyeye uygulanan özel öznitelikler koleksiyonunu alır ve isteğe bağlı olarak bu üyenin atalarını inceler.
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 atalarını inceler.
GetCustomAttributes(MemberInfo, Type)	Belirtilen üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetCustomAttributes(MemberInfo)	Belirtilen üyeye uygulanan özel öznitelik koleksiyonunu 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 atalarını inceler.
GetCustomAttributes<T>(MemberInfo)	Belirtilen üyeye uygulanan belirtilen türde özel özniteliklerden oluşan bir koleksiyonu alır.
GetMetadataToken(MemberInfo)	Varsa, verilen üye için bir meta veri belirteci alır.
GetRuntimeBaseDefinition(MethodInfo)	Yöntemin ilk bildirildiği doğrudan veya dolaylı temel sınıfta belirtilen yöntemi temsil eden bir nesnesi 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.
IsDefined(MemberInfo, Type, Boolean)	Belirtilen türde özel özniteliklerin belirtilen bir üyeye uygulanıp uygulanmadığını ve isteğe bağlı olarak üst öğeye uygulanıp uygulanmadığını gösterir.
IsDefined(MemberInfo, Type)	Belirtilen türde özel özniteliklerin belirtilen üyeye uygulanıp uygulanmadığını gösterir.

Ayrıca bkz.

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