DynamicMethod 클래스

정의

컴파일, 실행, 삭제 가능한 동적 메서드를 정의하고 나타냅니다.Defines and represents a dynamic method that can be compiled, executed, and discarded. 삭제된 메서드는 가비지 수집에 사용할 수 있습니다.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
상속
특성

예제

다음 코드 예제에서는 두 개의 매개 변수를 사용 하는 동적 메서드를 만듭니다.The following code example creates a dynamic method that takes two parameters. 이 예제에서는 첫 번째 매개 변수를 콘솔에 출력 하는 간단한 함수 본문을 내보내고 예제에서는 두 번째 매개 변수를 메서드의 반환 값으로 사용 합니다.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. 이 예제에서는 대리자를 만들고, 다른 매개 변수를 사용 하 여 대리자를 호출 하 고, 마지막으로 메서드를 사용 하 여 동적 메서드를 호출 하 여 메서드를 완료 합니다 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

설명

클래스를 사용 하 여 DynamicMethod 동적 어셈블리를 생성 하 고 메서드를 포함 하는 동적 형식을 생성 하지 않고도 런타임에 메서드를 생성 하 고 실행할 수 있습니다.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. JIT (just-in-time) 컴파일러에서 만든 실행 코드는 개체가 회수 될 때 회수 됩니다 DynamicMethod .The executable code created by the just-in-time (JIT) compiler is reclaimed when the DynamicMethod object is reclaimed. 동적 메서드는 작은 양의 코드를 생성 하 고 실행 하는 가장 효율적인 방법입니다.Dynamic methods are the most efficient way to generate and execute small amounts of code.

동적 메서드는 익명으로 호스팅될 수 있으며, 모듈 또는 형식과 논리적으로 연결 될 수도 있습니다.A dynamic method can be anonymously hosted, or it can be logically associated with a module or with a type.

  • 동적 메서드가 익명으로 호스트 되는 경우에는 시스템에서 제공 하는 어셈블리에 위치 하므로 다른 코드와 격리 됩니다.If the dynamic method is anonymously hosted, it is located in a system-provided assembly, and therefore is isolated from other code. 기본적으로 public이 아닌 데이터에는 액세스할 수 없습니다.By default, it does not have access to any non-public data. 익명으로 호스트 된 동적 메서드는 플래그가 부여 된 경우 JIT 컴파일러의 가시성 검사를 건너뛰는 기능을 제한할 수 있습니다 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. 동적 메서드에서 public이 아닌 멤버에 액세스 하는 어셈블리의 신뢰 수준은 동적 메서드를 내보내는 호출 스택의 신뢰 수준과 같거나 그 하위 집합 이어야 합니다.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. 익명으로 호스트 되는 동적 메서드에 대 한 자세한 내용은 연습: 부분 신뢰 시나리오에서 코드 내보내기를 참조 하세요.For more information about anonymously hosted dynamic methods, see Walkthrough: Emitting Code in Partial Trust Scenarios.

  • 동적 메서드가 지정 하는 모듈과 연결 된 경우 동적 메서드는 해당 모듈에 대해 전역적으로 전역적입니다.If the dynamic method is associated with a module that you specify, the dynamic method is effectively global to that module. 이 클래스는 모듈의 모든 형식과 internal 해당 형식의 모든 ( Friend Visual Basic) 멤버에 액세스할 수 있습니다.It can access all types in the module and all internal (Friend in Visual Basic) members of the types. ReflectionPermission RestrictedMemberAccess 코드를 포함 하는 호출 스택에서 플래그를 사용 하 여에 대 한 수요를 만족할 수 있는 경우 모듈을 만들었는지 여부와 관계 없이 모든 모듈에 동적 메서드를 연결할 수 있습니다.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.MemberAccess플래그가 grant에 포함 된 경우 동적 메서드는 JIT 컴파일러의 가시성 검사를 건너뛰고 모듈 또는 모든 어셈블리의 다른 모듈에 선언 된 모든 형식의 전용 데이터에 액세스할 수 있습니다.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.

    참고

    동적 메서드를 연결 하는 데 사용 되는 모듈을 지정 하는 경우 해당 모듈은 익명 호스팅에 사용 되는 시스템 제공 어셈블리에 포함 되지 않아야 합니다.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.

  • 지정한 형식과 연결 된 동적 메서드는 액세스 수준에 관계 없이 해당 형식의 모든 멤버에 액세스할 수 있습니다.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. 또한 JIT 가시성 검사를 건너뛸 수 있습니다.In addition, JIT visibility checks can be skipped. 이렇게 하면 동적 메서드가 동일한 모듈 또는 모든 어셈블리의 다른 모듈에 선언 된 다른 형식의 전용 데이터에 액세스할 수 있습니다.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. 모든 형식에 동적 메서드를 연결할 수 있지만 코드에 및 플래그를 모두 부여 해야 합니다 ReflectionPermission RestrictedMemberAccess MemberAccess .You can associate a dynamic method with any type, but your code must be granted ReflectionPermission with both the RestrictedMemberAccess and MemberAccess flags.

다음 표에서는 플래그가 있는를 사용 하는지 여부에 따라 JIT 가시성 검사를 사용 하거나 사용 하지 않고 익명으로 호스트 된 동적 메서드에서 액세스할 수 있는 형식 및 멤버를 보여 줍니다 ReflectionPermission 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.

RestrictedMemberAccess 사용 안 함Without RestrictedMemberAccess RestrictedMemberAccess 사용With RestrictedMemberAccess
JIT 가시성 검사를 건너뛰지 않습니다.Without skipping JIT visibility checks 모든 어셈블리에서 public 형식의 public 멤버Public members of public types in any assembly. 모든 어셈블리에서 public 형식의 public 멤버Public members of public types in any assembly.
제한 사항으로 JIT 가시성 검사를 건너뜁니다.Skipping JIT visibility checks, with restrictions 모든 어셈블리에서 public 형식의 public 멤버Public members of public types in any assembly. 모든 형식의 모든 멤버 (신뢰 수준이 동적 메서드를 내보내는 어셈블리의 신뢰 수준 보다 작거나 같은 어셈블리에만 해당)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.

참고

.NET Framework 2.0 서비스 팩 1 이전에는 플래그와 함께 필요한 코드를 내보낼 수 ReflectionPermission ReflectionPermissionFlag.ReflectionEmit 있습니다.Prior to the .NET Framework 2.0 Service Pack 1, emitting code required ReflectionPermission with the ReflectionPermissionFlag.ReflectionEmit flag. 이 권한은 기본적으로 FullTrust 및 LocalIntranet 명명 된 권한 집합에 포함 되지만 인터넷 권한 집합에는 포함 되지 않습니다.This permission is included by default in the FullTrust and LocalIntranet named permission sets, but not in the Internet permission set. 따라서 이전 버전의 .NET Framework에서는 특성이 있고에 대해를 실행 하는 경우에만 인터넷 권한으로 라이브러리를 사용할 수 있습니다 SecurityCriticalAttribute Assert ReflectionEmit .Therefore, in earlier versions of the .NET Framework a library can be used with Internet permissions only if it has the SecurityCriticalAttribute attribute and also executes an Assert for ReflectionEmit. 코딩 오류가 있을 경우 보안 허점이 발생할 수 있으므로 이러한 라이브러리는 신중한 보안 검토가 필요합니다.Such libraries require careful security review because coding errors could result in security holes. .NET Framework 2.0 SP1에서는 코드 생성이 기본적으로 권한 있는 작업이 아니기 때문에 보안 요구를 실행하지 않고 부분 신뢰 시나리오에서 코드를 내보낼 수 있습니다.The .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. 즉, 생성된 코드에 코드를 내보내는 어셈블리보다 많은 권한이 없습니다.That is, the generated code has no more permissions than the assembly that emits it. 따라서 코드를 내보내는 라이브러리가 보안상 투명할 수 있으며 ReflectionEmit를 어설션할 필요가 없으므로 보안 라이브러리 작성 작업이 간소화됩니다.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. 이 기능을 사용 하려면 응용 프로그램이 .NET Framework 3.5 이상을 대상으로 해야 합니다.To use this feature, your application should target the .NET Framework 3.5 or later.

다음 표에서는 모듈에 연결 된 동적 메서드나 모듈의 형식에 액세스할 수 있는 형식 및 멤버를 보여 줍니다.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.

모듈에 연결Associated with module 형식과 연결Associated with type
JIT 가시성 검사를 건너뛰지 않습니다.Without skipping JIT visibility checks 모듈에 있는 public, internal 및 private 형식의 공용 및 내부 멤버입니다.Public and internal members of public, internal, and private types in the module.

모든 어셈블리에서 public 형식의 public 멤버Public members of public types in any assembly.
연결 된 형식의 모든 멤버입니다.All members of the associated type. 모듈에 있는 다른 모든 형식의 공용 및 내부 멤버입니다.Public and internal members of all the other types in the module.

모든 어셈블리에서 public 형식의 public 멤버Public members of public types in any assembly.
JIT 가시성 검사를 건너뜁니다.Skipping JIT visibility checks 모든 어셈블리에 있는 모든 형식의 모든 멤버입니다.All members of all types in any assembly. 모든 어셈블리에 있는 모든 형식의 모든 멤버입니다.All members of all types in any assembly.

모듈과 연결 된 동적 메서드에는 해당 모듈의 권한이 있습니다.A dynamic method that is associated with a module has the permissions of that module. 형식과 연결 된 동적 메서드에는 해당 형식을 포함 하는 모듈의 권한이 있습니다.A dynamic method that is associated with a type has the permissions of the module containing that type.

동적 메서드와 해당 매개 변수는 이름을 지정할 필요가 없지만 디버깅에 도움이 되는 이름을 지정할 수 있습니다.Dynamic methods and their parameters do not have to be named, but you can specify names to assist in debugging. 사용자 지정 특성은 동적 메서드나 해당 매개 변수에서 지원 되지 않습니다.Custom attributes are not supported on dynamic methods or their parameters.

동적 메서드는 static 메서드 ( Shared Visual Basic의 메서드) 이지만 .NET Framework 2.0에 도입 된 대리자 바인딩에 대해 완화 된 규칙을 사용 하면 동적 메서드가 개체에 바인딩될 수 있으므로 해당 대리자 인스턴스를 사용 하 여 호출 될 때 인스턴스 메서드 처럼 작동 합니다.Although dynamic methods are static methods (Shared methods in Visual Basic), the relaxed rules for delegate binding introduced in the .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. 이를 보여 주는 예제는 메서드 오버 로드에 대해 제공 됩니다 CreateDelegate(Type, Object) .An example that demonstrates this is provided for the CreateDelegate(Type, Object) method overload.

참고

.NET Framework 2.0에서 동적 메서드는 기호 정보, 즉 지역 변수 이름과 줄 번호 매핑을 지원 하지 않습니다.In the .NET Framework 2.0, dynamic methods do not support symbol information, that is, local variable names and line-number mapping. 이 제한은 이후 버전에서 제거 될 수 있습니다.This limitation might be removed in a future version. 개발 중에를 사용 하 여 AssemblyBuilder 생성 된 MSIL (Microsoft 중간 언어)의 디버깅을 간소화 하 고, ILGenerator 두 경우 모두 호출이 동일 하기 때문에 최종 배포 중에 동적 메서드로 전환할 수 있습니다.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.

확인Verification

다음 목록에서는 동적 메서드가 확인할 수 없는 코드를 포함할 수 있는 조건을 요약 하 여 보여 줍니다.The following list summarizes the conditions under which dynamic methods can contain unverifiable code. 예를 들어 해당 InitLocals 속성이로 설정 되어 있으면 동적 메서드를 확인할 수 없습니다 false .(For example, a dynamic method is unverifiable if its InitLocals property is set to false.)

  • 보안에 중요 한 어셈블리와 연결 된 동적 메서드는 보안에도 중요 하며 확인을 건너뛸 수 있습니다.A dynamic method that is associated with a security-critical assembly is also security-critical, and can skip verification. 예를 들어, 데스크톱 애플리케이션으로 실행 되는 보안 특성 없이 어셈블리는 런타임에서 보안에 중요로 처리 됩니다.For example, an assembly without security attributes that is run as a desktop application is treated as security-critical by the runtime. 동적 메서드를 어셈블리와 연결 하는 경우 동적 메서드에 확인할 수 없는 코드가 포함 될 수 있습니다.If you associate a dynamic method with the assembly, the dynamic method can contain unverifiable code.

  • 확인할 수 없는 코드가 포함 된 동적 메서드가 수준 1 투명도를 포함 하는 어셈블리와 연결 되어 있으면 JIT (just-in-time) 컴파일러에서 보안 요구 사항을 삽입 합니다.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. 완전히 신뢰할 수 있는 코드에서 동적 메서드를 실행 하는 경우에만 요청이 성공 합니다.The demand succeeds only if the dynamic method is executed by fully trusted code. 보안 투명 코드, 수준 1을참조 하세요.See Security-Transparent Code, Level 1.

  • 확인할 수 없는 코드가 포함 된 동적 메서드가 수준 2 투명도 (예: mscorlib.dll)를 포함 하는 어셈블리와 연결 된 경우 보안 요구를 수행 하는 대신 예외를 throw 합니다 (JIT 컴파일러에서 삽입).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. 보안 투명 코드, 수준 2를참조 하세요.See Security-Transparent Code, Level 2.

  • 비안정형 코드를 포함 하는 익명으로 호스트 된 동적 메서드는 항상 예외를 throw 합니다.An anonymously hosted dynamic method that contains unverifiable code always throws an exception. 완전히 신뢰할 수 있는 코드에 의해 생성 되 고 실행 되는 경우에도 확인을 건너뛸 수 없습니다.It can never skip verification, even if it is created and executed by fully trusted code.

비안정형 코드에 대해 throw 되는 예외는 동적 메서드가 호출 되는 방식에 따라 달라 집니다.The exception that is thrown for unverifiable code varies depending on the way the dynamic method is invoked. 메서드에서 반환 된 대리자를 사용 하 여 동적 메서드를 호출 하면 CreateDelegate VerificationException 이 throw 됩니다.If you invoke a dynamic method by using a delegate returned from the CreateDelegate method, a VerificationException is thrown. 메서드를 사용 하 여 동적 메서드를 호출 하는 경우 Invoke TargetInvocationException 내부와 함께이 throw 됩니다 VerificationException .If you invoke the dynamic method by using the Invoke method, a TargetInvocationException is thrown with an inner VerificationException.

생성자

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

모듈 전체에 적용되는 동적 메서드를 만들어 메서드 이름, 특성, 호출 규칙, 반환 형식, 매개 변수 형식, 모듈을 지정하고, 동적 메서드의 MSIL(Microsoft Intermediate Language)이 액세스하는 형식과 멤버에 대해 JIT(just-in-time) 표시 유형 확인을 건너뛸지 여부를 지정합니다.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)

동적 메서드를 만들고, 메서드 이름, 특성, 호출 규칙, 반환 형식, 매개 변수 형식, 동적 메서드가 논리적으로 연결되는 형식, 동적 메서드의 MSIL(Microsoft Intermediate Language)이 액세스하는 형식과 멤버에 대해 JIT(just-in-time) 표시 유형 확인을 건너뛸지 여부를 지정합니다.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[])

메서드 이름, 반환 형식 및 매개 변수 형식을 지정하여 익명으로 호스트되는 동적 메서드를 초기화합니다.Initializes an anonymously hosted dynamic method, specifying the method name, return type, and parameter types.

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

메서드 이름, 반환 형식, 매개 변수 형식, 그리고 동적 메서드의 MSIL(Microsoft Intermediate Language)에서 액세스하는 형식 및 멤버에 대해 JIT(적시) 가시성 검사를 건너뛰어야 하는지 여부를 지정하는 익명으로 호스팅된 동적 메서드를 초기화합니다.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)

메서드 이름, 반환 형식, 매개 변수 형식 및 모듈을 지정하여 모듈 전체에서 사용되는 동적 메서드를 만듭니다.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)

모듈 전체에 적용되는 동적 메서드를 만들어 메서드 이름, 반환 형식, 매개 변수 형식, 모듈을 지정하고, 동적 메서드의 MSIL(Microsoft Intermediate Language)이 액세스하는 형식과 멤버에 대해 JIT(just-in-time) 표시 유형 확인을 건너뛸지 여부를 지정합니다.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)

메서드 이름, 반환 형식, 매개 변수 형식 및 동적 메서드가 논리적으로 연결된 형식을 지정하여 동적 메서드를 만듭니다.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)

동적 메서드를 만들고, 메서드 이름, 반환 형식, 매개 변수 형식, 동적 메서드가 논리적으로 연결되는 형식, 동적 메서드의 MSIL(Microsoft Intermediate Language)이 액세스하는 형식과 멤버에 대해 JIT(just-in-time) 표시 유형 확인을 건너뛸지 여부를 지정합니다.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.

속성

Attributes

동적 메서드를 만들 때 지정된 특성을 가져옵니다.Gets the attributes specified when the dynamic method was created.

CallingConvention

동적 메서드를 만들 때 지정된 호출 규칙을 가져옵니다.Gets the calling convention specified when the dynamic method was created.

ContainsGenericParameters

제네릭 메서드에 할당되지 않은 제네릭 형식 매개 변수가 포함되어 있는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether a generic method contains unassigned generic type parameters.

(다음에서 상속됨 MethodInfo)
CustomAttributes

이 멤버의 사용자 지정 특성을 포함하는 컬렉션을 가져옵니다.Gets a collection that contains this member's custom attributes.

(다음에서 상속됨 MemberInfo)
DeclaringType

동적 메서드에 대해 항상 null 인 메서드를 선언하는 형식을 가져옵니다.Gets the type that declares the method, which is always null for dynamic methods.

InitLocals

메서드의 로컬 변수가 0으로 초기화되었는지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value indicating whether the local variables in the method are zero-initialized.

IsAbstract

이 메서드가 추상 메서드인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is abstract.

(다음에서 상속됨 MethodBase)
IsAssembly

Assembly에서 이 메서드나 생성자의 잠재적 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 같은 어셈블리의 다른 형식에만 표시되고 어셈블리 외부의 파생 형식에는 표시되지 않습니다.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.

(다음에서 상속됨 MethodBase)
IsCollectible

MemberInfo 개체가 수집 가능한 AssemblyLoadContext에 보관된 어셈블리의 일부인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

(다음에서 상속됨 MemberInfo)
IsConstructedGenericMethod (다음에서 상속됨 MethodBase)
IsConstructor

메서드가 생성자인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is a constructor.

(다음에서 상속됨 MethodBase)
IsFamily

Family에서 이 메서드나 생성자의 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 해당 클래스 및 파생 클래스에만 표시됩니다.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.

(다음에서 상속됨 MethodBase)
IsFamilyAndAssembly

FamANDAssem에서 이 메서드나 생성자의 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 같은 어셈블리에 있는 경우에만 파생 클래스에서 호출할 수 있습니다.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.

(다음에서 상속됨 MethodBase)
IsFamilyOrAssembly

FamORAssem에서 이 메서드나 생성자의 잠재적 표시 유형을 설명하는지 여부를 나타내는 값을 가져옵니다. 즉, 이 메서드나 생성자는 파생 클래스(있는 경우) 및 같은 어셈블리의 클래스에서 호출할 수 있습니다.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.

(다음에서 상속됨 MethodBase)
IsFinal

이 메서드가 final인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether this method is final.

(다음에서 상속됨 MethodBase)
IsGenericMethod

현재 메서드가 제네릭 메서드인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the current method is a generic method.

(다음에서 상속됨 MethodInfo)
IsGenericMethodDefinition

현재 MethodInfo가 제네릭 메서드 정의를 나타내는지 여부를 표시하는 값을 가져옵니다.Gets a value indicating whether the current MethodInfo represents the definition of a generic method.

(다음에서 상속됨 MethodInfo)
IsHideBySig

동일한 시그니처가 있는 동일한 종류의 멤버만을 파생 클래스에서 숨길 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(다음에서 상속됨 MethodBase)
IsPrivate

이 멤버가 프라이빗인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether this member is private.

(다음에서 상속됨 MethodBase)
IsPublic

이 메서드가 public 메서드인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether this is a public method.

(다음에서 상속됨 MethodBase)
IsSecurityCritical

현재 동적 메서드가 보안에 중요한 형식이거나 보안 안전에 중요한 형식이어서 중요한 작업을 수행할 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the current dynamic method is security-critical or security-safe-critical, and therefore can perform critical operations.

IsSecurityCritical

현재 메서드나 생성자가 현재 신뢰 수준에서 보안에 중요한 형식이거나 보안 안전에 중요한 형식이어서 중요한 작업을 수행할 수 있는지 여부를 나타내는 값을 가져옵니다.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.

(다음에서 상속됨 MethodBase)
IsSecuritySafeCritical

현재 동적 메서드가 현재 신뢰 수준에서 보안 안전에 중요한 형식인지, 즉 중요한 작업을 수행할 수 있고 투명 코드로 액세스할 수 있는지 여부를 나타내는 값을 가져옵니다.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

현재 메서드나 생성자가 현재 신뢰 수준에서 보안 안전에 중요한 형식인지 즉, 중요한 작업을 수행할 수 있고 투명 코드로 액세스할 수 있는지 여부를 나타내는 값을 가져옵니다.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.

(다음에서 상속됨 MethodBase)
IsSecurityTransparent

현재 동적 메서드가 현재 신뢰 수준에서 투명하여 중요한 작업을 수행할 수 없는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the current dynamic method is transparent at the current trust level, and therefore cannot perform critical operations.

IsSecurityTransparent

현재 메서드나 생성자가 현재 신뢰 수준에서 투명하여 중요한 작업을 수행할 수 없는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the current method or constructor is transparent at the current trust level, and therefore cannot perform critical operations.

(다음에서 상속됨 MethodBase)
IsSpecialName

이 메서드의 이름이 특수한지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether this method has a special name.

(다음에서 상속됨 MethodBase)
IsStatic

메서드가 static인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is static.

(다음에서 상속됨 MethodBase)
IsVirtual

메서드가 virtual인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the method is virtual.

(다음에서 상속됨 MethodBase)
MemberType

이 멤버가 메서드임을 나타내는 MemberTypes 값을 가져옵니다.Gets a MemberTypes value indicating that this member is a method.

(다음에서 상속됨 MethodInfo)
MetadataToken

메타데이터 요소를 식별하는 값을 가져옵니다.Gets a value that identifies a metadata element.

(다음에서 상속됨 MemberInfo)
MethodHandle

동적 메서드에는 지원되지 않습니다.Not supported for dynamic methods.

MethodHandle

메서드의 내부 메타데이터 표현에 대한 핸들을 가져옵니다.Gets a handle to the internal metadata representation of a method.

(다음에서 상속됨 MethodBase)
MethodImplementationFlags
MethodImplementationFlags

메서드 구현의 특성을 지정하는 MethodImplAttributes 플래그를 가져옵니다.Gets the MethodImplAttributes flags that specify the attributes of a method implementation.

(다음에서 상속됨 MethodBase)
Module

동적 메서드가 논리적으로 연결된 모듈을 가져옵니다.Gets the module with which the dynamic method is logically associated.

Module

현재 MemberInfo가 나타내는 멤버를 선언하는 형식이 정의된 모듈을 가져옵니다.Gets the module in which the type that declares the member represented by the current MemberInfo is defined.

(다음에서 상속됨 MemberInfo)
Name

동적 메서드의 이름입니다.Gets the name of the dynamic method.

ReflectedType

메서드를 얻기 위해 리플렉션에서 사용된 클래스를 가져옵니다.Gets the class that was used in reflection to obtain the method.

ReflectedType

MemberInfo의 이 인스턴스를 가져오는 데 사용된 클래스 개체를 가져옵니다.Gets the class object that was used to obtain this instance of MemberInfo.

(다음에서 상속됨 MemberInfo)
ReturnParameter

동적 메서드의 반환 매개 변수를 가져옵니다.Gets the return parameter of the dynamic method.

ReturnType

동적 메서드의 반환 값 형식을 가져옵니다.Gets the type of return value for the dynamic method.

ReturnTypeCustomAttributes

동적 메서드에 대한 반환 형식의 사용자 지정 특성을 가져옵니다.Gets the custom attributes of the return type for the dynamic method.

ReturnTypeCustomAttributes

반환 형식에 대한 사용자 지정 특성을 가져옵니다.Gets the custom attributes for the return type.

(다음에서 상속됨 MethodInfo)

메서드

CreateDelegate(Type)

동적 메서드를 완료하고 실행하는 데 사용할 수 있는 대리자를 만듭니다.Completes the dynamic method and creates a delegate that can be used to execute it.

CreateDelegate(Type, Object)

동적 메서드를 완료하고 대리자 형식과 대리자가 바인딩되는 개체를 지정하여 해당 메서드를 실행하는 데 사용할 수 있는 대리자를 만듭니다.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>()

이 메서드에서 T 형식의 대리자를 만듭니다.Creates a delegate of type T from this method.

(다음에서 상속됨 MethodInfo)
CreateDelegate<T>(Object)

이 메서드에서 지정된 대상을 사용하여 T 형식의 대리자를 만듭니다.Creates a delegate of type T with the specified target from this method.

(다음에서 상속됨 MethodInfo)
DefineParameter(Int32, ParameterAttributes, String)

동적 메서드의 매개 변수를 정의합니다.Defines a parameter of the dynamic method.

Equals(Object)

이 인스턴스가 지정된 개체와 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether this instance is equal to a specified object.

(다음에서 상속됨 MethodInfo)
GetBaseDefinition()

메서드에 대한 기본 구현을 반환합니다.Returns the base implementation for the method.

GetBaseDefinition()

파생 클래스에서 재정의되는 경우 이 인스턴스가 나타내는 메서드가 처음 선언된 직접 또는 간접 기본 클래스의 메서드에 대해 MethodInfo 개체를 반환합니다.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.

(다음에서 상속됨 MethodInfo)
GetCustomAttributes(Boolean)

이 메서드에 대해 정의된 모든 사용자 지정 특성을 반환합니다.Returns all the custom attributes defined for the method.

GetCustomAttributes(Boolean)

파생 클래스에서 재정의되는 경우 이 멤버에 적용된 모든 사용자 지정 특성의 배열을 반환합니다.When overridden in a derived class, returns an array of all custom attributes applied to this member.

(다음에서 상속됨 MemberInfo)
GetCustomAttributes(Type, Boolean)

메서드에 적용된 지정된 형식의 사용자 지정 특성을 반환합니다.Returns the custom attributes of the specified type that have been applied to the method.

GetCustomAttributes(Type, Boolean)

파생된 클래스에서 재정의하는 경우 이 멤버에 적용되고 Type으로 식별되는 사용자 지정 특성의 배열을 반환합니다.When overridden in a derived class, returns an array of custom attributes applied to this member and identified by Type.

(다음에서 상속됨 MemberInfo)
GetCustomAttributesData()

대상 멤버에 적용된 특성에 대한 데이터를 나타내는 CustomAttributeData 개체의 목록을 반환합니다.Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(다음에서 상속됨 MemberInfo)
GetDynamicILInfo()

메타데이터 토큰, 범위 및 MSIL(Microsoft Intermediate Language) 스트림에서 메서드 본문을 생성하는 데 사용할 수 있는 DynamicILInfo 개체입니다.Returns a DynamicILInfo object that can be used to generate a method body from metadata tokens, scopes, and Microsoft intermediate language (MSIL) streams.

GetGenericArguments()

제네릭 메서드의 형식 인수나 제네릭 메서드 정의의 형식 매개 변수를 나타내는 Type 개체의 배열을 반환합니다.Returns an array of Type objects that represent the type arguments of a generic method or the type parameters of a generic method definition.

(다음에서 상속됨 MethodInfo)
GetGenericMethodDefinition()

현재 메서드를 생성하는 데 사용할 수 있는 제네릭 메서드 정의를 나타내는 MethodInfo 개체를 반환합니다.Returns a MethodInfo object that represents a generic method definition from which the current method can be constructed.

(다음에서 상속됨 MethodInfo)
GetHashCode()

이 인스턴스의 해시 코드를 반환합니다.Returns the hash code for this instance.

(다음에서 상속됨 MethodInfo)
GetILGenerator()

64바이트의 기본 MSIL(Microsoft Intermediate Language) 스트림 크기를 사용하는 메서드에 대한 MSIL 생성기를 반환합니다.Returns a Microsoft intermediate language (MSIL) generator for the method with a default MSIL stream size of 64 bytes.

GetILGenerator(Int32)

지정된 된 MSIL 스트림 크기를 사용하는 메서드에 대한 MSIL(Microsoft Intermediate Language) 생성기를 반환합니다.Returns a Microsoft intermediate language (MSIL) generator for the method with the specified MSIL stream size.

GetMethodBody()

파생 클래스에서 재정의된 경우, 현재 메서드의 MSIL 스트림, 지역 변수 및 예외에 액세스할 수 있도록 하는 MethodBody 개체를 가져옵니다.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.

(다음에서 상속됨 MethodBase)
GetMethodImplementationFlags()

메서드에 대한 구현 플래그를 반환합니다.Returns the implementation flags for the method.

GetMethodImplementationFlags()

파생 클래스에서 재정의할 때 MethodImplAttributes 플래그를 반환합니다.When overridden in a derived class, returns the MethodImplAttributes flags.

(다음에서 상속됨 MethodBase)
GetParameters()

동적 메서드의 매개 변수를 반환합니다.Returns the parameters of the dynamic method.

GetType()

메서드의 특성을 검색하고 메서드 메타데이터에 대한 액세스를 제공합니다.Discovers the attributes of a method and provides access to method metadata.

(다음에서 상속됨 MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo) (다음에서 상속됨 MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

지정된 문화권 정보를 사용하고 지정된 바인더의 제약 조건에 따라, 지정된 매개 변수를 사용하여 동적 메서드를 호출합니다.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)

파생 클래스에서 재정의된 경우, 지정된 매개 변수를 사용하여 리플렉션된 메서드나 생성자를 호출합니다.When overridden in a derived class, invokes the reflected method or constructor with the given parameters.

(다음에서 상속됨 MethodBase)
Invoke(Object, Object[])

이 MethodInfo 인스턴스에 의해 리플렉션된 메서드나 생성자를 호출합니다.Invokes the method or constructor reflected by this MethodInfo instance.

(다음에서 상속됨 MethodInfo)
IsDefined(Type, Boolean)

지정된 사용자 지정 특성 유형이 정의되었는지 여부를 나타냅니다.Indicates whether the specified custom attribute type is defined.

IsDefined(Type, Boolean)

파생 클래스에서 재정의되는 경우 지정된 형식 또는 파생 형식의 특성이 하나 이상 이 멤버에 적용되는지 여부를 나타냅니다.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.

(다음에서 상속됨 MemberInfo)
MakeGenericMethod(Type[])

현재 제네릭 메서드 정의의 형식 매개 변수를 형식 배열의 요소로 대체하고, 결과로 생성된 메서드를 나타내는 MethodInfo 개체를 반환합니다.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.

(다음에서 상속됨 MethodInfo)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
ToString()

문자열로 표현된 메서드의 서명을 반환합니다.Returns the signature of the method, represented as a string.

명시적 인터페이스 구현

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

이름 집합을 해당하는 디스패치 식별자 집합에 매핑합니다.Maps a set of names to a corresponding set of dispatch identifiers.

(다음에서 상속됨 MemberInfo)
_MemberInfo.GetType()

Type 클래스를 나타내는 MemberInfo 개체를 가져옵니다.Gets a Type object representing the MemberInfo class.

(다음에서 상속됨 MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

인터페이스의 형식 정보를 가져오는 데 사용할 수 있는 개체의 형식 정보를 검색합니다.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(다음에서 상속됨 MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

개체에서 제공하는 형식 정보 인터페이스의 수를 검색합니다(0 또는 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(다음에서 상속됨 MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

개체에서 노출하는 메서드와 속성에 대한 액세스를 제공합니다.Provides access to properties and methods exposed by an object.

(다음에서 상속됨 MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

이름 집합을 해당하는 디스패치 식별자 집합에 매핑합니다.Maps a set of names to a corresponding set of dispatch identifiers.

(다음에서 상속됨 MethodBase)
_MethodBase.GetType()

이 멤버에 대한 설명은 GetType()를 참조하세요.For a description of this member, see GetType().

(다음에서 상속됨 MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

인터페이스의 형식 정보를 가져오는 데 사용할 수 있는 개체의 형식 정보를 검색합니다.Retrieves the type information for an object, which can then be used to get the type information for an interface.

(다음에서 상속됨 MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

개체에서 제공하는 형식 정보 인터페이스의 수를 검색합니다(0 또는 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(다음에서 상속됨 MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

개체에서 노출하는 메서드와 속성에 대한 액세스를 제공합니다.Provides access to properties and methods exposed by an object.

(다음에서 상속됨 MethodBase)
_MethodBase.IsAbstract

이 멤버에 대한 설명은 IsAbstract를 참조하세요.For a description of this member, see IsAbstract.

(다음에서 상속됨 MethodBase)
_MethodBase.IsAssembly

이 멤버에 대한 설명은 IsAssembly를 참조하세요.For a description of this member, see IsAssembly.

(다음에서 상속됨 MethodBase)
_MethodBase.IsConstructor

이 멤버에 대한 설명은 IsConstructor를 참조하세요.For a description of this member, see IsConstructor.

(다음에서 상속됨 MethodBase)
_MethodBase.IsFamily

이 멤버에 대한 설명은 IsFamily를 참조하세요.For a description of this member, see IsFamily.

(다음에서 상속됨 MethodBase)
_MethodBase.IsFamilyAndAssembly

이 멤버에 대한 설명은 IsFamilyAndAssembly를 참조하세요.For a description of this member, see IsFamilyAndAssembly.

(다음에서 상속됨 MethodBase)
_MethodBase.IsFamilyOrAssembly

이 멤버에 대한 설명은 IsFamilyOrAssembly를 참조하세요.For a description of this member, see IsFamilyOrAssembly.

(다음에서 상속됨 MethodBase)
_MethodBase.IsFinal

이 멤버에 대한 설명은 IsFinal를 참조하세요.For a description of this member, see IsFinal.

(다음에서 상속됨 MethodBase)
_MethodBase.IsHideBySig

이 멤버에 대한 설명은 IsHideBySig를 참조하세요.For a description of this member, see IsHideBySig.

(다음에서 상속됨 MethodBase)
_MethodBase.IsPrivate

이 멤버에 대한 설명은 IsPrivate를 참조하세요.For a description of this member, see IsPrivate.

(다음에서 상속됨 MethodBase)
_MethodBase.IsPublic

이 멤버에 대한 설명은 IsPublic를 참조하세요.For a description of this member, see IsPublic.

(다음에서 상속됨 MethodBase)
_MethodBase.IsSpecialName

이 멤버에 대한 설명은 IsSpecialName를 참조하세요.For a description of this member, see IsSpecialName.

(다음에서 상속됨 MethodBase)
_MethodBase.IsStatic

이 멤버에 대한 설명은 IsStatic를 참조하세요.For a description of this member, see IsStatic.

(다음에서 상속됨 MethodBase)
_MethodBase.IsVirtual

이 멤버에 대한 설명은 IsVirtual를 참조하세요.For a description of this member, see IsVirtual.

(다음에서 상속됨 MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

이름 집합을 해당하는 디스패치 식별자 집합에 매핑합니다.Maps a set of names to a corresponding set of dispatch identifiers.

(다음에서 상속됨 MethodInfo)
_MethodInfo.GetType()

COM에서 GetType() 메서드에 대한 액세스를 제공합니다.Provides access to the GetType() method from COM.

(다음에서 상속됨 MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

인터페이스의 형식 정보를 가져오는 데 사용할 수 있는 개체의 형식 정보를 검색합니다.Retrieves the type information for an object, which can be used to get the type information for an interface.

(다음에서 상속됨 MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)

개체에서 제공하는 형식 정보 인터페이스의 수를 검색합니다(0 또는 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(다음에서 상속됨 MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

개체에서 노출하는 메서드와 속성에 대한 액세스를 제공합니다.Provides access to properties and methods exposed by an object.

(다음에서 상속됨 MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

명명된 특성을 제외하고 이 멤버에 정의된 모든 사용자 지정 특성의 배열을 반환하거나 사용자 지정 특성이 없는 경우 빈 배열을 반환합니다.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.

(다음에서 상속됨 MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

형식으로 식별되는 이 멤버에 정의된 사용자 지정 특성의 배열을 반환하거나 해당 형식의 사용자 지정 특성이 없는 경우 빈 배열을 반환합니다.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.

(다음에서 상속됨 MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

하나 이상의 attributeType 인스턴스가 이 멤버에 대해 정의되는지 여부를 나타냅니다.Indicates whether one or more instance of attributeType is defined on this member.

(다음에서 상속됨 MemberInfo)

확장 메서드

GetCustomAttribute(MemberInfo, Type)

지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성을 검색합니다.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.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)

지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성을 검색합니다.Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.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)

지정된 멤버에 적용된 사용자 지정 특성 컬렉션을 검색합니다.Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean)

사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.Retrieves a collection of custom attributes that are applied to a specified member, and optionally inspects the ancestors of that member.

GetCustomAttributes(MemberInfo, Type)

지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성 컬렉션을 검색합니다.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.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)

지정된 멤버에 적용된 지정된 형식의 사용자 지정 특성 컬렉션을 검색합니다.Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되는 컬렉션을 검색하거나 선택적으로 해당 멤버의 상위 항목을 검사합니다.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)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되었는지 여부를 나타냅니다.Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean)

지정된 형식의 사용자 지정 특성이 지정된 멤버에 적용되었는지, 또는 선택적으로 상위 항목에 적용되었는지 여부를 결정합니다.Indicates whether custom attributes of a specified type are applied to a specified member, and, optionally, applied to its ancestors.

GetMetadataToken(MemberInfo)

사용 가능한 경우 지정된 멤버의 메타데이터 토큰을 가져옵니다.Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo)

지정된 멤버에 대해 메타데이터 토큰을 사용할 수 있는지를 나타내는 값을 반환합니다.Returns a value that indicates whether a metadata token is available for the specified member.

GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo)

메서드가 처음으로 선언된 직접 또는 간접 기본 클래스에서 지정된 메서드를 표현하는 개체를 검색합니다.Retrieves an object that represents the specified method on the direct or indirect base class where the method was first declared.

적용 대상