DynamicMethod Sınıf

Tanım

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
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DynamicMethod : System.Reflection.MethodInfo
type DynamicMethod = class
    inherit MethodInfo
[<System.Runtime.InteropServices.ComVisible(true)>]
type DynamicMethod = class
    inherit MethodInfo
Public NotInheritable Class DynamicMethod
Inherits MethodInfo
Devralma
Öznitelikler

Ö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.

IsSecurityCritical

Geçerli yöntem veya oluşturucunun geçerli güven düzeyinde güvenlik açısından kritik veya güvenlik açısından güvenli-kritik olduğunu belirten bir değer alır ve bu nedenle kritik işlemler gerçekleştirebilir.

(Devralındığı yer: MethodBase)
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.

IsSecuritySafeCritical

Geçerli yöntemin veya oluşturucunun geçerli güven düzeyinde güvenlik açısından güvenli-kritik olup olmadığını belirten 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.

(Devralındığı yer: MethodBase)
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.

IsSecurityTransparent

Geçerli yöntemin veya oluşturucunun 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.

(Devralındığı yer: MethodBase)
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.

MethodHandle

Bir yöntemin iç meta veri gösteriminin tanıtıcısını alır.

(Devralındığı yer: MethodBase)
MethodImplementationFlags

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.

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.

Module

Geçerli MemberInfo tarafından temsil edilen üyeyi bildiren türün tanımlandığı modülü alır.

(Devralındığı yer: MemberInfo)
Name

Dinamik yöntemin adını alır.

ReflectedType

yöntemini almak için yansımada kullanılan sınıfını alır.

ReflectedType

bu örneğini MemberInfoalmak için kullanılan sınıf nesnesini alır.

(Devralındığı yer: MemberInfo)
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.

ReturnTypeCustomAttributes

Dönüş türü için özel öznitelikleri alır.

(Devralındığı yer: MethodInfo)

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.

GetBaseDefinition()

Türetilmiş bir sınıfta geçersiz kılındığında, bu örnek tarafından temsil edilen yöntemin ilk bildirildiği doğrudan veya dolaylı temel sınıfta yönteminin nesnesini döndürür MethodInfo .

(Devralındığı yer: MethodInfo)
GetCustomAttributes(Boolean)

yöntemi için tanımlanan tüm özel öznitelikleri döndürür.

GetCustomAttributes(Boolean)

Türetilmiş bir sınıfta geçersiz kılındığında, bu üyeye uygulanan tüm özel özniteliklerden oluşan bir dizi döndürür.

(Devralındığı yer: MemberInfo)
GetCustomAttributes(Type, Boolean)

Yöntemine uygulanmış belirtilen türdeki özel öznitelikleri döndürür.

GetCustomAttributes(Type, Boolean)

Türetilmiş bir sınıfta geçersiz kılındığında, bu üyeye uygulanan ve tarafından Typetanımlanan bir özel öznitelik dizisi döndürür.

(Devralındığı yer: MemberInfo)
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.

GetMethodImplementationFlags()

Türetilmiş bir sınıfta geçersiz kılındığında bayrakları döndürür MethodImplAttributes .

(Devralındığı yer: MethodBase)
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, BindingFlags, Binder, Object[], CultureInfo)

Türetilmiş bir sınıfta geçersiz kılındığında, yansıtılan yöntemi veya oluşturucuyu verilen parametrelerle çağırır.

(Devralındığı yer: MethodBase)
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.

IsDefined(Type, Boolean)

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen türde veya türetilmiş türlerinden bir veya daha fazla özniteliğin bu üyeye uygulanıp uygulanmadığını gösterir.

(Devralındığı yer: MemberInfo)
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.

Belirtik Arabirim Kullanımları

_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler.

(Devralındığı yer: MemberInfo)
_MemberInfo.GetType()

Sınıfını temsil eden MemberInfo bir Type nesnesi alır.

(Devralındığı yer: MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Bir nesne için tür bilgilerini alır ve bu da bir arabirimin tür bilgisini almak için kullanılabilir.

(Devralındığı yer: MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).

(Devralındığı yer: MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Bir nesne tarafından sunulan özelliklere ve yöntemlere erişim sağlar.

(Devralındığı yer: MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler.

(Devralındığı yer: MethodBase)
_MethodBase.GetType()

Bu üyenin açıklaması için bkz GetType(). .

(Devralındığı yer: MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

Bir nesne için tür bilgilerini alır ve bu da bir arabirimin tür bilgisini almak için kullanılabilir.

(Devralındığı yer: MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).

(Devralındığı yer: MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Bir nesne tarafından sunulan özelliklere ve yöntemlere erişim sağlar.

(Devralındığı yer: MethodBase)
_MethodBase.IsAbstract

Bu üyenin açıklaması için bkz IsAbstract. .

(Devralındığı yer: MethodBase)
_MethodBase.IsAssembly

Bu üyenin açıklaması için bkz IsAssembly. .

(Devralındığı yer: MethodBase)
_MethodBase.IsConstructor

Bu üyenin açıklaması için bkz IsConstructor. .

(Devralındığı yer: MethodBase)
_MethodBase.IsFamily

Bu üyenin açıklaması için bkz IsFamily. .

(Devralındığı yer: MethodBase)
_MethodBase.IsFamilyAndAssembly

Bu üyenin açıklaması için bkz IsFamilyAndAssembly. .

(Devralındığı yer: MethodBase)
_MethodBase.IsFamilyOrAssembly

Bu üyenin açıklaması için bkz IsFamilyOrAssembly. .

(Devralındığı yer: MethodBase)
_MethodBase.IsFinal

Bu üyenin açıklaması için bkz IsFinal. .

(Devralındığı yer: MethodBase)
_MethodBase.IsHideBySig

Bu üyenin açıklaması için bkz IsHideBySig. .

(Devralındığı yer: MethodBase)
_MethodBase.IsPrivate

Bu üyenin açıklaması için bkz IsPrivate. .

(Devralındığı yer: MethodBase)
_MethodBase.IsPublic

Bu üyenin açıklaması için bkz IsPublic. .

(Devralındığı yer: MethodBase)
_MethodBase.IsSpecialName

Bu üyenin açıklaması için bkz IsSpecialName. .

(Devralındığı yer: MethodBase)
_MethodBase.IsStatic

Bu üyenin açıklaması için bkz IsStatic. .

(Devralındığı yer: MethodBase)
_MethodBase.IsVirtual

Bu üyenin açıklaması için bkz IsVirtual. .

(Devralındığı yer: MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Bir ad kümesini karşılık gelen bir dağıtma tanımlayıcısı kümesine eşler.

(Devralındığı yer: MethodInfo)
_MethodInfo.GetType()

COM'dan yöntemine GetType() erişim sağlar.

(Devralındığı yer: MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

Bir arabirimin tür bilgilerini almak için kullanılabilecek bir nesnenin tür bilgilerini alır.

(Devralındığı yer: MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).

(Devralındığı yer: MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Bir nesne tarafından sunulan özelliklere ve yöntemlere erişim sağlar.

(Devralındığı yer: MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

Adlandırılmış öznitelikler hariç, bu üyede tanımlanan tüm özel özniteliklerin dizisini veya özel öznitelikler yoksa boş bir dizi döndürür.

(Devralındığı yer: MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

Bu üyede tanımlanan, türe göre tanımlanan özel öznitelik dizisini veya bu türe ait özel öznitelikler yoksa boş bir dizi döndürür.

(Devralındığı yer: MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

Bir veya daha fazla örneğinin bu üyede tanımlanıp tanımlanmadığını attributeType gösterir.

(Devralındığı yer: MemberInfo)

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.

Şunlara uygulanır

Ayrıca bkz.