DynamicMethod DynamicMethod DynamicMethod DynamicMethod Class

定義

コンパイル、実行、および破棄することのできる動的メソッドを定義し、またそれを表現します。 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
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DynamicMethod : System.Reflection.MethodInfo
type DynamicMethod = class
    inherit MethodInfo
Public NotInheritable Class DynamicMethod
Inherits MethodInfo
継承
属性

次のコード例では、2 つのパラメーターを受け取る動的メソッドを作成します。The following code example creates a dynamic method that takes two parameters. 例では、最初のパラメーターをコンソールに出力する単純な関数の本体を出力して、例では、2 番目のパラメーターを使用して、メソッドの戻り値として。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
Imports System.Reflection
Imports System.Reflection.Emit
Imports Microsoft.VisualBasic
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) コンパイラによって作成された実行可能コードが再利用されるときに、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. 既定がない非パブリック データにアクセスします。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. 動的メソッドが非パブリック メンバーがアクセスするアセンブリの信頼レベルと同じか、または動的メソッドを出力する呼び出しスタックの信頼レベルのサブセットである必要があります。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と共に、RestrictedMemberAccessMemberAccessフラグ。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 members of public types in any assembly. 任意のアセンブリ内のパブリック型のパブリック メンバー。Public members of public types in any assembly.
スキップ JIT 参照範囲チェックを制限があります。Skipping JIT visibility checks, with restrictions 任意のアセンブリ内のパブリック型のパブリック メンバー。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 Service Pack 1.NET Framework 2.0 Service Pack 1、必要なコードを出力ReflectionPermissionで、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. このアクセス許可が 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.NET Frameworkがある場合にのみ、インターネット アクセス許可でライブラリを使用できます、SecurityCriticalAttribute属性し、もを実行、AssertReflectionEmitします。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. このようなライブラリでは、コーディング エラーがあるとセキュリティ ホールが発生するおそれがあるため、セキュリティを慎重にレビューする必要があります。Such libraries require careful security review because coding errors could result in security holes. コードの生成は本質的に特権を必要とする操作ではないため、.NET Framework 2.0 SP1.NET Framework 2.0 SP1 はセキュリティ確認要求を発行せずに部分信頼シナリオでコードを出力できます。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. これは、生成されたコードには、コードを出力したアセンブリと同等以下のアクセス許可しかないことを意味します。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.NET Framework 3.5またはそれ以降。To use this feature, your application should target the .NET Framework 3.5.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 and internal members of public, internal, and private types in the module.

任意のアセンブリ内のパブリック型のパブリック メンバー。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 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.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.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.NET Framework 2.0、いるシンボル情報、ローカル変数名と行番号のマップの動的メソッドはサポートされません。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. この制限は、将来のバージョンで削除される可能性があります。This limitation might be removed in a future version. 使用することができますAssemblyBuilder開発時に生成された Microsoft intermediate language (MSIL) のデバッグを簡略化し、そのために、最後のデプロイ時に動的メソッドにし、切り替えるには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) コンパイラは、セキュリティの要求を挿入します。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.

  • 検証できないコードを含む動的メソッドが (mscorlib.dll) などのレベル 2 の透過性のあるアセンブリに関連付けられている場合は、セキュリティの要求ではなく、(、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.

  • 常に検証できないコードを含む匿名でホストされる動的メソッドは、例外をスローします。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.

検証不可能なコードに対してスローされる例外は、動的メソッドが呼び出される方法によって異なります。The exception that is thrown for unverifiable code varies depending on the way the dynamic method is invoked. 返されたデリゲートを使用して動的メソッドを呼び出すかどうか、CreateDelegateメソッド、VerificationExceptionがスローされます。If you invoke a dynamic method by using a delegate returned from the CreateDelegate method, a VerificationException is thrown. 使用して、動的メソッドを呼び出す場合、Invokeメソッド、TargetInvocationException内部でスローされる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) DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean) DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean) DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)

メソッド名、属性、呼び出し規約、戻り値の型、パラメーターの型、モジュールを指定し、さらに Just-In-Time (JIT) 参照範囲チェックが動的メソッドの Microsoft Intermediate Language (MSIL) によりアクセスされる型やメンバーをスキップするかどうかを指定して、動的メソッドを作成します。 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) DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean) DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean) DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)

メソッド名、属性、呼び出し規則、戻り値の型、パラメーターの型、動的メソッドが論理的に関連付けられている型を指定し、さらに Just-In-Time (JIT) 参照範囲チェックが動的メソッドの Microsoft Intermediate Language (MSIL) によりアクセスされる型やメンバーをスキップするかどうかを指定して、動的メソッドを作成します。 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[]) DynamicMethod(String, Type, Type[]) DynamicMethod(String, Type, Type[]) DynamicMethod(String, Type, Type[])

メソッド名、戻り値の型、パラメーターの型を指定して、匿名でホストされる動的メソッドを初期化します。 Initializes an anonymously hosted dynamic method, specifying the method name, return type, and parameter types.

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

メソッド名、戻り値の型、パラメーターの型を指定し、さらに Just-In-Time (JIT) 参照範囲チェックが動的メソッドの Microsoft Intermediate Language (MSIL) によりアクセスされる型やメンバーをスキップするかどうかを指定して、匿名ホスト対象の動的メソッドを初期化します。 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) DynamicMethod(String, Type, Type[], Module) DynamicMethod(String, Type, Type[], Module) 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) DynamicMethod(String, Type, Type[], Module, Boolean) DynamicMethod(String, Type, Type[], Module, Boolean) DynamicMethod(String, Type, Type[], Module, Boolean)

メソッド名、戻り値の型、パラメーターの型、モジュールを指定し、さらに Just-In-Time (JIT) 参照範囲チェックが動的メソッドの Microsoft Intermediate Language (MSIL) によりアクセスされる型やメンバーをスキップするかどうかを指定して、モジュールに対してグローバルな動的メソッドを作成します。 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) DynamicMethod(String, Type, Type[], Type) DynamicMethod(String, Type, Type[], Type) 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) DynamicMethod(String, Type, Type[], Type, Boolean) DynamicMethod(String, Type, Type[], Type, Boolean) DynamicMethod(String, Type, Type[], Type, Boolean)

メソッド名、戻り値の型、パラメーターの型、動的メソッドが論理的に関連付けられている型を指定し、さらに動的メソッドの Microsoft Intermediate Language (MSIL) によりアクセスされる型やメンバーに対する Just-In-Time (JIT) 参照範囲チェックをスキップするかどうかを指定して、動的メソッドを作成します。 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 Attributes Attributes Attributes

動的メソッドの作成時に指定された属性を取得します。 Gets the attributes specified when the dynamic method was created.

CallingConvention CallingConvention CallingConvention CallingConvention

動的メソッドの作成時に指定された呼び出し規則を取得します。 Gets the calling convention specified when the dynamic method was created.

ContainsGenericParameters ContainsGenericParameters ContainsGenericParameters ContainsGenericParameters Inherited from MethodInfo
CustomAttributes CustomAttributes CustomAttributes CustomAttributes

このメンバーのカスタム属性を含むコレクションを取得します。 Gets a collection that contains this member's custom attributes.

(Inherited from MemberInfo)
DeclaringType DeclaringType DeclaringType DeclaringType

メソッドを宣言する型を取得します。動的メソッドの場合は常に null です。 Gets the type that declares the method, which is always null for dynamic methods.

InitLocals InitLocals InitLocals InitLocals

メソッドのローカル変数をゼロに初期化するかどうかを示す値を取得または設定します。 Gets or sets a value indicating whether the local variables in the method are zero-initialized.

IsAbstract IsAbstract IsAbstract IsAbstract

メソッドが抽象メソッドかどうかを示す値を取得します。 Gets a value indicating whether the method is abstract.

(Inherited from MethodBase)
IsAssembly IsAssembly IsAssembly 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.

(Inherited from MethodBase)
IsConstructedGenericMethod IsConstructedGenericMethod IsConstructedGenericMethod IsConstructedGenericMethod Inherited from MethodBase
IsConstructor IsConstructor IsConstructor IsConstructor

メソッドがコンストラクターかどうかを示す値を取得します。 Gets a value indicating whether the method is a constructor.

(Inherited from MethodBase)
IsFamily IsFamily IsFamily 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.

(Inherited from MethodBase)
IsFamilyAndAssembly IsFamilyAndAssembly IsFamilyAndAssembly 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.

(Inherited from MethodBase)
IsFamilyOrAssembly IsFamilyOrAssembly IsFamilyOrAssembly 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.

(Inherited from MethodBase)
IsFinal IsFinal IsFinal IsFinal

このメソッドが final かどうかを示す値を取得します。 Gets a value indicating whether this method is final.

(Inherited from MethodBase)
IsGenericMethod IsGenericMethod IsGenericMethod IsGenericMethod Inherited from MethodInfo
IsGenericMethodDefinition IsGenericMethodDefinition IsGenericMethodDefinition IsGenericMethodDefinition Inherited from MethodInfo
IsHideBySig IsHideBySig IsHideBySig IsHideBySig

派生クラスで、正確に同じシグネチャを持つ同じ種類のメンバーだけが隠しメンバーになるかどうかを示す値を取得します。 Gets a value indicating whether only a member of the same kind with exactly the same signature is hidden in the derived class.

(Inherited from MethodBase)
IsPrivate IsPrivate IsPrivate IsPrivate

このメンバーがプライベートかどうかを示す値を取得します。 Gets a value indicating whether this member is private.

(Inherited from MethodBase)
IsPublic IsPublic IsPublic IsPublic

パブリック メソッドかどうかを示す値を取得します。 Gets a value indicating whether this is a public method.

(Inherited from MethodBase)
IsSecurityCritical IsSecurityCritical IsSecurityCritical IsSecurityCritical

現在の動的メソッドがセキュリティ クリティカルまたはセキュリティ セーフ クリティカルであり、重要な操作を実行できるかどうかを示す値を取得します。 Gets a value that indicates whether the current dynamic method is security-critical or security-safe-critical, and therefore can perform critical operations.

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

IsSecurityTransparent IsSecurityTransparent IsSecurityTransparent IsSecurityTransparent

現在の動的メソッドが現在の信頼レベルで透過的であり、重要な操作を実行できないかどうかを示す値を取得します。 Gets a value that indicates whether the current dynamic method is transparent at the current trust level, and therefore cannot perform critical operations.

IsSpecialName IsSpecialName IsSpecialName IsSpecialName

特別な名前のメソッドかどうかを示す値を取得します。 Gets a value indicating whether this method has a special name.

(Inherited from MethodBase)
IsStatic IsStatic IsStatic IsStatic

メソッドが static であるかどうかを示す値を取得します。 Gets a value indicating whether the method is static.

(Inherited from MethodBase)
IsVirtual IsVirtual IsVirtual IsVirtual

メソッドが virtual であるかどうかを示す値を取得します。 Gets a value indicating whether the method is virtual.

(Inherited from MethodBase)
MemberType MemberType MemberType MemberType

このメンバーがメソッドであることを示す MemberTypes 値を取得します。 Gets a MemberTypes value indicating that this member is a method.

(Inherited from MethodInfo)
MetadataToken MetadataToken MetadataToken MetadataToken

メタデータ要素を識別する値を取得します。 Gets a value that identifies a metadata element.

(Inherited from MemberInfo)
MethodHandle MethodHandle MethodHandle MethodHandle

動的メソッドはサポートされていません。 Not supported for dynamic methods.

MethodImplementationFlags MethodImplementationFlags MethodImplementationFlags MethodImplementationFlags
Module Module Module Module

動的メソッドが論理的に関連付けられるモジュールを取得します。 Gets the module with which the dynamic method is logically associated.

Name Name Name Name

動的メソッドの名前を取得します。 Gets the name of the dynamic method.

ReflectedType ReflectedType ReflectedType ReflectedType

メソッドを取得するためにリフレクションで使用されたクラスを取得します。 Gets the class that was used in reflection to obtain the method.

ReturnParameter ReturnParameter ReturnParameter ReturnParameter

動的メソッドの戻りパラメーターを取得します。 Gets the return parameter of the dynamic method.

ReturnType ReturnType ReturnType ReturnType

動的メソッドの戻り値の型を取得します。 Gets the type of return value for the dynamic method.

ReturnTypeCustomAttributes ReturnTypeCustomAttributes ReturnTypeCustomAttributes ReturnTypeCustomAttributes

動的メソッドの戻り値の型のカスタム属性を取得します。 Gets the custom attributes of the return type for the dynamic method.

_MethodBase.IsAbstract _MethodBase.IsAbstract _MethodBase.IsAbstract _MethodBase.IsAbstract

このメンバーの詳細については、「IsAbstract」をご覧ください。 For a description of this member, see IsAbstract.

(Inherited from MethodBase)
_MethodBase.IsAssembly _MethodBase.IsAssembly _MethodBase.IsAssembly _MethodBase.IsAssembly

このメンバーの詳細については、「IsAssembly」をご覧ください。 For a description of this member, see IsAssembly.

(Inherited from MethodBase)
_MethodBase.IsConstructor _MethodBase.IsConstructor _MethodBase.IsConstructor _MethodBase.IsConstructor

このメンバーの詳細については、「IsConstructor」をご覧ください。 For a description of this member, see IsConstructor.

(Inherited from MethodBase)
_MethodBase.IsFamily _MethodBase.IsFamily _MethodBase.IsFamily _MethodBase.IsFamily

このメンバーの詳細については、「IsFamily」をご覧ください。 For a description of this member, see IsFamily.

(Inherited from MethodBase)
_MethodBase.IsFamilyAndAssembly _MethodBase.IsFamilyAndAssembly _MethodBase.IsFamilyAndAssembly _MethodBase.IsFamilyAndAssembly

このメンバーの詳細については、「IsFamilyAndAssembly」をご覧ください。 For a description of this member, see IsFamilyAndAssembly.

(Inherited from MethodBase)
_MethodBase.IsFamilyOrAssembly _MethodBase.IsFamilyOrAssembly _MethodBase.IsFamilyOrAssembly _MethodBase.IsFamilyOrAssembly

このメンバーの詳細については、「IsFamilyOrAssembly」をご覧ください。 For a description of this member, see IsFamilyOrAssembly.

(Inherited from MethodBase)
_MethodBase.IsFinal _MethodBase.IsFinal _MethodBase.IsFinal _MethodBase.IsFinal

このメンバーの詳細については、「IsFinal」をご覧ください。 For a description of this member, see IsFinal.

(Inherited from MethodBase)
_MethodBase.IsHideBySig _MethodBase.IsHideBySig _MethodBase.IsHideBySig _MethodBase.IsHideBySig

このメンバーの詳細については、「IsHideBySig」をご覧ください。 For a description of this member, see IsHideBySig.

(Inherited from MethodBase)
_MethodBase.IsPrivate _MethodBase.IsPrivate _MethodBase.IsPrivate _MethodBase.IsPrivate

このメンバーの詳細については、「IsPrivate」をご覧ください。 For a description of this member, see IsPrivate.

(Inherited from MethodBase)
_MethodBase.IsPublic _MethodBase.IsPublic _MethodBase.IsPublic _MethodBase.IsPublic

このメンバーの詳細については、「IsPublic」をご覧ください。 For a description of this member, see IsPublic.

(Inherited from MethodBase)
_MethodBase.IsSpecialName _MethodBase.IsSpecialName _MethodBase.IsSpecialName _MethodBase.IsSpecialName

このメンバーの詳細については、「IsSpecialName」をご覧ください。 For a description of this member, see IsSpecialName.

(Inherited from MethodBase)
_MethodBase.IsStatic _MethodBase.IsStatic _MethodBase.IsStatic _MethodBase.IsStatic

このメンバーの詳細については、「IsStatic」をご覧ください。 For a description of this member, see IsStatic.

(Inherited from MethodBase)
_MethodBase.IsVirtual _MethodBase.IsVirtual _MethodBase.IsVirtual _MethodBase.IsVirtual

このメンバーの詳細については、「IsVirtual」をご覧ください。 For a description of this member, see IsVirtual.

(Inherited from MethodBase)

方法

CreateDelegate(Type) CreateDelegate(Type) CreateDelegate(Type) CreateDelegate(Type)

動的メソッドを完了し、それを実行するために使用できるデリゲートを作成します。 Completes the dynamic method and creates a delegate that can be used to execute it.

CreateDelegate(Type, Object) CreateDelegate(Type, Object) CreateDelegate(Type, Object) 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.

DefineParameter(Int32, ParameterAttributes, String) DefineParameter(Int32, ParameterAttributes, String) DefineParameter(Int32, ParameterAttributes, String) DefineParameter(Int32, ParameterAttributes, String)

動的メソッドのパラメーターを定義します。 Defines a parameter of the dynamic method.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

このインスタンスが、指定されたオブジェクトと等価であるかどうかを示す値を返します。 Returns a value that indicates whether this instance is equal to a specified object.

(Inherited from MethodInfo)
GetBaseDefinition() GetBaseDefinition() GetBaseDefinition() GetBaseDefinition()

メソッドの基本実装を返します。 Returns the base implementation for the method.

GetCustomAttributes(Boolean) GetCustomAttributes(Boolean) GetCustomAttributes(Boolean) GetCustomAttributes(Boolean)

メソッドの定義済みのカスタム属性をすべて返します。 Returns all the custom attributes defined for the method.

GetCustomAttributes(Type, Boolean) GetCustomAttributes(Type, Boolean) GetCustomAttributes(Type, Boolean) GetCustomAttributes(Type, Boolean)

メソッドに適用されている、指定した型のカスタム属性を返します。 Returns the custom attributes of the specified type that have been applied to the method.

GetCustomAttributesData() GetCustomAttributesData() GetCustomAttributesData() GetCustomAttributesData()

ターゲット メンバーに適用されている属性に関するデータを表す CustomAttributeData オブジェクトのリストを返します。 Returns a list of CustomAttributeData objects representing data about the attributes that have been applied to the target member.

(Inherited from MemberInfo)
GetDynamicILInfo() GetDynamicILInfo() GetDynamicILInfo() 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() GetGenericArguments() GetGenericArguments() 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.

(Inherited from MethodInfo)
GetGenericMethodDefinition() GetGenericMethodDefinition() GetGenericMethodDefinition() GetGenericMethodDefinition()

現在のメソッドを構築する元になるジェネリック メソッド定義を表す MethodInfo オブジェクトを返します。 Returns a MethodInfo object that represents a generic method definition from which the current method can be constructed.

(Inherited from MethodInfo)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

このインスタンスのハッシュ コードを返します。 Returns the hash code for this instance.

(Inherited from MethodInfo)
GetILGenerator() GetILGenerator() GetILGenerator() GetILGenerator()

メソッドの Microsoft Intermediate Language (MSIL) ジェネレーターを返します。これは 64 バイトの既定の MSIL ストリーム サイズを持ちます。 Returns a Microsoft intermediate language (MSIL) generator for the method with a default MSIL stream size of 64 bytes.

GetILGenerator(Int32) GetILGenerator(Int32) GetILGenerator(Int32) GetILGenerator(Int32)

指定した Microsoft Intermediate Language (MSIL) ストリーム サイズの、メソッドの MSIL ジェネレーターを返します。 Returns a Microsoft intermediate language (MSIL) generator for the method with the specified MSIL stream size.

GetMethodBody() GetMethodBody() GetMethodBody() 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.

(Inherited from MethodBase)
GetMethodImplementationFlags() GetMethodImplementationFlags() GetMethodImplementationFlags() GetMethodImplementationFlags()

このメソッドの実装フラグを返します。 Returns the implementation flags for the method.

GetParameters() GetParameters() GetParameters() GetParameters()

動的メソッドのパラメーターを返します。 Returns the parameters of the dynamic method.

GetType() GetType() GetType() GetType() Inherited from MethodInfo
HasSameMetadataDefinitionAs(MemberInfo) HasSameMetadataDefinitionAs(MemberInfo) HasSameMetadataDefinitionAs(MemberInfo) HasSameMetadataDefinitionAs(MemberInfo) Inherited from MemberInfo
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) 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, Object[]) Invoke(Object, Object[]) Invoke(Object, Object[]) Invoke(Object, Object[]) Inherited from MethodInfo
IsDefined(Type, Boolean) IsDefined(Type, Boolean) IsDefined(Type, Boolean) IsDefined(Type, Boolean)

指定されたカスタム属性の型が定義されているかどうかを示します。 Indicates whether the specified custom attribute type is defined.

MakeGenericMethod(Type[]) MakeGenericMethod(Type[]) MakeGenericMethod(Type[]) 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.

(Inherited from MethodInfo)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

現在の Object の簡易コピーを作成します。 Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

文字列として表される、メソッドの署名を返します。 Returns the signature of the method, represented as a string.

明示的なインターフェイスの実装

ICustomAttributeProvider.GetCustomAttributes(Boolean) ICustomAttributeProvider.GetCustomAttributes(Boolean) ICustomAttributeProvider.GetCustomAttributes(Boolean) ICustomAttributeProvider.GetCustomAttributes(Boolean) Inherited from MemberInfo
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) ICustomAttributeProvider.GetCustomAttributes(Type, Boolean) Inherited from MemberInfo
ICustomAttributeProvider.IsDefined(Type, Boolean) ICustomAttributeProvider.IsDefined(Type, Boolean) ICustomAttributeProvider.IsDefined(Type, Boolean) ICustomAttributeProvider.IsDefined(Type, Boolean) Inherited from MemberInfo
_MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MemberInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

一連の名前を対応する一連のディスパッチ識別子に割り当てます。 Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from MemberInfo)
_MemberInfo.GetType() _MemberInfo.GetType() _MemberInfo.GetType() _MemberInfo.GetType()

Type クラスを表す MemberInfo オブジェクトを取得します。 Gets a Type object representing the MemberInfo class.

(Inherited from MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr) _MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr) _MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr) _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.

(Inherited from MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32) _MemberInfo.GetTypeInfoCount(UInt32) _MemberInfo.GetTypeInfoCount(UInt32) _MemberInfo.GetTypeInfoCount(UInt32)

オブジェクトが提供する型情報インターフェイスの数 (0 または 1) を取得します。 Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

オブジェクトによって公開されたプロパティおよびメソッドへのアクセスを提供します。 Provides access to properties and methods exposed by an object.

(Inherited from MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

一連の名前を対応する一連のディスパッチ識別子に割り当てます。 Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from MethodBase)
_MethodBase.GetType() _MethodBase.GetType() _MethodBase.GetType() _MethodBase.GetType()

このメンバーの詳細については、「GetType()」をご覧ください。 For a description of this member, see GetType().

(Inherited from MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr) _MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr) _MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr) _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.

(Inherited from MethodBase)
_MethodBase.GetTypeInfoCount(UInt32) _MethodBase.GetTypeInfoCount(UInt32) _MethodBase.GetTypeInfoCount(UInt32) _MethodBase.GetTypeInfoCount(UInt32)

オブジェクトが提供する型情報インターフェイスの数 (0 または 1) を取得します。 Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

オブジェクトによって公開されたプロパティおよびメソッドへのアクセスを提供します。 Provides access to properties and methods exposed by an object.

(Inherited from MethodBase)
_MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _MethodInfo.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

一連の名前を対応する一連のディスパッチ識別子に割り当てます。 Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from MethodInfo)
_MethodInfo.GetType() _MethodInfo.GetType() _MethodInfo.GetType() _MethodInfo.GetType()

COM から GetType() メソッドにアクセスできるようにします。 Provides access to the GetType() method from COM.

(Inherited from MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr) _MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr) _MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr) _MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

オブジェクトの型情報を取得します。この情報はインターフェイスの型情報の取得に使用できます。 Retrieves the type information for an object, which can be used to get the type information for an interface.

(Inherited from MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32) _MethodInfo.GetTypeInfoCount(UInt32) _MethodInfo.GetTypeInfoCount(UInt32) _MethodInfo.GetTypeInfoCount(UInt32)

オブジェクトが提供する型情報インターフェイスの数 (0 または 1) を取得します。 Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

オブジェクトによって公開されたプロパティおよびメソッドへのアクセスを提供します。 Provides access to properties and methods exposed by an object.

(Inherited from MethodInfo)

適用対象

こちらもご覧ください