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.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) コンパイラによって作成された実行可能コードは、 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. 匿名でホストさReflectionPermissionれる動的メソッドは、 ReflectionPermissionFlag.RestrictedMemberAccessフラグで JIT コンパイラの参照範囲チェックを省略できるようにすることができます。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 MemberAccessRestrictedMemberAccess両方のフラグを使用してコードを許可する必要があります。You can associate a dynamic method with any type, but your code must be granted ReflectionPermission with both the RestrictedMemberAccess and MemberAccess flags.

次の表は、匿名でホストされる動的メソッドにアクセスできる型およびメンバーを示しています。これは、 ReflectionPermission RestrictedMemberAccessフラグが付与されているかどうかによって異なりますが、JIT 参照範囲チェックの有無は関係ありません。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.

注意

より前ReflectionPermissionでは、 ReflectionPermissionFlag.ReflectionEmitフラグを使用して必要なコードを出力していました。 .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1Prior 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 Assert属性があり、のReflectionEmitを実行する場合にのみ、インターネットアクセス許可でライブラリを使用できます。Therefore, in earlier versions of the .NET Framework.NET Framework a library can be used with Internet permissions only if it has the SecurityCriticalAttribute attribute and also executes an Assert for ReflectionEmit. このようなライブラリでは、コーディング エラーがあるとセキュリティ ホールが発生するおそれがあるため、セキュリティを慎重にレビューする必要があります。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 中間言語 (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.

  • 検証不可能なコードを含む動的メソッドが、レベル2の透過性 (mscorlib.dll など) を持つアセンブリに関連付けられている場合、セキュリティ要求を行うのではなく、(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. メソッドから返されたデリゲートを使用して動的メソッドを呼び出すと、がスローされます。VerificationException CreateDelegateIf you invoke a dynamic method by using a delegate returned from the CreateDelegate method, a VerificationException is thrown. メソッドを使用VerificationExceptionして動的メソッドを呼び出すと、が内部でスローされます。TargetInvocationException InvokeIf 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)

メソッド名、属性、呼び出し規約、戻り値の型、パラメーターの型、モジュールを指定し、さらに動的メソッドの 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) DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean) DynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean) 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[]) 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)

メソッド名、戻り値の型、パラメーターの型、モジュールを指定し、さらに動的メソッドの 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) 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)

メソッド名、戻り値の型、パラメーターの型、動的メソッドを論理的に関連付ける型を指定し、さらに動的メソッドの 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 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

ジェネリック メソッドに未割り当てのジェネリック型パラメーターが含まれているかどうかを示す値を取得します。Gets a value that indicates whether a generic method contains unassigned generic type parameters.

(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

メソッドのローカル変数を 0 で初期化するかどうかを示す値を取得または設定します。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)
IsCollectible IsCollectible IsCollectible IsCollectible

この MemberInfo オブジェクトが、収集可能な AssemblyLoadContext に保持されているアセンブリの一部であるかどうかを示す値を取得します。Gets a value that indicates whether this MemberInfo object is part of an assembly held in a collectible AssemblyLoadContext.

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

現在のメソッドがジェネリック メソッドかどうかを示す値を取得します。Gets a value indicating whether the current method is a generic method.

(Inherited from MethodInfo)
IsGenericMethodDefinition IsGenericMethodDefinition IsGenericMethodDefinition IsGenericMethodDefinition

現在の MethodInfo がジェネリック メソッドの定義を表しているかどうかを示す値を取得します。Gets a value indicating whether the current MethodInfo represents the definition of a generic method.

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

既定の MSIL (Microsoft Intermediate Language) ストリーム サイズである 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)

指定された MSIL (Microsoft Intermediate Language) ストリーム サイズのメソッドに 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)

拡張メソッド

GetCustomAttribute(MemberInfo, Type) GetCustomAttribute(MemberInfo, Type) GetCustomAttribute(MemberInfo, Type) GetCustomAttribute(MemberInfo, Type)

指定したメンバーに適用される指定した型のカスタム属性を取得します。Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute(MemberInfo, Type, Boolean) GetCustomAttribute(MemberInfo, Type, Boolean) GetCustomAttribute(MemberInfo, Type, Boolean) 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) GetCustomAttribute<T>(MemberInfo) GetCustomAttribute<T>(MemberInfo) GetCustomAttribute<T>(MemberInfo)

指定したメンバーに適用される指定した型のカスタム属性を取得します。Retrieves a custom attribute of a specified type that is applied to a specified member.

GetCustomAttribute<T>(MemberInfo, Boolean) GetCustomAttribute<T>(MemberInfo, Boolean) GetCustomAttribute<T>(MemberInfo, Boolean) 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) GetCustomAttributes(MemberInfo) GetCustomAttributes(MemberInfo) GetCustomAttributes(MemberInfo)

指定されたメンバーに適用されるカスタム属性のコレクションを取得します。Retrieves a collection of custom attributes that are applied to a specified member.

GetCustomAttributes(MemberInfo, Boolean) GetCustomAttributes(MemberInfo, Boolean) GetCustomAttributes(MemberInfo, Boolean) 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) GetCustomAttributes(MemberInfo, Type) GetCustomAttributes(MemberInfo, Type) GetCustomAttributes(MemberInfo, Type)

指定されたメンバーに適用される指定された型のカスタム属性のコレクションを取得します。Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes(MemberInfo, Type, Boolean) GetCustomAttributes(MemberInfo, Type, Boolean) GetCustomAttributes(MemberInfo, Type, Boolean) 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) GetCustomAttributes<T>(MemberInfo) GetCustomAttributes<T>(MemberInfo) GetCustomAttributes<T>(MemberInfo)

指定されたメンバーに適用される指定された型のカスタム属性のコレクションを取得します。Retrieves a collection of custom attributes of a specified type that are applied to a specified member.

GetCustomAttributes<T>(MemberInfo, Boolean) GetCustomAttributes<T>(MemberInfo, Boolean) GetCustomAttributes<T>(MemberInfo, Boolean) 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) IsDefined(MemberInfo, Type) IsDefined(MemberInfo, Type) IsDefined(MemberInfo, Type)

指定された型のカスタム属性が指定されたメンバーに適用されているかどうかを示します。Indicates whether custom attributes of a specified type are applied to a specified member.

IsDefined(MemberInfo, Type, Boolean) IsDefined(MemberInfo, Type, Boolean) IsDefined(MemberInfo, Type, Boolean) 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) GetMetadataToken(MemberInfo) GetMetadataToken(MemberInfo) GetMetadataToken(MemberInfo)

指定されたメンバーのメタデータ トークンを取得します (存在する場合)。Gets a metadata token for the given member, if available.

HasMetadataToken(MemberInfo) HasMetadataToken(MemberInfo) HasMetadataToken(MemberInfo) HasMetadataToken(MemberInfo)

指定されたメンバーに対してメタデータ トークンを使用できるかどうかを示す値を返します。Returns a value that indicates whether a metadata token is available for the specified member.

GetBaseDefinition(MethodInfo) GetBaseDefinition(MethodInfo) GetBaseDefinition(MethodInfo) GetBaseDefinition(MethodInfo)
GetRuntimeBaseDefinition(MethodInfo) GetRuntimeBaseDefinition(MethodInfo) GetRuntimeBaseDefinition(MethodInfo) GetRuntimeBaseDefinition(MethodInfo)

メソッドが最初に宣言された直接基本クラスまたは間接基本クラスの指定したメソッドを表すオブジェクトを取得します。Retrieves an object that represents the specified method on the direct or indirect base class where the method was first declared.

適用対象

こちらもご覧ください