DynamicMethod Sınıf

Tanım

Derlenebilecek, yürütülebilecek ve atılacak dinamik bir yöntemi tanımlar ve temsil eder.Defines and represents a dynamic method that can be compiled, executed, and discarded. Atılan Yöntemler çöp toplama için kullanılabilir.Discarded methods are available for garbage collection.

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.The following code example creates a dynamic method that takes two parameters. Örnek, konsola ilk parametreyi yazdıran basit bir işlev gövdesini yayar ve örnek, yöntemin dönüş değeri olarak ikinci parametreyi kullanır.The example emits a simple function body that prints the first parameter to the console, and the example uses the second parameter as the return value of the method. Örnek, bir temsilci oluşturarak yöntemi tamamlar, temsilciyi farklı parametrelerle çağırır ve son olarak yöntemi kullanarak dinamik yöntemi çağırır Invoke .The example completes the method by creating a delegate, invokes the delegate with different parameters, and finally invokes the dynamic method using the Invoke method.

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

Sınıfını, bir DynamicMethod dinamik derleme ve yöntemi içermesi için dinamik bir tür oluşturmaya gerek kalmadan çalışma zamanında bir yöntemi oluşturmak ve yürütmek için kullanabilirsiniz.You can use the DynamicMethod class to generate and execute a method at run time, without having to generate a dynamic assembly and a dynamic type to contain the method. Tam zamanında (JıT) derleyici tarafından oluşturulan yürütülebilir kod, DynamicMethod nesne geri kazanılır.The executable code created by the just-in-time (JIT) compiler is reclaimed when the DynamicMethod object is reclaimed. Dinamik yöntemler, az miktarda kod oluşturmak ve yürütmek için en verimli yoldur.Dynamic methods are the most efficient way to generate and execute small amounts of code.

Dinamik bir yöntem anonim olarak barındırılabilir veya bir modülle veya bir türle mantıksal olarak ilişkilendirilebilir.A dynamic method can be anonymously hosted, or it can be logically associated with a module or with a type.

  • Dinamik yöntem anonim olarak barındırılıyorsa, sistem tarafından sağlanmış bir derlemede bulunur ve bu nedenle diğer koddan yalıtılmıştır.If the dynamic method is anonymously hosted, it is located in a system-provided assembly, and therefore is isolated from other code. Varsayılan olarak, genel olmayan verilere erişemez.By default, it does not have access to any non-public data. Anonim olarak barındırılan dinamik bir yöntem, bayrağıyla verildiyse JıT derleyicisinin görünürlük denetimlerini atlayabilme yeteneğine sahip olabilir ReflectionPermission ReflectionPermissionFlag.RestrictedMemberAccess .An anonymously hosted dynamic method can have restricted ability to skip the JIT compiler's visibility checks, if it has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag. Ortak olmayan üyelere, dinamik yöntem tarafından erişilen derlemenin güven düzeyi, dinamik yöntemi oluşturan çağrı yığınının güven düzeyini veya bir alt kümesine eşit olmalıdır.The trust level of the assembly whose non-public members are accessed by the dynamic method must be equal to, or a subset of, the trust level of the call stack that emitted the dynamic method. Anonim olarak barındırılan dinamik yöntemler hakkında daha fazla bilgi için bkz. Izlenecek yol: kısmi güven senaryolarında kod yayma.For more information about anonymously hosted dynamic methods, see Walkthrough: Emitting Code in Partial Trust Scenarios.

  • Dinamik yöntem belirttiğiniz bir modülle ilişkiliyse, dinamik yöntem o modüle etkin bir şekilde geneldir.If the dynamic method is associated with a module that you specify, the dynamic method is effectively global to that module. Modüldeki tüm türlere ve internal türlerin tüm ( Friend Visual Basic) üyelerine erişebilir.It can access all types in the module and all internal (Friend in Visual Basic) members of the types. Modülün oluşturulma şeklinden bağımsız olarak, modüle sahip bir talebin, ReflectionPermission RestrictedMemberAccess kodunuzu içeren çağrı yığını tarafından karşılanıp karşılanamayacağını belirten bir modülle bir dinamik yöntemi ilişkilendirebilirsiniz.You can associate a dynamic method with any module, regardless of whether you created the module, provided that a demand for ReflectionPermission with the RestrictedMemberAccess flag can be satisfied by the call stack that includes your code. ReflectionPermissionFlag.MemberAccessBayrağa izin varsa, dinamik yöntem JIT derleyicisinin görünürlük denetimlerini atlayabilir ve modülde veya herhangi bir derlemede belirtilen tüm türlerin özel verilerine erişim sağlayabilir.If the ReflectionPermissionFlag.MemberAccess flag is included in the grant, the dynamic method can skip the JIT compiler's visibility checks and access the private data of all types declared in the module or in any other module in any assembly.

    Not

    Dinamik bir yöntemin ilişkilendirildiği modülü belirttiğinizde, bu modül anonim barındırma için kullanılan sistem tarafından sağlanmış derlemede yer almalıdır.When you specify the module with which a dynamic method is associated, that module must not be in the system-provided assembly that is used for anonymous hosting.

  • 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şebilir.If the dynamic method is associated with a type that you specify, it has access to all members of the type, regardless of access level. Ayrıca, JıT görünürlük denetimleri atlanabilir.In addition, JIT visibility checks can be skipped. Bu, dinamik yöntem 'e aynı modülde veya herhangi bir derlemedeki diğer bir modülde belirtilen diğer türlerin özel verilerine erişmesini sağlar.This gives the dynamic method access to the private data of other types declared in the same module or in any other module in any assembly. Dinamik bir yöntemi herhangi bir türle ilişkilendirebilirsiniz, ancak kodunuz ReflectionPermission hem hem de RestrictedMemberAccess bayraklarıyla verilmelidir MemberAccess .You can associate a dynamic method with any type, but your code must be granted ReflectionPermission with both the RestrictedMemberAccess and MemberAccess flags.

Aşağıdaki tabloda, ReflectionPermission bayrağın verilip verilmediğine bağlı olarak, JIT görünürlük denetimleri olmadan ve olmadan, anonim olarak barındırılan dinamik bir yöntem için hangi türlerin ve üyelerin erişilebilir olduğu gösterilmektedir RestrictedMemberAccess .The following table shows which types and members are accessible to an anonymously hosted dynamic method, with and without JIT visibility checks, depending on whether ReflectionPermission with the RestrictedMemberAccess flag is granted.

Koymadan RestrictedMemberAccessWithout RestrictedMemberAccess Kullanılarak RestrictedMemberAccessWith RestrictedMemberAccess
JıT görünürlük denetimlerini atlamadanWithout skipping JIT visibility checks Herhangi bir derlemede ortak türlerin ortak üyeleri.Public members of public types in any assembly. Herhangi bir derlemede ortak türlerin ortak üyeleri.Public members of public types in any assembly.
Kısıtlamalarla JıT görünürlük denetimleri atlanıyorSkipping JIT visibility checks, with restrictions Herhangi bir derlemede ortak türlerin ortak üyeleri.Public members of public types in any assembly. Tüm türlerin tüm üyeleri, yalnızca güven düzeyleri dinamik yöntemi oluşturan derlemenin güven düzeyine eşit veya daha küçük olan derlemelerde.All members of all types, only in assemblies whose trust levels are equal to or less than the trust level of the assembly that emitted the dynamic method.

Not

Öğesinden önce .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1 , ReflectionPermission bayrağı ile birlikte, yayma kodu gerekir ReflectionPermissionFlag.ReflectionEmit .Prior to the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, emitting code required ReflectionPermission with the ReflectionPermissionFlag.ReflectionEmit flag. Bu izin, izin kümeleri adında, varsayılan olarak, Internet izin kümesine değil, FullTrust ve LocalIntranet 'te bulunur.This permission is included by default in the FullTrust and LocalIntranet named permission sets, but not in the Internet permission set. Bu nedenle, bir kitaplığın önceki sürümlerinde, .NET Framework.NET Framework yalnızca SecurityCriticalAttribute özniteliği varsa ve bir için bir de çalıştırırsa, Internet izinleriyle birlikte kullanılabilir Assert ReflectionEmit .Therefore, in earlier versions of the .NET Framework.NET Framework a library can be used with Internet permissions only if it has the SecurityCriticalAttribute attribute and also executes an Assert for ReflectionEmit. Bu tür Kitaplıklar, kodlama hataları güvenlik delikleri ile sonuçlanabileceğinden dikkatli bir güvenlik incelemesi gerektirir.Such libraries require careful security review because coding errors could result in security holes. Kod .NET Framework 2,0 SP1.NET Framework 2.0 SP1 oluşturmak doğal olarak ayrıcalıklı bir işlem olmadığından kodun herhangi bir güvenlik talebi vermeden kısmi güven senaryolarında yayınlanmasının olanaklı olmasına izin verir.The .NET Framework 2,0 SP1.NET Framework 2.0 SP1 allows code to be emitted in partial trust scenarios without issuing any security demands, because generating code is not inherently a privileged operation. Diğer bir deyişle, oluşturulan kodun onu yayan derlemeden daha fazla izni yoktur.That is, the generated code has no more permissions than the assembly that emits it. Bu, kod veren kitaplıkların güvenlik açısından saydam olmasını sağlar ve ReflectionEmit güvenli bir kitaplık yazma görevini kolaylaştıran onay gereksinimini ortadan kaldırır.This allows libraries that emit code to be security transparent and removes the need to assert ReflectionEmit, which simplifies the task of writing a secure library. Bu özelliği kullanmak için uygulamanızın .NET Framework 3.5.NET Framework 3.5 veya sonraki bir sürümünü hedeflemesi gerekir.To use this feature, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Aşağıdaki tabloda, bir modülle veya bir modüldeki türle ilişkili olan dinamik bir yöntem için hangi türlerin ve üyelerin erişilebilir olduğu gösterilmektedir.The following table shows which types and members are accessible to a dynamic method that is associated with a module or with a type in a module.

Modülle ilişkiliAssociated with module Türle ilişkiliAssociated with type
JıT görünürlük denetimlerini atlamadanWithout skipping JIT visibility checks Modüldeki ortak, iç ve özel türlerin ortak ve iç üyeleri.Public and internal members of public, internal, and private types in the module.

Herhangi bir derlemede ortak türlerin ortak üyeleri.Public members of public types in any assembly.
İlişkili türün tüm üyeleri.All members of the associated type. Modüldeki diğer tüm türlerin ortak ve iç üyeleri.Public and internal members of all the other types in the module.

Herhangi bir derlemede ortak türlerin ortak üyeleri.Public members of public types in any assembly.
JıT görünürlük denetimleri atlanıyorSkipping JIT visibility checks Tüm derlemedeki tüm türlerin üyeleri.All members of all types in any assembly. Tüm derlemedeki tüm türlerin üyeleri.All members of all types in any assembly.

Bir modülle ilişkili dinamik bir yöntem bu modülün izinlerine sahiptir.A dynamic method that is associated with a module has the permissions of that module. Bir türle ilişkili dinamik bir yöntem, bu türü içeren modülün izinlerine sahiptir.A dynamic method that is associated with a type has the permissions of the module containing that type.

Dinamik yöntemlerin ve parametrelerinin adlandırılması gerekmez, ancak hata ayıklamada yardımcı olacak adlar belirtebilirsiniz.Dynamic methods and their parameters do not have to be named, but you can specify names to assist in debugging. Özel öznitelikler dinamik yöntemlerde veya parametrelerinde desteklenmez.Custom attributes are not supported on dynamic methods or their parameters.

Dinamik yöntemler static Yöntemler ( Shared Visual Basic içindeki Yöntemler) olsa da, bir dinamik yöntemin bir nesneye bağlanmasına izin ver ' de tanıtılan temsilci bağlama için gevşek kurallar, .NET Framework 2.0.NET Framework 2.0 Bu sayede, bu temsilci örneği kullanılarak çağrıldığında bir örnek yöntemi gibi davranır.Although dynamic methods are static methods (Shared methods in Visual Basic), the relaxed rules for delegate binding introduced in the .NET Framework 2.0.NET Framework 2.0 allow a dynamic method to be bound to an object, so that it acts like an instance method when called using that delegate instance. Yöntem aşırı yüklemesi için bunu gösteren bir örnek verilmiştir CreateDelegate(Type, Object) .An example that demonstrates this is provided for the CreateDelegate(Type, Object) method overload.

Not

' De, .NET Framework 2.0.NET Framework 2.0 dinamik yöntemler sembol bilgilerini, diğer bir deyişle, yerel değişken adlarını ve satır numarası eşlemeyi desteklemez.In the .NET Framework 2.0.NET Framework 2.0, dynamic methods do not support symbol information, that is, local variable names and line-number mapping. Bu sınırlama gelecekteki bir sürümde kaldırılabilir.This limitation might be removed in a future version. AssemblyBuilderGeliştirme sırasında, oluşturulan Microsoft ara dilini (MSIL) hata ayıklamayı basitleştirmek ve sonra son dağıtım sırasında dinamik yöntemlere geçiş yapmak için kullanabilirsiniz, çünkü ILGenerator çağrılar her iki durumda da aynıdır.You can use AssemblyBuilder during development to simplify debugging the generated Microsoft intermediate language (MSIL), and then switch to dynamic methods during final deployment, because the ILGenerator calls are the same in both cases.

DoğrulamaVerification

Aşağıdaki liste, hangi dinamik yöntemlerin doğrulanamayan kodu içerebileceği koşullarını özetler.The following list summarizes the conditions under which dynamic methods can contain unverifiable code. (Örneğin, özelliği olarak ayarlandıysa, dinamik bir yöntem doğrulanamaz olur InitLocals false .)(For example, a dynamic method is unverifiable if its InitLocals property is set to false.)

  • Güvenlik açısından kritik bir derlemeyle ilişkili dinamik bir yöntem de güvenlik açısından kritik 'tir ve doğrulamayı atlayabilir.A dynamic method that is associated with a security-critical assembly is also security-critical, and can skip verification. Örneğin, bir 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.For example, an assembly without security attributes that is run as a desktop application is treated as security-critical by the runtime. Dinamik bir yöntemi derlemeyle ilişkilendirirseniz, dinamik yöntem doğrulanamayan kod içerebilir.If you associate a dynamic method with the assembly, the dynamic method can contain unverifiable code.

  • Doğrulanamayan kodu içeren dinamik bir yöntem, düzey 1 saydamlığına sahip bir derlemeyle ilişkiliyse, tam zamanında (JıT) derleyici bir güvenlik talebi çıkarır.If a dynamic method that contains unverifiable code is associated with an assembly that has level 1 transparency, the just-in-time (JIT) compiler injects a security demand. Talep, yalnızca dinamik yöntem tamamen güvenilir kodla yürütüldüğünde başarılı olur.The demand succeeds only if the dynamic method is executed by fully trusted code. Bkz. güvenlik-saydam kodu, düzey 1.See Security-Transparent Code, Level 1.

  • Doğrulanamayan kodu içeren dinamik bir yöntem, düzey 2 saydamlığına sahip bir derleme ile ilişkili ise (örneğin, mscorlib.dll), güvenlik talebi yapmak yerine bir özel durum (JıT derleyicisi tarafından eklenen) oluşturur.If a dynamic method that contains unverifiable code is associated with an assembly that has level 2 transparency (such as mscorlib.dll), it throws an exception (injected by the JIT compiler) instead of making a security demand. Bkz. güvenlik-saydam kodu, düzey 2.See Security-Transparent Code, Level 2.

  • Doğrulanamayan kodu içeren anonim olarak barındırılan bir dinamik yöntem her zaman bir özel durum oluşturur.An anonymously hosted dynamic method that contains unverifiable code always throws an exception. Tam olarak güvenilen kod tarafından oluşturulup yürütülene bile doğrulamayı hiçbir şekilde atlayabilirler.It can never skip verification, even if it is created and executed by fully trusted code.

Doğrulanamayan kod için oluşturulan özel durum, dinamik yöntemin çağrıldığı yönteme bağlı olarak değişir.The exception that is thrown for unverifiable code varies depending on the way the dynamic method is invoked. Yönteminden döndürülen bir temsilciyi kullanarak dinamik bir yöntemi çağırırsanız CreateDelegate , bir oluşturulur VerificationException .If you invoke a dynamic method by using a delegate returned from the CreateDelegate method, a VerificationException is thrown. Yöntemini kullanarak dinamik yöntemi çağırırsanız Invoke , bir TargetInvocationException iç ile oluşturulur VerificationException .If you invoke the dynamic method by using the Invoke method, a TargetInvocationException is thrown with an inner VerificationException.

Oluşturucular

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)

Modül için genel olan, yöntem adı, öznitelikler, çağırma kuralı, dönüş türü, parametre türleri, modül ve dinamik metodun Microsoft ara dili (MSIL) tarafından erişilen türler ve Üyeler için tam zamanında (JıT) görünürlük denetimlerinin atlanıp atlanmayacağını belirten bir dinamik yöntem oluşturur.Creates a dynamic method that is global to a module, specifying the method name, attributes, calling convention, return type, parameter types, module, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)

Yöntem adı, öznitelikler, çağırma kuralı, dönüş türü, parametre türleri, dinamik yöntemin mantıksal olarak ilişkilendirildiği tür ve dinamik metodun Microsoft ara dili (MSIL) tarafından erişilen türler ve Üyeler için tam zamanında (JıT) görünürlük denetimlerinin atlanıp atlanmayacağını belirten bir dinamik yöntem oluşturur.Creates a dynamic method, specifying the method name, attributes, calling convention, return type, parameter types, the type with which the dynamic method is logically associated, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

DynamicMethod(String, Type, Type[])

Yöntem adı, dönüş türü ve parametre türlerini belirterek, anonim olarak barındırılan dinamik bir yöntemi başlatır.Initializes an anonymously hosted dynamic method, specifying the method name, return type, and parameter types.

DynamicMethod(String, Type, Type[], Boolean)

Anonim olarak barındırılan dinamik bir yöntemi başlatır; bu yöntem adı, dönüş türü, parametre türleri ve dinamik metodun Microsoft ara dili (MSIL) tarafından erişilen türler ve Üyeler için tam zamanında (JıT) görünürlük denetimlerinin atlanıp atlanmayacağını belirtir.Initializes an anonymously hosted dynamic method, specifying the method name, return type, parameter types, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

DynamicMethod(String, Type, Type[], Module)

Modül için genel olan, yöntem adını, dönüş türünü, parametre türlerini ve modülü belirten bir dinamik yöntem oluşturur.Creates a dynamic method that is global to a module, specifying the method name, return type, parameter types, and module.

DynamicMethod(String, Type, Type[], Module, Boolean)

Modül için genel olan, yöntem adını, dönüş türünü, parametre türlerini, modülü ve tam zamanında (JıT) görünürlük denetimlerinin, dinamik metodun Microsoft ara dili (MSIL) tarafından erişilen türler ve Üyeler için atlanıp atlanmayacağını belirten bir dinamik yöntem oluşturur.Creates a dynamic method that is global to a module, specifying the method name, return type, parameter types, module, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

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.Creates a dynamic method, specifying the method name, return type, parameter types, and the type with which the dynamic method is logically associated.

DynamicMethod(String, Type, Type[], Type, Boolean)

Yöntem adı, dönüş türü, parametre türleri, dinamik yöntemin mantıksal olarak ilişkilendirildiği tür ve dinamik metodun Microsoft ara dili (MSIL) tarafından erişilen türler ve Üyeler için tam zamanında (JıT) görünürlük denetimlerinin atlanıp atlanmayacağını belirten bir dinamik yöntem oluşturur.Creates a dynamic method, specifying the method name, return type, parameter types, the type with which the dynamic method is logically associated, and whether just-in-time (JIT) visibility checks should be skipped for types and members accessed by the Microsoft intermediate language (MSIL) of the dynamic method.

Özellikler

Attributes

Dinamik yöntem oluşturulduğunda belirtilen öznitelikleri alır.Gets the attributes specified when the dynamic method was created.

CallingConvention

Dinamik yöntem oluşturulduğunda belirtilen çağırma kuralını alır.Gets the calling convention specified when the dynamic method was created.

ContainsGenericParameters

Genel bir yöntemin atanmamış genel tür parametrelerini içerip içermediğini gösteren bir değer alır.Gets a value that indicates whether a generic method contains unassigned generic type parameters.

(Devralındığı yer: MethodInfo)
CustomAttributes

Bu üyenin özel özniteliklerini içeren bir koleksiyon alır.Gets a collection that contains this member's custom attributes.

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

Her zaman dinamik yöntemler için olan yöntemini bildiren türü alır null .Gets the type that declares the method, which is always null for dynamic methods.

InitLocals

Yöntemdeki yerel değişkenlerin sıfır olarak başlatılıp başlatılmayacağını gösteren bir değer alır veya ayarlar.Gets or sets a value indicating whether the local variables in the method are zero-initialized.

IsAbstract

Yöntemin soyut olup olmadığını gösteren bir değer alır.Gets a value indicating whether the method is abstract.

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

Bu yöntemin veya oluşturucunun potansiyel görünürlüğünü tarafından açıklanıp açıklanmadığını gösteren bir değer alır Assembly ; diğer bir deyişle, yöntem veya Oluşturucu aynı derlemede diğer türlerin en üstünde görünür ve derleme dışında türetilen türlere görünür değildir.Gets a value indicating whether the potential visibility of this method or constructor is described by Assembly; that is, the method or constructor is visible at most to other types in the same assembly, and is not visible to derived types outside the assembly.

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

Bu MemberInfo nesnenin toplanabilir olarak tutulan bir derlemenin parçası olup olmadığını gösteren bir değer alır AssemblyLoadContext .Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(Devralındığı yer: MemberInfo)
IsConstructedGenericMethod (Devralındığı yer: MethodBase)
IsConstructor

Yöntemin bir Oluşturucu olup olmadığını gösteren bir değer alır.Gets a value indicating whether the method is a constructor.

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

Bu yöntemin veya oluşturucunun görünürlüğünü tarafından açıklanıp açıklanmadığını gösteren bir değer alır Family ; diğer bir deyişle, yöntem veya Oluşturucu yalnızca kendi sınıfı ve türetilmiş sınıflar içinde görünür.Gets a value indicating whether the visibility of this method or constructor is described by Family; that is, the method or constructor is visible only within its class and derived classes.

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

Bu yöntemin veya oluşturucunun görünürlüğünü tarafından açıklanmadığını gösteren bir değer alır FamANDAssem ; diğer bir deyişle, yöntem veya Oluşturucu türetilmiş sınıflar tarafından çağrılabilir, ancak yalnızca aynı derlemede yer alıyorsa.Gets a value indicating whether the visibility of this method or constructor is described by FamANDAssem; that is, the method or constructor can be called by derived classes, but only if they are in the same assembly.

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

Bu yöntemin veya oluşturucunun potansiyel görünürlüğünü tarafından açıklanmadığını gösteren bir değer alır FamORAssem ; diğer bir deyişle, yöntem veya Oluşturucu, nerede olursa olsun ve aynı derlemede bulunan sınıflar tarafından çağrılabilir.Gets a value indicating whether the potential visibility of this method or constructor is described by FamORAssem; that is, the method or constructor can be called by derived classes wherever they are, and by classes in the same assembly.

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

Bu yöntemin olup olmadığını gösteren bir değer alır final .Gets a value indicating whether this method is final.

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

Geçerli yöntemin genel bir yöntem olup olmadığını gösteren bir değer alır.Gets a value indicating whether the current method is a generic method.

(Devralındığı yer: MethodInfo)
IsGenericMethodDefinition

Geçerli MethodInfo öğesinin genel yöntemin tanımını temsil ettiğini gösteren bir değer alır.Gets a value indicating whether the current MethodInfo represents the definition of a generic method.

(Devralındığı yer: MethodInfo)
IsHideBySig

Türetilmiş sınıfta yalnızca aynı imzaya sahip aynı türde bir üyenin gizli olup olmadığını gösteren bir değer alır.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

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

Bu üyenin özel olup olmadığını gösteren bir değer alır.Gets a value indicating whether this member is private.

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

Bu bir genel yöntem olup olmadığını gösteren bir değer alır.Gets a value indicating whether this is a public method.

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

Geçerli dinamik yöntemin güvenlik açısından kritik veya güvenlik açısından kritik olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemler gerçekleştirebilir.Gets a value that indicates whether the current dynamic method is security-critical or security-safe-critical, and therefore can perform critical operations.

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 kritik olup olmadığını belirten bir değer alır ve bu nedenle kritik işlemler gerçekleştirebilir.Gets a value that indicates whether the current method or constructor is security-critical or security-safe-critical at the current trust level, and therefore can perform critical operations.

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

Geçerli dinamik yöntemin geçerli güven düzeyinde güvenlik açısından kritik olup olmadığını belirten bir değer alır; diğer bir deyişle, kritik işlemler yapıp gerçekleştiremeyeceğini ve saydam kod tarafından erişilebilir.Gets a value that indicates whether the current dynamic method is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

IsSecuritySafeCritical

Geçerli yöntem veya oluşturucunun geçerli güven düzeyinde güvenlik açısından kritik olup olmadığını belirten bir değer alır; diğer bir deyişle, kritik işlemler yapıp gerçekleştiremeyeceğini ve saydam kod tarafından erişilebilir.Gets a value that indicates whether the current method or constructor is security-safe-critical at the current trust level; that is, whether it can perform critical operations and can be accessed by transparent code.

(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.Gets a value that indicates whether the current dynamic method is transparent at the current trust level, and therefore cannot perform critical operations.

IsSecurityTransparent

Geçerli yöntemin veya oluşturucunun geçerli güven düzeyinde saydam olup olmadığını gösteren bir değer alır ve bu nedenle kritik işlemler gerçekleştiremez.Gets a value that indicates whether the current method or constructor is transparent at the current trust level, and therefore cannot perform critical operations.

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

Bu yöntemin özel bir ada sahip olup olmadığını gösteren bir değer alır.Gets a value indicating whether this method has a special name.

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

Yöntemin olup olmadığını gösteren bir değer alır static .Gets a value indicating whether the method is static.

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

Yöntemin olup olmadığını gösteren bir değer alır virtual .Gets a value indicating whether the method is virtual.

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

MemberTypesBu üyenin bir yöntem olduğunu gösteren bir değer alır.Gets a MemberTypes value indicating that this member is a method.

(Devralındığı yer: MethodInfo)
MetadataToken

Meta veri öğesini tanımlayan bir değer alır.Gets a value that identifies a metadata element.

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

Dinamik yöntemlerle desteklenmez.Not supported for dynamic methods.

MethodHandle

Bir yöntemin iç meta veri gösterimine yönelik bir tanıtıcı alır.Gets a handle to the internal metadata representation of a method.

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

MethodImplAttributesBir yöntem uygulamasının özniteliklerini belirten bayrakları alır.Gets the MethodImplAttributes flags that specify the attributes of a method implementation.

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

Dinamik yöntemin mantıksal olarak ilişkilendirildiği modülü alır.Gets the module with which the dynamic method is logically associated.

Module

Geçerli tarafından temsil edilen üyeyi bildiren türün tanımlandığı modülü alır MemberInfo .Gets the module in which the type that declares the member represented by the current MemberInfo is defined.

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

Dinamik yöntemin adını alır.Gets the name of the dynamic method.

ReflectedType

Yöntemi almak için, yansıma içinde kullanılan sınıfı alır.Gets the class that was used in reflection to obtain the method.

ReflectedType

Bu örneği elde etmek için kullanılan sınıf nesnesini alır MemberInfo .Gets the class object that was used to obtain this instance of MemberInfo.

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

Dinamik metodun dönüş parametresini alır.Gets the return parameter of the dynamic method.

ReturnType

Dinamik yöntemin dönüş değeri türünü alır.Gets the type of return value for the dynamic method.

ReturnTypeCustomAttributes

Dinamik yöntem için dönüş türünün özel özniteliklerini alır.Gets the custom attributes of the return type for the dynamic method.

ReturnTypeCustomAttributes

Dönüş türünün özel özniteliklerini alır.Gets the custom attributes for the return type.

(Devralındığı yer: MethodInfo)

Yöntemler

CreateDelegate(Type)

Dinamik yöntemi tamamlar ve bunu yürütmek için kullanılabilecek bir temsilci oluşturur.Completes the dynamic method and creates a delegate that can be used to execute it.

CreateDelegate(Type, Object)

Dinamik yöntemi tamamlar ve temsilci türünü ve temsilcinin bağlandığı bir nesneyi belirterek onu yürütmek için kullanılabilecek bir temsilci oluşturur.Completes the dynamic method and creates a delegate that can be used to execute it, specifying the delegate type and an object the delegate is bound to.

CreateDelegate<T>()

Bu yöntemden türünde bir temsilci oluşturur T .Creates a delegate of type T from this method.

(Devralındığı yer: MethodInfo)
CreateDelegate<T>(Object)

TBu yöntemden belirtilen hedefle bir temsilci türü oluşturur.Creates a delegate of type T with the specified target from this method.

(Devralındığı yer: MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)

Dynamic yönteminin bir parametresini tanımlar.Defines a parameter of the dynamic method.

Equals(Object)

Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür.Returns a value that indicates whether this instance is equal to a specified object.

(Devralındığı yer: MethodInfo)
GetBaseDefinition()

Yöntemi için temel uygulamayı döndürür.Returns the base implementation for the method.

GetBaseDefinition()

Türetilmiş bir sınıfta geçersiz kılınırsa, MethodInfo Bu örnek tarafından temsil edilen yöntemin ilk olarak bildirildiği doğrudan veya dolaylı temel sınıftaki yöntemin nesnesini döndürür.When overridden in a derived class, returns the MethodInfo object for the method on the direct or indirect base class in which the method represented by this instance was first declared.

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

Yöntemi için tanımlanan tüm özel öznitelikleri döndürür.Returns all the custom attributes defined for the method.

GetCustomAttributes(Boolean)

Türetilmiş bir sınıfta geçersiz kılınırsa, bu üyeye uygulanan tüm özel özniteliklerin dizisini döndürür.When overridden in a derived class, returns an array of all custom attributes applied to this member.

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

Yönteme uygulanmış olan belirtilen türün özel özniteliklerini döndürür.Returns the custom attributes of the specified type that have been applied to the method.

GetCustomAttributes(Type, Boolean)

Türetilmiş bir sınıfta geçersiz kılınırsa, bu üyeye uygulanan ve tarafından tanımlanan özel özniteliklerin bir dizisini döndürür Type .When overridden in a derived class, returns an array of custom attributes applied to this member and identified by Type.

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

CustomAttributeDataHedef üyeye uygulanmış olan özniteliklerle ilgili verileri temsil eden nesnelerin listesini döndürür.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

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

DynamicILInfoMeta veri belirteçleri, kapsamları ve Microsoft ara dili (MSIL) akışlarından bir yöntem gövdesi oluşturmak için kullanılabilecek bir nesne döndürür.Returns a DynamicILInfo object that can be used to generate a method body from metadata tokens, scopes, and Microsoft intermediate language (MSIL) streams.

GetGenericArguments()

Bir Type genel metodun tür bağımsız değişkenlerini veya bir genel yöntem tanımının tür parametrelerini temsil eden nesne dizisini döndürür.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

(Devralındığı yer: MethodInfo)
GetGenericMethodDefinition()

MethodInfoGeçerli yöntemin üzerinde oluşturulabilecek genel yöntem tanımını temsil eden bir nesne döndürür.Returns a MethodInfo object that represents a generic method definition from which the current method can be constructed.

(Devralındığı yer: MethodInfo)
GetHashCode()

Bu örneğe ilişkin karma kodu döndürür.Returns the hash code for this instance.

(Devralındığı yer: MethodInfo)
GetILGenerator()

Varsayılan MSIL akış boyutu 64 bayt olan yöntem için bir Microsoft ara dili (MSIL) Oluşturucu döndürür.Returns a Microsoft intermediate language (MSIL) generator for the method with a default MSIL stream size of 64 bytes.

GetILGenerator(Int32)

Belirtilen MSIL akış boyutuyla yöntemi için bir Microsoft ara dili (MSIL) Oluşturucu döndürür.Returns a Microsoft intermediate language (MSIL) generator for the method with the specified MSIL stream size.

GetMethodBody()

Türetilmiş bir sınıfta geçersiz kılındığında, MethodBody geçerli yöntem IÇIN MSIL akışına, yerel değişkenlere ve özel durumlara erişim sağlayan bir nesne alır.When overridden in a derived class, gets a MethodBody object that provides access to the MSIL stream, local variables, and exceptions for the current method.

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

Yöntemi için uygulama bayraklarını döndürür.Returns the implementation flags for the method.

GetMethodImplementationFlags()

Türetilmiş bir sınıfta geçersiz kılınırsa, bayrakları döndürür MethodImplAttributes .When overridden in a derived class, returns the MethodImplAttributes flags.

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

Dinamik metodun parametrelerini döndürür.Returns the parameters of the dynamic method.

GetType()

Bir yöntemin özniteliklerini bulur ve yöntem meta verilerine erişim sağlar.Discovers the attributes of a method and provides access to method metadata.

(Devralındığı yer: MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo) (Devralındığı yer: MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Belirtilen kültür bilgileriyle belirtilen cildin kısıtlamaları altında belirtilen parametreleri kullanarak dinamik yöntemi çağırır.Invokes the dynamic method using the specified parameters, under the constraints of the specified binder, with the specified culture information.

Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

Türetilmiş bir sınıfta geçersiz kılınırsa, yansıtılan yöntemi veya oluşturucuyu verilen parametrelerle çağırır.When overridden in a derived class, invokes the reflected method or constructor with the given parameters.

(Devralındığı yer: MethodBase)
Invoke(Object, Object[])

Bu MethodInfo örneği tarafından yansıtılan yöntemi veya oluşturucuyu çağırır.Invokes the method or constructor reflected by this MethodInfo instance.

(Devralındığı yer: MethodInfo)
IsDefined(Type, Boolean)

Belirtilen özel öznitelik türünün tanımlanıp tanımlanmadığını gösterir.Indicates whether the specified custom attribute type is defined.

IsDefined(Type, Boolean)

Türetilmiş bir sınıfta geçersiz kılınırsa, belirtilen türdeki veya ondan türetilmiş türlerin bir veya daha fazla özniteliğinin Bu üyeye uygulanıp uygulanmadığını gösterir.When overridden in a derived class, indicates whether one or more attributes of the specified type or of its derived types is applied to this member.

(Devralındığı yer: MemberInfo)
MakeGenericMethod(Type[])

Geçerli genel yöntem tanımının tür parametreleri için bir tür dizisinin öğelerini değiştirir ve MethodInfo elde edilen oluşturulmuş yöntemi temsil eden bir nesne döndürür.Substitutes the elements of an array of types for the type parameters of the current generic method definition, and returns a MethodInfo object representing the resulting constructed method.

(Devralındığı yer: MethodInfo)
MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
ToString()

Bir dize olarak temsil edilen metodun imzasını döndürür.Returns the signature of the method, represented as a string.

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.Maps a set of names to a corresponding set of dispatch identifiers.

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

TypeSınıfını temsil eden bir nesne alır MemberInfo .Gets a Type object representing the MemberInfo class.

(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.Retrieves the type information for an object, which can then be used to get the type information for an interface.

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

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

(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.Maps a set of names to a corresponding set of dispatch identifiers.

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

Bu üyenin açıklaması için bkz GetType() ..For a description of this member, see 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.Retrieves the type information for an object, which can then be used to get the type information for an interface.

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

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

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

Bu üyenin açıklaması için bkz IsAbstract ..For a description of this member, see IsAbstract.

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

Bu üyenin açıklaması için bkz IsAssembly ..For a description of this member, see IsAssembly.

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

Bu üyenin açıklaması için bkz IsConstructor ..For a description of this member, see IsConstructor.

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

Bu üyenin açıklaması için bkz IsFamily ..For a description of this member, see IsFamily.

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

Bu üyenin açıklaması için bkz IsFamilyAndAssembly ..For a description of this member, see IsFamilyAndAssembly.

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

Bu üyenin açıklaması için bkz IsFamilyOrAssembly ..For a description of this member, see IsFamilyOrAssembly.

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

Bu üyenin açıklaması için bkz IsFinal ..For a description of this member, see IsFinal.

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

Bu üyenin açıklaması için bkz IsHideBySig ..For a description of this member, see IsHideBySig.

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

Bu üyenin açıklaması için bkz IsPrivate ..For a description of this member, see IsPrivate.

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

Bu üyenin açıklaması için bkz IsPublic ..For a description of this member, see IsPublic.

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

Bu üyenin açıklaması için bkz IsSpecialName ..For a description of this member, see IsSpecialName.

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

Bu üyenin açıklaması için bkz IsStatic ..For a description of this member, see IsStatic.

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

Bu üyenin açıklaması için bkz IsVirtual ..For a description of this member, see 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.Maps a set of names to a corresponding set of dispatch identifiers.

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

GetType()Com 'dan yönteme erişim sağlar.Provides access to the GetType() method from COM.

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

Bir arabirimin tür bilgilerini almak için kullanılabilen bir nesnenin tür bilgilerini alır.Retrieves the type information for an object, which can be used to get the type information for an interface.

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

Bir nesnenin sağladığı tür bilgisi arabirimlerinin sayısını alır (0 ya da 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

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

Bu üye üzerinde tanımlanan, adlandırılmış öznitelikler hariç veya özel öznitelik yoksa boş bir dizi olan tüm özel özniteliklerin dizisini döndürür.Returns an array of all of the custom attributes defined on this member, excluding named attributes, or an empty array if there are no custom attributes.

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

Bu üyede tanımlanmış, türe göre tanımlanan ve bir özel öznitelik yoksa boş bir dizi olan özel özniteliklerin dizisini döndürür.Returns an array of custom attributes defined on this member, identified by type, or an empty array if there are no custom attributes of that type.

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

Bu üyede bir veya daha fazla örneğinin attributeType tanımlanıp tanımlanmadığını gösterir.Indicates whether one or more instance of attributeType is defined on this member.

(Devralındığı yer: MemberInfo)

Uzantı Metotları

GetCustomAttribute(MemberInfo, Type)

Belirtilen bir üyeye uygulanan belirtilen türde özel bir özniteliği alır.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

Belirtilen bir üyeye uygulanan belirli bir türün özel özniteliğini alır ve isteğe bağlı olarak o üyenin üst öğelerini inceler.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttribute<T>(MemberInfo)

Belirtilen bir üyeye uygulanan belirtilen türde özel bir özniteliği alır.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

Belirtilen bir üyeye uygulanan belirli bir türün özel özniteliğini alır ve isteğe bağlı olarak o üyenin üst öğelerini inceler.Retrieves a custom attribute of a specified type that is applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo)

Belirtilen bir üyeye uygulanan özel özniteliklerin koleksiyonunu alır.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

Belirli bir üyeye uygulanan özel özniteliklerin bir koleksiyonunu alır ve isteğe bağlı olarak o üyenin üst öğelerini inceler.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

Belirtilen bir üyeye uygulanan belirli bir türün özel özniteliklerinin bir koleksiyonunu alır.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

Belirtilen bir üyeye uygulanan belirli bir türün özel özniteliklerinin bir koleksiyonunu alır ve isteğe bağlı olarak o üyenin üst öğelerini inceler.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes<T>(MemberInfo)

Belirtilen bir üyeye uygulanan belirli bir türün özel özniteliklerinin bir koleksiyonunu alır.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

Belirtilen bir üyeye uygulanan belirli bir türün özel özniteliklerinin bir koleksiyonunu alır ve isteğe bağlı olarak o üyenin üst öğelerini inceler.Retrieves a collection of custom attributes of a specified type that are applied to a specified member, and optionally inspects the ancestors of that member.

IsDefined(MemberInfo, Type)

Belirtilen bir üyeye belirli bir türün özel özniteliklerinin uygulanıp uygulanmadığını gösterir.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

Belirtilen bir türün özel özniteliklerinin belirtilen üyeye uygulanıp uygulanmadığını ve isteğe bağlı olarak, üst öğelerinden uygulanıp uygulanmayacağını gösterir.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

Varsa, belirtilen üye için bir meta veri belirteci alır.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

Belirtilen üye için bir meta veri belirtecinin kullanılabilir olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a metadata token is available for the specified member.

GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo)

Yöntemin ilk olarak bildirildiği doğrudan veya dolaylı temel sınıfta belirtilen yöntemi temsil eden bir nesne alır.Retrieves an object that represents the specified method on the direct or indirect base class where the method was first declared.

Şunlara uygulanır

Ayrıca bkz.