MethodBuilder クラス

定義

動的クラスのメソッドまたはコンストラクターを定義し、表わします。

public ref class MethodBuilder sealed : System::Reflection::MethodInfo
public ref class MethodBuilder abstract : System::Reflection::MethodInfo
public ref class MethodBuilder sealed : System::Reflection::MethodInfo, System::Runtime::InteropServices::_MethodBuilder
public sealed class MethodBuilder : System.Reflection.MethodInfo
public abstract class MethodBuilder : System.Reflection.MethodInfo
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class MethodBuilder : System.Reflection.MethodInfo, System.Runtime.InteropServices._MethodBuilder
type MethodBuilder = class
    inherit MethodInfo
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.None)>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type MethodBuilder = class
    inherit MethodInfo
    interface _MethodBuilder
Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Public MustInherit Class MethodBuilder
Inherits MethodInfo
Public NotInheritable Class MethodBuilder
Inherits MethodInfo
Implements _MethodBuilder
継承
属性
実装

次の例では、 クラスを MethodBuilder 使用して動的型内にメソッドを作成します。

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void AddMethodDynamically( TypeBuilder^ myTypeBld, 
                           String^ mthdName, 
                           array<Type^>^ mthdParams, 
                           Type^ returnType, 
                           String^ mthdAction )
{
   MethodBuilder^ myMthdBld = myTypeBld->DefineMethod( mthdName, static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), returnType, mthdParams );
   ILGenerator^ ILOut = myMthdBld->GetILGenerator();
   int numParams = mthdParams->Length;
   for ( Byte x = 0; x < numParams; x++ )
   {
      ILOut->Emit( OpCodes::Ldarg_S, x );

   }
   if ( numParams > 1 )
   {
      for ( int y = 0; y < (numParams - 1); y++ )
      {
         if ( mthdAction->Equals( "A" ) )
                  ILOut->Emit( OpCodes::Add );
         else
         if ( mthdAction->Equals( "M" ) )
                  ILOut->Emit( OpCodes::Mul );
         else
                  ILOut->Emit( OpCodes::Add );

      }
   }

   ILOut->Emit( OpCodes::Ret );
};

void main()
{
   AppDomain^ myDomain = AppDomain::CurrentDomain;
   AssemblyName^ asmName = gcnew AssemblyName;
   asmName->Name = "MyDynamicAsm";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( asmName, 
                                                                    AssemblyBuilderAccess::RunAndSave );
   ModuleBuilder^ myModule = myAsmBuilder->DefineDynamicModule( "MyDynamicAsm", 
                                                                "MyDynamicAsm.dll" );
   TypeBuilder^ myTypeBld = myModule->DefineType( "MyDynamicType", 
                                                  TypeAttributes::Public );
   
   // Get info from the user to build the method dynamically.
   Console::WriteLine( "Let's build a simple method dynamically!" );
   Console::WriteLine( "Please enter a few numbers, separated by spaces." );
   String^ inputNums = Console::ReadLine();
   Console::Write( "Do you want to [A]dd (default) or [M]ultiply these numbers? " );
   String^ myMthdAction = Console::ReadLine()->ToUpper();
   Console::Write( "Lastly, what do you want to name your new dynamic method? " );
   String^ myMthdName = Console::ReadLine();
   
   // Process inputNums into an array and create a corresponding Type array
   int index = 0;
   array<String^>^inputNumsList = inputNums->Split();
   array<Type^>^myMthdParams = gcnew array<Type^>(inputNumsList->Length);
   array<Object^>^inputValsList = gcnew array<Object^>(inputNumsList->Length);
   for each (String^ inputNum in inputNumsList)
   {
      inputValsList[ index ] = Convert::ToInt32( inputNum );
      myMthdParams[ index ] = int::typeid;
      index++;
   }

   
   // Now, call the method building method with the parameters, passing the
   // TypeBuilder by reference.
   AddMethodDynamically( myTypeBld, 
                         myMthdName, 
                         myMthdParams, 
                         int::typeid, 
                         myMthdAction );
   Type^ myType = myTypeBld->CreateType();

   Console::WriteLine( "---" );
   Console::WriteLine( "The result of {0} the inputted values is: {1}", 
                       ((myMthdAction->Equals( "M" )) ? "multiplying" : "adding"), 
                       myType->InvokeMember( myMthdName, 
                                             BindingFlags::InvokeMethod | BindingFlags::Public | BindingFlags::Static, 
                       nullptr, 
                       nullptr, 
                       inputValsList ) );
   Console::WriteLine( "---" );
   
   // Let's take a look at the method we created.
   // If you are interested in seeing the MSIL generated dynamically for the method
   // your program generated, change to the directory where you ran the compiled
   // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
   // of manifest contents appears, click on "MyDynamicType" and then on the name of
   // of the method you provided during execution.

   myAsmBuilder->Save( "MyDynamicAsm.dll" );

   MethodInfo^ myMthdInfo = myType->GetMethod( myMthdName );
   Console::WriteLine( "Your Dynamic Method: {0};", myMthdInfo );
}

using System;
using System.Reflection;
using System.Reflection.Emit;

class DemoMethodBuilder
{
    public static void AddMethodDynamically (TypeBuilder myTypeBld,
                                             string mthdName,
                                             Type[] mthdParams,
                                             Type returnType,
                                             string mthdAction)
    {

        MethodBuilder myMthdBld = myTypeBld.DefineMethod(
                                             mthdName,
                                             MethodAttributes.Public |
                                             MethodAttributes.Static,
                                             returnType,
                                             mthdParams);

        ILGenerator ILout = myMthdBld.GetILGenerator();

        int numParams = mthdParams.Length;

        for (byte x=0; x < numParams; x++)
        {
            ILout.Emit(OpCodes.Ldarg_S, x);
        }

        if (numParams > 1)
        {
            for (int y=0; y<(numParams-1); y++)
            {
                switch (mthdAction)
                {
                    case "A": ILout.Emit(OpCodes.Add);
                              break;
                    case "M": ILout.Emit(OpCodes.Mul);
                              break;
                    default: ILout.Emit(OpCodes.Add);
                              break;
                }
            }
        }
        ILout.Emit(OpCodes.Ret);
    }

    public static void Main()
    {
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName asmName = new AssemblyName();
        asmName.Name = "MyDynamicAsm";

        AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                                       asmName,
                                       AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule("MyDynamicAsm",
                                                                  "MyDynamicAsm.dll");

        TypeBuilder myTypeBld = myModule.DefineType("MyDynamicType",
                                                    TypeAttributes.Public);

        // Get info from the user to build the method dynamically.
        Console.WriteLine("Let's build a simple method dynamically!");
        Console.WriteLine("Please enter a few numbers, separated by spaces.");
        string inputNums = Console.ReadLine();
        Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ");
        string myMthdAction = Console.ReadLine().ToUpper();
        Console.Write("Lastly, what do you want to name your new dynamic method? ");
        string myMthdName = Console.ReadLine();

        // Process inputNums into an array and create a corresponding Type array
        int index = 0;
        string[] inputNumsList = inputNums.Split();

        Type[] myMthdParams = new Type[inputNumsList.Length];
        object[] inputValsList = new object[inputNumsList.Length];

        foreach (string inputNum in inputNumsList)
        {
            inputValsList[index] = (object)Convert.ToInt32(inputNum);
                myMthdParams[index] = typeof(int);
                index++;
        }

        // Now, call the method building method with the parameters, passing the
        // TypeBuilder by reference.
        AddMethodDynamically(myTypeBld,
                             myMthdName,
                             myMthdParams,
                             typeof(int),
                             myMthdAction);

        Type myType = myTypeBld.CreateType();

        Console.WriteLine("---");
        Console.WriteLine("The result of {0} the inputted values is: {1}",
                          ((myMthdAction == "M") ? "multiplying" : "adding"),
                          myType.InvokeMember(myMthdName,
                          BindingFlags.InvokeMethod | BindingFlags.Public |
                          BindingFlags.Static,
                          null,
                          null,
                          inputValsList));
        Console.WriteLine("---");

        // Let's take a look at the method we created.
        // If you are interested in seeing the MSIL generated dynamically for the method
        // your program generated, change to the directory where you ran the compiled
        // code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
        // of manifest contents appears, click on "MyDynamicType" and then on the name of
        // of the method you provided during execution.

        myAsmBuilder.Save("MyDynamicAsm.dll");

        MethodInfo myMthdInfo = myType.GetMethod(myMthdName);
        Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString());
    }
}
Imports System.Reflection
Imports System.Reflection.Emit

Class DemoMethodBuilder
   
   Public Shared Sub AddMethodDynamically(ByVal myTypeBld As TypeBuilder, _
                                          ByVal mthdName As String, _
                                          ByVal mthdParams() As Type, _
                                          ByVal returnType As Type, _
                                          ByVal mthdAction As String)
      
      Dim myMthdBld As MethodBuilder = myTypeBld.DefineMethod(mthdName, _
                                       MethodAttributes.Public Or MethodAttributes.Static, _
                                       returnType, _
                                       mthdParams)
      
      Dim ILout As ILGenerator = myMthdBld.GetILGenerator()
      
      Dim numParams As Integer = mthdParams.Length
      
      Dim x As Byte
      For x = 0 To numParams - 1
         ILout.Emit(OpCodes.Ldarg_S, x)
      Next x
      
      If numParams > 1 Then
         Dim y As Integer
         For y = 0 To (numParams - 1) - 1
            Select Case mthdAction
               Case "A"
                  ILout.Emit(OpCodes.Add)
               Case "M"
                  ILout.Emit(OpCodes.Mul)
               Case Else
                  ILout.Emit(OpCodes.Add)
            End Select
         Next y
      End If
      ILout.Emit(OpCodes.Ret)
   End Sub 
    
   
   Public Shared Sub Main()
      
      Dim myDomain As AppDomain = AppDomain.CurrentDomain
      Dim asmName As New AssemblyName()
      asmName.Name = "MyDynamicAsm"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(asmName, _
                                            AssemblyBuilderAccess.RunAndSave)
      
      Dim myModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyDynamicAsm", _
                                                                       "MyDynamicAsm.dll")
      
      Dim myTypeBld As TypeBuilder = myModule.DefineType("MyDynamicType", TypeAttributes.Public)
      
      ' Get info from the user to build the method dynamically.
      Console.WriteLine("Let's build a simple method dynamically!")
      Console.WriteLine("Please enter a few numbers, separated by spaces.")
      Dim inputNums As String = Console.ReadLine()
      Console.Write("Do you want to [A]dd (default) or [M]ultiply these numbers? ")
      Dim myMthdAction As String = Console.ReadLine().ToUpper()
      Console.Write("Lastly, what do you want to name your new dynamic method? ")
      Dim myMthdName As String = Console.ReadLine()
      
      ' Process inputNums into an array and create a corresponding Type array 
      Dim index As Integer = 0
      Dim inputNumsList As String() = inputNums.Split()
      
      Dim myMthdParams(inputNumsList.Length - 1) As Type
      Dim inputValsList(inputNumsList.Length - 1) As Object
      
      
      Dim inputNum As String
      For Each inputNum In  inputNumsList
         inputValsList(index) = CType(Convert.ToInt32(inputNum), Object)
         myMthdParams(index) = GetType(Integer)
         index += 1
      Next inputNum
      
      ' Now, call the method building method with the parameters, passing the 
      ' TypeBuilder by reference.
      AddMethodDynamically(myTypeBld, myMthdName, myMthdParams, GetType(Integer), myMthdAction)
      
      Dim myType As Type = myTypeBld.CreateType()
     
      Dim description as String 
      If myMthdAction = "M" Then
         description = "multiplying"
      Else
         description = "adding"
      End If

      Console.WriteLine("---")
      Console.WriteLine("The result of {0} the values is: {1}", _
                         description, _
                         myType.InvokeMember(myMthdName, _
                                             BindingFlags.InvokeMethod _
                                               Or BindingFlags.Public _
                                               Or BindingFlags.Static, _
                                             Nothing, _
                                             Nothing, _
                                             inputValsList)) 
      Console.WriteLine("---")

      ' If you are interested in seeing the MSIL generated dynamically for the method
      ' your program generated, change to the directory where you ran the compiled
      ' code sample and type "ildasm MyDynamicAsm.dll" at the prompt. When the list
      ' of manifest contents appears, click on "MyDynamicType" and then on the name of
      ' of the method you provided during execution.
 
      myAsmBuilder.Save("MyDynamicAsm.dll") 

      Dim myMthdInfo As MethodInfo = myType.GetMethod(myMthdName)
      Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString())
   End Sub 
End Class

注釈

この API の詳細については、「 MethodBuilder の補足 API 解説」を参照してください。

コンストラクター

MethodBuilder()

MethodBuilder クラスの新しいインスタンスを初期化します。

プロパティ

Attributes

このメソッドの属性を取得します。

CallingConvention

メソッドの呼び出し規則を返します。

ContainsGenericParameters

この型ではサポートされていません。

ContainsGenericParameters

ジェネリック メソッドに未割り当てのジェネリック型パラメーターが含まれているかどうかを示す値を取得します。

(継承元 MethodInfo)
CustomAttributes

このメンバーのカスタム属性を含むコレクションを取得します。

(継承元 MemberInfo)
DeclaringType

このメソッドを宣言する型を返します。

InitLocals

このメソッドのローカル変数をゼロに初期化するかどうかを指定するブール値を取得または設定します。 このプロパティの既定値は true です。

InitLocalsCore

派生クラスでオーバーライドされた場合、このメソッドのローカル変数がゼロ初期化されているかどうかを示す値を取得または設定します。

IsAbstract

メソッドが抽象メソッドかどうかを示す値を取得します。

(継承元 MethodBase)
IsAssembly

このメソッドまたはコンストラクターを参照できる範囲が Assembly によって示されるかどうかを表す値を取得します。ここで判定されるのは、このメソッドまたはコンストラクターが同じアセンブリ内の他の型でのみ参照でき、アセンブリ外部の派生型では参照できないものであることです。

(継承元 MethodBase)
IsCollectible

この MemberInfo オブジェクトが、収集可能な AssemblyLoadContext に保持されているアセンブリの一部であるかどうかを示す値を取得します。

(継承元 MemberInfo)
IsConstructedGenericMethod

動的クラスのメソッドまたはコンストラクターを定義し、表わします。

IsConstructedGenericMethod

動的クラスのメソッドまたはコンストラクターを定義し、表わします。

(継承元 MethodBase)
IsConstructor

メソッドがコンストラクターかどうかを示す値を取得します。

(継承元 MethodBase)
IsFamily

このメソッドまたはコンストラクターへの参照範囲が Family によって正しく示されるかどうかを表す値を取得します。ここで判定されるのは、メソッドまたはコンストラクターはそれらのクラスと派生クラスの内側でのみ参照できるものであることです。

(継承元 MethodBase)
IsFamilyAndAssembly

このメソッドまたはコンストラクターへの参照範囲が FamANDAssem によって示されるかどうかを表す値を取得します。ここで判定されるのは、メソッドまたはコンストラクターは派生クラスから呼び出すことができるが、それらが同じアセンブリ内にある場合に限るものであることです。

(継承元 MethodBase)
IsFamilyOrAssembly

このメソッドまたはコンストラクターを参照可能な範囲が FamORAssem によって示されるかどうかを表す値を取得します。ここで判定されるのは、メソッドまたはコンストラクターは任意の場所にある派生クラスと、同じアセンブリ内のクラスから呼び出すことができるものであることです。

(継承元 MethodBase)
IsFinal

このメソッドが final かどうかを示す値を取得します。

(継承元 MethodBase)
IsGenericMethod

メソッドがジェネリック メソッドかどうかを示す値を取得します。

IsGenericMethod

現在のメソッドがジェネリック メソッドかどうかを示す値を取得します。

(継承元 MethodInfo)
IsGenericMethodDefinition

現在の MethodBuilder オブジェクトがジェネリック メソッドの定義を表しているかどうかを示す値を取得します。

IsGenericMethodDefinition

現在の MethodInfo がジェネリック メソッドの定義を表しているかどうかを示す値を取得します。

(継承元 MethodInfo)
IsHideBySig

派生クラスで、正確に同じシグネチャを持つ同じ種類のメンバーだけが隠しメンバーになるかどうかを示す値を取得します。

(継承元 MethodBase)
IsPrivate

このメンバーがプライベートかどうかを示す値を取得します。

(継承元 MethodBase)
IsPublic

パブリック メソッドかどうかを示す値を取得します。

(継承元 MethodBase)
IsSecurityCritical

常に NotSupportedException をスローします。

IsSecurityCritical

現在のメソッドまたはコンストラクターが、現在の信頼レベルでセキュリティ クリティカルまたはセキュリティ セーフ クリティカルであり、重要な操作を実行できるかどうかを示す値を取得します。

(継承元 MethodBase)
IsSecuritySafeCritical

常に NotSupportedException をスローします。

IsSecuritySafeCritical

現在のメソッドまたはコンストラクターが、現在の信頼レベルでセキュリティ セーフ クリティカルであり、重要な操作を実行でき、透過的なコードからアクセスできるかどうかを示す値を取得します。

(継承元 MethodBase)
IsSecurityTransparent

常に NotSupportedException をスローします。

IsSecurityTransparent

現在のメソッドまたはコンストラクターが、現在の信頼レベルで透過的であり、重要な操作を実行できないかどうかを示す値を取得します。

(継承元 MethodBase)
IsSpecialName

特別な名前のメソッドかどうかを示す値を取得します。

(継承元 MethodBase)
IsStatic

メソッドが static であるかどうかを示す値を取得します。

(継承元 MethodBase)
IsVirtual

メソッドが virtual であるかどうかを示す値を取得します。

(継承元 MethodBase)
MemberType

このメンバーがメソッドであることを示す MemberTypes 値を取得します。

(継承元 MethodInfo)
MetadataToken

メタデータ内の現在の動的モジュールを識別するトークンを取得します。

MetadataToken

メタデータ要素を識別する値を取得します。

(継承元 MemberInfo)
MethodHandle

メソッドの内部ハンドルを取得します。 基になるメタデータ ハンドルにアクセスするには、このハンドルを使用します。

MethodHandle

メソッドの内部メタデータ表現を識別するハンドルを取得します。

(継承元 MethodBase)
MethodImplementationFlags

動的クラスのメソッドまたはコンストラクターを定義し、表わします。

MethodImplementationFlags

メソッド実装の属性を指定する MethodImplAttributes フラグを取得します。

(継承元 MethodBase)
Module

現在のメソッドが定義されているモジュールを取得します。

Module

現在の MemberInfo によって表されるメンバーを宣言する型が定義されているモジュールを取得します。

(継承元 MemberInfo)
Name

このメソッドの名前を取得します。

ReflectedType

このオブジェクトを取得するためにリフレクションで使用されたクラスを取得します。

ReflectedType

MemberInfo のこのインスタンスを取得するために使用したクラス オブジェクトを取得します。

(継承元 MemberInfo)
ReturnParameter

戻り値の型にカスタム修飾子があるかどうかなど、メソッドの戻り値の型に関する情報を格納している ParameterInfo オブジェクトを取得します。

ReturnParameter

戻り値の型にカスタム修飾子があるかどうかなど、メソッドの戻り値の型に関する情報を格納している ParameterInfo オブジェクトを取得します。

(継承元 MethodInfo)
ReturnType

この MethodBuilder によって表されるメソッドの戻り値の型を取得します。

ReturnType

このメソッドの戻り値の型を取得します。

(継承元 MethodInfo)
ReturnTypeCustomAttributes

メソッドの戻り値の型のカスタム属性を返します。

ReturnTypeCustomAttributes

戻り値の型のカスタム属性を取得します。

(継承元 MethodInfo)
Signature

メソッドの署名を取得します。

メソッド

AddDeclarativeSecurity(SecurityAction, PermissionSet)

このメソッドに宣言セキュリティを追加します。

CreateDelegate(Type)

このメソッドから、指定した型のデリゲートを作成します。

(継承元 MethodInfo)
CreateDelegate(Type, Object)

このメソッドから、指定した型のデリゲートを、指定したターゲットを使用して作成します。

(継承元 MethodInfo)
CreateDelegate<T>()

このメソッドから T 型のデリゲートを作成します。

(継承元 MethodInfo)
CreateDelegate<T>(Object)

このメソッドから、指定したターゲットを使用して、T 型のデリゲートを作成します。

(継承元 MethodInfo)
CreateMethodBody(Byte[], Int32)

Microsoft intermediate language (MSIL) の命令の指定されたバイト配列を使用して、メソッドの本体を作成します。

DefineGenericParameters(String[])

現在のメソッドのジェネリック型パラメーターの数を設定し、それらのパラメーターの名前を指定し、パラメーターの制約の定義に使用できる GenericTypeParameterBuilder オブジェクトの配列を返します。

DefineGenericParametersCore(String[])

派生クラスでオーバーライドされた場合は、現在のメソッドのジェネリック型パラメーターの数を設定し、その名前を指定し、制約を定義するために使用できるオブジェクトの GenericTypeParameterBuilder 配列を返します。

DefineParameter(Int32, ParameterAttributes, String)

パラメーター属性およびこのメソッドのパラメーターの名前、またはこのメソッドの戻り値の名前を設定します。 カスタム属性を適用するために使用できる ParameterBuilder を返します。

DefineParameterCore(Int32, ParameterAttributes, String)

派生クラスでオーバーライドされると、このメソッドのパラメーターまたは戻り値パラメーターを定義します。

Equals(Object)

指定したオブジェクトが、このインスタンスと等しいかどうかを判定します。

GetBaseDefinition()

メソッドの基本実装を返します。

GetBaseDefinition()

派生クラスによってオーバーライドされた場合、このインスタンスが表すメソッドが最初に宣言された直接または間接基本クラスで、そのメソッドの MethodInfo オブジェクトを返します。

(継承元 MethodInfo)
GetCustomAttributes(Boolean)

このメソッドの定義済みのカスタム属性をすべて返します。

GetCustomAttributes(Boolean)

派生クラスでオーバーライドされた場合、このメンバーに適用されているすべてのカスタム属性の配列を返します。

(継承元 MemberInfo)
GetCustomAttributes(Type, Boolean)

指定された型で識別されるカスタム属性を返します。

GetCustomAttributes(Type, Boolean)

派生クラスでオーバーライドされた場合は、このメンバーに適用され、Type によって識別されるカスタム属性の配列を返します。

(継承元 MemberInfo)
GetCustomAttributesData()

ターゲット メンバーに適用されている属性に関するデータを表す CustomAttributeData オブジェクトのリストを返します。

(継承元 MemberInfo)
GetGenericArguments()

メソッドの型パラメーターがジェネリックの場合、そのパラメーターを表す GenericTypeParameterBuilder オブジェクトの配列。

GetGenericArguments()

ジェネリック メソッドの型引数、またはジェネリック メソッドの定義の型パラメーターを表す Type オブジェクトの配列を返します。

(継承元 MethodInfo)
GetGenericMethodDefinition()

このメソッドを返します。

GetGenericMethodDefinition()

現在のメソッドを構築する元になるジェネリック メソッド定義を表す MethodInfo オブジェクトを返します。

(継承元 MethodInfo)
GetHashCode()

このメソッドのハッシュ コードを取得します。

GetILGenerator()

このメソッドの ILGenerator を返します。既定の Microsoft Intermediate Language (MSIL) のストリーム サイズは 64 バイトです。

GetILGenerator(Int32)

指定された Microsoft Intermediate Language (MSIL) のストリーム サイズにより、このメソッドの ILGenerator を返します。

GetILGeneratorCore(Int32)

派生クラスでオーバーライドされると、このメソッドの ILGenerator メソッド本体を出力するために使用できる を取得します。

GetMethodBody()

派生クラスでオーバーライドされると、現在のメソッドの MSIL ストリーム、ローカル変数、および例外にアクセスできるようにする MethodBody オブジェクトを取得します。

(継承元 MethodBase)
GetMethodImplementationFlags()

このメソッドの実装フラグを返します。

GetMethodImplementationFlags()

派生クラスでオーバーライドされると、新しい MethodImplAttributes フラグを返します。

(継承元 MethodBase)
GetModule()

このメソッドを含むモジュールへの参照を返します。

GetParameters()

このメソッドのパラメーターを返します。

GetToken()

このメソッドのトークンを表わす MethodToken を返します。

GetType()

メソッドの属性を取得し、メソッドのメタデータにアクセスできるようにします。

(継承元 MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)

動的クラスのメソッドまたはコンストラクターを定義し、表わします。

(継承元 MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)

指定されたバインダーの制約下で、指定されたパラメーターを渡しつつ、指定されたオブジェクトのこのインスタンスによって反映されるメソッドを動的に呼び出します。

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

派生クラスによってオーバーライドされた場合に、指定したパラメーターでリフレクションされたメソッドまたはコンストラクターを呼び出します。

(継承元 MethodBase)
Invoke(Object, Object[])

指定されたパラメーターを使用して、現在のインスタンスが表すメソッドまたはコンストラクターを呼び出します。

(継承元 MethodInfo)
IsDefined(Type, Boolean)

指定されたカスタム属性の型が定義されているかどうかを確認します。

IsDefined(Type, Boolean)

派生クラスでオーバーライドされた場合、このメンバーに、指定された型の属性またはその派生型の属性が 1 つ以上適用されているかどうかを示します。

(継承元 MemberInfo)
MakeGenericMethod(Type[])

指定したジェネリック型引数を使用して、現在のジェネリック メソッド定義から構築されたジェネリック メソッドを返します。

MakeGenericMethod(Type[])

現在のジェネリック メソッド定義の型パラメーターを型の配列要素に置き換え、その結果構築されるメソッドを表す MethodInfo オブジェクトを返します。

(継承元 MethodInfo)
MemberwiseClone()

現在の Object の簡易コピーを作成します。

(継承元 Object)
SetCustomAttribute(ConstructorInfo, Byte[])

指定されたカスタム属性の blob を使用して、カスタム属性を設定します。

SetCustomAttribute(CustomAttributeBuilder)

カスタム属性ビルダーを使用して、カスタム属性を設定します。

SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)

派生クラスでオーバーライドされた場合は、このアセンブリにカスタム属性を設定します。

SetImplementationFlags(MethodImplAttributes)

このメソッドの実装フラグを取得または設定します。

SetImplementationFlagsCore(MethodImplAttributes)

派生クラスでオーバーライドされた場合は、このメソッドの実装フラグを設定します。

SetMarshal(UnmanagedMarshal)
古い.

このメソッドの戻り値の型のマーシャリング情報を設定します。

SetMethodBody(Byte[], Int32, Byte[], IEnumerable<ExceptionHandler>, IEnumerable<Int32>)

Microsoft intermediate language (MSIL) の命令の指定したバイト配列を使用して、メソッドの本体を作成します。

SetParameters(Type[])

メソッドのパラメーターの数と型を設定します。

SetReturnType(Type)

メソッドの戻り値の型を設定します。

SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])

メソッドのシグネチャを設定します。それには、戻り値の型、パラメーターの型、および戻り値の型とパラメーター型の必須カスタム修飾子と省略可能カスタム修飾子が含まれます。

SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])

派生クラスでオーバーライドされた場合は、戻り値の型、パラメーター型、および戻り値の型とパラメーター型の必須および省略可能なカスタム修飾子を含むメソッド シグネチャを設定します。

SetSymCustomAttribute(String, Byte[])

blob を使用して、シンボリック カスタム属性を設定します。

ToString()

この MethodBuilder インスタンスを文字列として返します。

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

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

一連の名前を対応する一連のディスパッチ識別子に割り当てます。

(継承元 MemberInfo)
_MemberInfo.GetType()

Type クラスを表す MemberInfo オブジェクトを取得します。

(継承元 MemberInfo)
_MemberInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

オブジェクトの型情報を取得します。この型情報を使用して、インターフェイスの型情報を取得できます。

(継承元 MemberInfo)
_MemberInfo.GetTypeInfoCount(UInt32)

オブジェクトが提供する型情報インターフェイスの数 (0 または 1) を取得します。

(継承元 MemberInfo)
_MemberInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

オブジェクトによって公開されたプロパティおよびメソッドへのアクセスを提供します。

(継承元 MemberInfo)
_MethodBase.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

一連の名前を対応する一連のディスパッチ識別子に割り当てます。

(継承元 MethodBase)
_MethodBase.GetType()

このメンバーの詳細については、「GetType()」をご覧ください。

(継承元 MethodBase)
_MethodBase.GetTypeInfo(UInt32, UInt32, IntPtr)

オブジェクトの型情報を取得します。この型情報を使用して、インターフェイスの型情報を取得できます。

(継承元 MethodBase)
_MethodBase.GetTypeInfoCount(UInt32)

オブジェクトが提供する型情報インターフェイスの数 (0 または 1) を取得します。

(継承元 MethodBase)
_MethodBase.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

オブジェクトによって公開されたプロパティおよびメソッドへのアクセスを提供します。

(継承元 MethodBase)
_MethodBase.IsAbstract

このメンバーの詳細については、「IsAbstract」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsAssembly

このメンバーの詳細については、「IsAssembly」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsConstructor

このメンバーの詳細については、「IsConstructor」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsFamily

このメンバーの詳細については、「IsFamily」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsFamilyAndAssembly

このメンバーの詳細については、「IsFamilyAndAssembly」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsFamilyOrAssembly

このメンバーの詳細については、「IsFamilyOrAssembly」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsFinal

このメンバーの詳細については、「IsFinal」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsHideBySig

このメンバーの詳細については、「IsHideBySig」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsPrivate

このメンバーの詳細については、「IsPrivate」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsPublic

このメンバーの詳細については、「IsPublic」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsSpecialName

このメンバーの詳細については、「IsSpecialName」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsStatic

このメンバーの詳細については、「IsStatic」をご覧ください。

(継承元 MethodBase)
_MethodBase.IsVirtual

このメンバーの詳細については、「IsVirtual」をご覧ください。

(継承元 MethodBase)
_MethodBuilder.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

一連の名前を対応する一連のディスパッチ識別子に割り当てます。

_MethodBuilder.GetTypeInfo(UInt32, UInt32, IntPtr)

オブジェクトの型情報を取得します。この型情報を使用して、インターフェイスの型情報を取得できます。

_MethodBuilder.GetTypeInfoCount(UInt32)

オブジェクトが提供する型情報インターフェイスの数 (0 または 1) を取得します。

_MethodBuilder.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

オブジェクトによって公開されたプロパティおよびメソッドへのアクセスを提供します。

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

一連の名前を対応する一連のディスパッチ識別子に割り当てます。

(継承元 MethodInfo)
_MethodInfo.GetType()

COM から GetType() メソッドにアクセスできるようにします。

(継承元 MethodInfo)
_MethodInfo.GetTypeInfo(UInt32, UInt32, IntPtr)

オブジェクトの型情報を取得します。この情報はインターフェイスの型情報の取得に使用できます。

(継承元 MethodInfo)
_MethodInfo.GetTypeInfoCount(UInt32)

オブジェクトが提供する型情報インターフェイスの数 (0 または 1) を取得します。

(継承元 MethodInfo)
_MethodInfo.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

オブジェクトによって公開されたプロパティおよびメソッドへのアクセスを提供します。

(継承元 MethodInfo)
ICustomAttributeProvider.GetCustomAttributes(Boolean)

名前付きの属性を除く、このメンバーに定義されているすべてのカスタム属性の配列、またはカスタム属性がない場合は空の配列を返します。

(継承元 MemberInfo)
ICustomAttributeProvider.GetCustomAttributes(Type, Boolean)

型で識別された、このメンバーに定義されているカスタム属性の配列、または、この型のカスタム属性がない場合は空の配列を返します。

(継承元 MemberInfo)
ICustomAttributeProvider.IsDefined(Type, Boolean)

attributeType の 1 つ以上のインスタンスがこのメンバーで定義されているかどうかを示します。

(継承元 MemberInfo)

拡張メソッド

GetCustomAttribute(MemberInfo, Type)

指定したメンバーに適用される指定した型のカスタム属性を取得します。

GetCustomAttribute(MemberInfo, Type, Boolean)

指定したメンバーに適用される指定した型のカスタム属性を取得し、オプションでそのメンバーの先祖を調べます。

GetCustomAttribute<T>(MemberInfo)

指定したメンバーに適用される指定した型のカスタム属性を取得します。

GetCustomAttribute<T>(MemberInfo, Boolean)

指定したメンバーに適用される指定した型のカスタム属性を取得し、オプションでそのメンバーの先祖を調べます。

GetCustomAttributes(MemberInfo)

指定されたメンバーに適用されるカスタム属性のコレクションを取得します。

GetCustomAttributes(MemberInfo, Boolean)

指定されたメンバーに適用されるカスタム属性のコレクションを取得し、オプションでそのメンバーの先祖を調べます。

GetCustomAttributes(MemberInfo, Type)

指定されたメンバーに適用される指定された型のカスタム属性のコレクションを取得します。

GetCustomAttributes(MemberInfo, Type, Boolean)

指定されたメンバーに適用されている指定された型のカスタム属性のコレクションを取得し、オプションでそのメンバーの先祖を調べます。

GetCustomAttributes<T>(MemberInfo)

指定されたメンバーに適用される指定された型のカスタム属性のコレクションを取得します。

GetCustomAttributes<T>(MemberInfo, Boolean)

指定されたメンバーに適用されている指定された型のカスタム属性のコレクションを取得し、オプションでそのメンバーの先祖を調べます。

IsDefined(MemberInfo, Type)

指定された型のカスタム属性が指定されたメンバーに適用されているかどうかを示します。

IsDefined(MemberInfo, Type, Boolean)

指定された型のカスタム属性が指定されたメンバーに適用され、オプションで先祖に適用されているかどうかを示します。

GetMetadataToken(MemberInfo)

指定されたメンバーのメタデータ トークンを取得します (存在する場合)。

HasMetadataToken(MemberInfo)

指定されたメンバーに対してメタデータ トークンを使用できるかどうかを示す値を返します。

GetBaseDefinition(MethodInfo)

動的クラスのメソッドまたはコンストラクターを定義し、表わします。

GetRuntimeBaseDefinition(MethodInfo)

メソッドが最初に宣言された直接基本クラスまたは間接基本クラスの指定したメソッドを表すオブジェクトを取得します。

適用対象