MethodBuilder クラス

定義

名前空間:

System.Reflection.Emit

アセンブリ:

System.Reflection.Emit.dll

ソース:

MethodBuilder.cs

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

public ref class MethodBuilder abstract : System::Reflection::MethodInfo

public abstract class MethodBuilder : System.Reflection.MethodInfo

type MethodBuilder = class
    inherit MethodInfo

Public MustInherit Class MethodBuilder
Inherits MethodInfo

継承

Object

MemberInfo

MethodBase

MethodInfo

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	この型ではサポートされていません。
CustomAttributes	このメンバーのカスタム属性を含むコレクションを取得します。 (継承元 MemberInfo)
DeclaringType	このメソッドを宣言する型を返します。
InitLocals	このメソッドのローカル変数をゼロに初期化するかどうかを指定するブール値を取得または設定します。 このプロパティの既定値は true です。
InitLocalsCore	派生クラスでオーバーライドされた場合、このメソッドのローカル変数がゼロ初期化されているかどうかを示す値を取得または設定します。
IsAbstract	メソッドが抽象メソッドかどうかを示す値を取得します。 (継承元 MethodBase)
IsAssembly	このメソッドまたはコンストラクターを参照できる範囲が Assembly によって示されるかどうかを表す値を取得します。ここで判定されるのは、このメソッドまたはコンストラクターが同じアセンブリ内の他の型でのみ参照でき、アセンブリ外部の派生型では参照できないものであることです。 (継承元 MethodBase)
IsCollectible	この MemberInfo オブジェクトが、収集可能な AssemblyLoadContext に保持されているアセンブリの一部であるかどうかを示す値を取得します。 (継承元 MemberInfo)
IsConstructedGenericMethod	動的クラスのメソッドまたはコンストラクターを定義し、表わします。 (継承元 MethodBase)
IsConstructor	メソッドがコンストラクターかどうかを示す値を取得します。 (継承元 MethodBase)
IsFamily	このメソッドまたはコンストラクターへの参照範囲が Family によって正しく示されるかどうかを表す値を取得します。ここで判定されるのは、メソッドまたはコンストラクターはそれらのクラスと派生クラスの内側でのみ参照できるものであることです。 (継承元 MethodBase)
IsFamilyAndAssembly	このメソッドまたはコンストラクターへの参照範囲が FamANDAssem によって示されるかどうかを表す値を取得します。ここで判定されるのは、メソッドまたはコンストラクターは派生クラスから呼び出すことができるが、それらが同じアセンブリ内にある場合に限るものであることです。 (継承元 MethodBase)
IsFamilyOrAssembly	このメソッドまたはコンストラクターを参照可能な範囲が FamORAssem によって示されるかどうかを表す値を取得します。ここで判定されるのは、メソッドまたはコンストラクターは任意の場所にある派生クラスと、同じアセンブリ内のクラスから呼び出すことができるものであることです。 (継承元 MethodBase)
IsFinal	このメソッドが final かどうかを示す値を取得します。 (継承元 MethodBase)
IsGenericMethod	メソッドがジェネリック メソッドかどうかを示す値を取得します。
IsGenericMethodDefinition	現在の MethodBuilder オブジェクトがジェネリック メソッドの定義を表しているかどうかを示す値を取得します。
IsHideBySig	派生クラスで、正確に同じシグネチャを持つ同じ種類のメンバーだけが隠しメンバーになるかどうかを示す値を取得します。 (継承元 MethodBase)
IsPrivate	このメンバーがプライベートかどうかを示す値を取得します。 (継承元 MethodBase)
IsPublic	パブリック メソッドかどうかを示す値を取得します。 (継承元 MethodBase)
IsSecurityCritical	常に NotSupportedException をスローします。
IsSecuritySafeCritical	常に NotSupportedException をスローします。
IsSecurityTransparent	常に NotSupportedException をスローします。
IsSpecialName	特別な名前のメソッドかどうかを示す値を取得します。 (継承元 MethodBase)
IsStatic	メソッドが static であるかどうかを示す値を取得します。 (継承元 MethodBase)
IsVirtual	メソッドが virtual であるかどうかを示す値を取得します。 (継承元 MethodBase)
MemberType	このメンバーがメソッドであることを示す MemberTypes 値を取得します。 (継承元 MethodInfo)
MetadataToken	メタデータ内の現在の動的モジュールを識別するトークンを取得します。
MethodHandle	メソッドの内部ハンドルを取得します。 基になるメタデータ ハンドルにアクセスするには、このハンドルを使用します。
MethodImplementationFlags	メソッド実装の属性を指定する MethodImplAttributes フラグを取得します。 (継承元 MethodBase)
Module	現在のメソッドが定義されているモジュールを取得します。
Name	このメソッドの名前を取得します。
ReflectedType	このオブジェクトを取得するためにリフレクションで使用されたクラスを取得します。
ReturnParameter	戻り値の型にカスタム修飾子があるかどうかなど、メソッドの戻り値の型に関する情報を格納している ParameterInfo オブジェクトを取得します。
ReturnType	この MethodBuilder によって表されるメソッドの戻り値の型を取得します。
ReturnTypeCustomAttributes	メソッドの戻り値の型のカスタム属性を返します。

メソッド

CreateDelegate(Type)	このメソッドから、指定した型のデリゲートを作成します。 (継承元 MethodInfo)
CreateDelegate(Type, Object)	このメソッドから、指定した型のデリゲートを、指定したターゲットを使用して作成します。 (継承元 MethodInfo)
CreateDelegate<T>()	このメソッドから T 型のデリゲートを作成します。 (継承元 MethodInfo)
CreateDelegate<T>(Object)	このメソッドから、指定したターゲットを使用して、T 型のデリゲートを作成します。 (継承元 MethodInfo)
DefineGenericParameters(String[])	現在のメソッドのジェネリック型パラメーターの数を設定し、それらのパラメーターの名前を指定し、パラメーターの制約の定義に使用できる GenericTypeParameterBuilder オブジェクトの配列を返します。
DefineGenericParametersCore(String[])	派生クラスでオーバーライドされた場合は、現在のメソッドのジェネリック型パラメーターの数を設定し、その名前を指定し、制約を定義するために使用できるオブジェクトの GenericTypeParameterBuilder 配列を返します。
DefineParameter(Int32, ParameterAttributes, String)	パラメーター属性およびこのメソッドのパラメーターの名前、またはこのメソッドの戻り値の名前を設定します。 カスタム属性を適用するために使用できる ParameterBuilder を返します。
DefineParameterCore(Int32, ParameterAttributes, String)	派生クラスでオーバーライドされると、このメソッドのパラメーターまたは戻り値パラメーターを定義します。
Equals(Object)	指定したオブジェクトが、このインスタンスと等しいかどうかを判定します。
GetBaseDefinition()	メソッドの基本実装を返します。
GetCustomAttributes(Boolean)	このメソッドの定義済みのカスタム属性をすべて返します。
GetCustomAttributes(Type, Boolean)	指定された型で識別されるカスタム属性を返します。
GetCustomAttributesData()	ターゲット メンバーに適用されている属性に関するデータを表す CustomAttributeData オブジェクトのリストを返します。 (継承元 MemberInfo)
GetGenericArguments()	メソッドの型パラメーターがジェネリックの場合、そのパラメーターを表す GenericTypeParameterBuilder オブジェクトの配列。
GetGenericMethodDefinition()	このメソッドを返します。
GetHashCode()	このメソッドのハッシュ コードを取得します。
GetILGenerator()	このメソッドの ILGenerator を返します。既定の Microsoft Intermediate Language (MSIL) のストリーム サイズは 64 バイトです。
GetILGenerator(Int32)	指定された Microsoft Intermediate Language (MSIL) のストリーム サイズにより、このメソッドの ILGenerator を返します。
GetILGeneratorCore(Int32)	派生クラスでオーバーライドされると、このメソッドの ILGenerator メソッド本体を出力するために使用できる を取得します。
GetMethodBody()	派生クラスでオーバーライドされると、現在のメソッドの MSIL ストリーム、ローカル変数、および例外にアクセスできるようにする MethodBody オブジェクトを取得します。 (継承元 MethodBase)
GetMethodImplementationFlags()	このメソッドの実装フラグを返します。
GetParameters()	このメソッドのパラメーターを返します。
GetType()	メソッドの属性を取得し、メソッドのメタデータにアクセスできるようにします。 (継承元 MethodInfo)
HasSameMetadataDefinitionAs(MemberInfo)	動的クラスのメソッドまたはコンストラクターを定義し、表わします。 (継承元 MemberInfo)
Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)	指定されたバインダーの制約下で、指定されたパラメーターを渡しつつ、指定されたオブジェクトのこのインスタンスによって反映されるメソッドを動的に呼び出します。
Invoke(Object, Object[])	指定されたパラメーターを使用して、現在のインスタンスが表すメソッドまたはコンストラクターを呼び出します。 (継承元 MethodInfo)
IsDefined(Type, Boolean)	指定されたカスタム属性の型が定義されているかどうかを確認します。
MakeGenericMethod(Type[])	指定したジェネリック型引数を使用して、現在のジェネリック メソッド定義から構築されたジェネリック メソッドを返します。
MemberwiseClone()	現在の Object の簡易コピーを作成します。 (継承元 Object)
SetCustomAttribute(ConstructorInfo, Byte[])	指定されたカスタム属性の blob を使用して、カスタム属性を設定します。
SetCustomAttribute(CustomAttributeBuilder)	カスタム属性ビルダーを使用して、カスタム属性を設定します。
SetCustomAttributeCore(ConstructorInfo, ReadOnlySpan<Byte>)	派生クラスでオーバーライドされた場合は、このアセンブリにカスタム属性を設定します。
SetImplementationFlags(MethodImplAttributes)	このメソッドの実装フラグを取得または設定します。
SetImplementationFlagsCore(MethodImplAttributes)	派生クラスでオーバーライドされた場合は、このメソッドの実装フラグを設定します。
SetParameters(Type[])	メソッドのパラメーターの数と型を設定します。
SetReturnType(Type)	メソッドの戻り値の型を設定します。
SetSignature(Type, Type[], Type[], Type[], Type[][], Type[][])	メソッドのシグネチャを設定します。それには、戻り値の型、パラメーターの型、および戻り値の型とパラメーター型の必須カスタム修飾子と省略可能カスタム修飾子が含まれます。
SetSignatureCore(Type, Type[], Type[], Type[], Type[][], Type[][])	派生クラスでオーバーライドされた場合は、戻り値の型、パラメーター型、および戻り値の型とパラメーター型の必須および省略可能なカスタム修飾子を含むメソッド シグネチャを設定します。
ToString()	この MethodBuilder インスタンスを文字列として返します。

拡張メソッド

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