MethodBuilder クラスとは何？わかりやすく解説 Weblio辞書

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

MethodBuilder クラス

動的クラスのメソッド (またはコンストラクタ) を定義および表現します。

名前空間: System.Reflection.Emit
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

<ClassInterfaceAttribute(ClassInterfaceType.None)> _
<ComVisibleAttribute(True)> _
Public NotInheritable Class
 MethodBuilder
    Inherits MethodInfo
    Implements _MethodBuilder

Visual Basic (使用法)

Dim instance As MethodBuilder

[ClassInterfaceAttribute(ClassInterfaceType.None)] 
[ComVisibleAttribute(true)] 
public sealed class MethodBuilder : MethodInfo,
 _MethodBuilder

C++

[ClassInterfaceAttribute(ClassInterfaceType::None)] 
[ComVisibleAttribute(true)] 
public ref class MethodBuilder sealed : public
 MethodInfo, _MethodBuilder

/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */ 
/** @attribute ComVisibleAttribute(true) */ 
public final class MethodBuilder extends MethodInfo
 implements _MethodBuilder

JScript

ClassInterfaceAttribute(ClassInterfaceType.None) 
ComVisibleAttribute(true) 
public final class MethodBuilder extends
 MethodInfo implements _MethodBuilder

解説

メモ
このクラスに適用される HostProtectionAttribute 属性の Resources プロパティの値は、MayLeakOnAbort です。HostProtectionAttribute は、デスクトップアプリケーション (一般的には、アイコンをダブルクリック、コマンドを入力、またはブラウザに URL を入力して起動するアプリケーション) には影響しません。詳細については、HostProtectionAttribute クラスのトピックまたは「SQL Server プログラミングとホスト保護属性」を参照してください。

メモ

このクラスに適用される HostProtectionAttribute 属性の Resources プロパティの値は、MayLeakOnAbort です。HostProtectionAttribute は、デスクトップアプリケーション (一般的には、アイコンをダブルクリック、コマンドを入力、またはブラウザに URL を入力して起動するアプリケーション) には影響しません。詳細については、HostProtectionAttribute クラスのトピックまたは「SQL Server プログラミングとホスト保護属性」を参照してください。

MethodBuilder を使用して、MSIL (Microsoft Intermediate Language) のメソッドを完全に記述します。名前、属性、シグネチャ、メソッド本体が含まれます。TypeBuilder クラスと組み合わせて使用され、実行時にクラスを作成します。

使用例

MethodBuilder クラスを使用して、動的な型の中にメソッドを作成する方法を次の例に示します。

Visual Basic

Imports System
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _


Class DemoMethodBuilder
   
   Public Shared Sub AddMethodDynamically(ByRef
 myTypeBld As TypeBuilder, _
                        mthdName As String,
 _
                            mthdParams() As Type, _
                            returnType As Type, _
                            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 'AddMethodDynamically
    
   
   Public Shared Sub Main()
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim asmName As New
 AssemblyName()
      asmName.Name = "DynamicAssembly1"
      
      Dim myAsmBuilder As AssemblyBuilder =
 myDomain.DefineDynamicAssembly(asmName, _
                        AssemblyBuilderAccess.RunAndSave)
      
      Dim myModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("DynamicModule1",
 _
                                       "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 or [M]ultiply these
 numbers? ")
      Dim myMthdAction As String
 = Console.ReadLine()
      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 = "A" Then
     description = "adding"
      Else
     description = "multiplying"
      End If

      Console.WriteLine("---")
      Console.WriteLine("The result of {0} the inputted 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 'Main 
End Class 'DemoMethodBuilder

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


class DemoMethodBuilder {

    public static void AddMethodDynamically
 (ref 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 = Thread.GetDomain();
       AssemblyName asmName = new AssemblyName();
       asmName.Name = "DynamicAssembly1";
    
       AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                      asmName, 
                      AssemblyBuilderAccess.RunAndSave);

          ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule("DynamicModule1"
,
                                        "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 or [M]ultiply these numbers? ");
       string myMthdAction = Console.ReadLine();
       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(ref myTypeBld,
                myMthdName,
                myMthdParams,
                typeof(int),    
                myMthdAction);

       Type myType = myTypeBld.CreateType();

       Console.WriteLine("---");
       Console.WriteLine("The result of {0} the inputted values is: {1}"
,
                 ((myMthdAction == "A") ? "adding" : "multiplying")
,
                 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());
 
    
    }

}

C++

using namespace System;
using namespace System::Threading;
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::Mul );

      }
   }

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

int main()
{
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ asmName = gcnew AssemblyName;
   asmName->Name = "DynamicAssembly1";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( asmName, AssemblyBuilderAccess::RunAndSave
 );
   ModuleBuilder^ myModule = myAsmBuilder->DefineDynamicModule( "DynamicModule1",
 "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 or [M]ultiply these numbers? "
 );
   String^ myMthdAction = Console::ReadLine();
   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( 0 );
   array<Type^>^myMthdParams = gcnew array<Type^>(inputNumsList->Length);
   array<Object^>^inputValsList = gcnew array<Object^>(inputNumsList->Length);
   System::Collections::IEnumerator^ myEnum = inputNumsList->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ inputNum = safe_cast<String^>(myEnum->Current);
      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( "A" )) ? (String^)"adding" : "multiplying"),
 myType->InvokeMember( myMthdName, static_cast<BindingFlags>(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 );
}

import System.*;
import System.Threading.*;
import System.Reflection.*;
import 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 (ubyte 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") == true)
 {
                    iLout.Emit(OpCodes.Add);
                }
                else if (mthdAction.Equals("M")
 == true) {
                    iLout.Emit(OpCodes.Mul);
                }
                else {
                    iLout.Emit(OpCodes.Add);
                }
            }
        }
        iLout.Emit(OpCodes.Ret);
    } //AddMethodDynamically
 
    public static void main(String[]
 args)
    {
        AppDomain myDomain = System.Threading.Thread.GetDomain();
        AssemblyName asmName = new AssemblyName();
        asmName.set_Name("DynamicAssembly1");
        AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(asmName,
            AssemblyBuilderAccess.RunAndSave);
        ModuleBuilder myModule = myAsmBuilder.DefineDynamicModule
            ("DynamicModule1", "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 or [M]ultiply these numbers? ");
        String myMthdAction = Console.ReadLine();
        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(null);
        Type myMthdParams[] = new Type[inputNumsList.length];
        Object inputValsList[] = new Object[inputNumsList.length];
        for (int iCtr = 0; iCtr < inputNumsList.length;
 iCtr++) {
            String inputNum = inputNumsList[iCtr];
            inputValsList[index] = (Object)(Int32)Integer.parseInt(inputNum);
            myMthdParams.set_Item(index, int.class.ToType());
            index++;
        }

        // Now, call the method building method with the parameters
,
        // passing the TypeBuilder by reference.
        AddMethodDynamically(myTypeBld, myMthdName, myMthdParams,
            int.class.ToType(), myMthdAction);
        Type myType = myTypeBld.CreateType();
        Console.WriteLine("---");
        Console.WriteLine("The result of {0} the inputted values is: {1}"
,
            (myMthdAction.equals("A")) ? "adding" : "multiplying"
,
            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 the method
 you provided 
        // during execution.
        myAsmBuilder.Save("MyDynamicAsm.dll");
        MethodInfo myMthdInfo = myType.GetMethod(myMthdName);
        Console.WriteLine("Your Dynamic Method: {0};", myMthdInfo.ToString());
    } //main 
} //DemoMethodBuilder

継承階層

System.Object
   System.Reflection.MemberInfo
     System.Reflection.MethodBase
       System.Reflection.MethodInfo
        System.Reflection.Emit.MethodBuilder

スレッドセーフ

この型の public static (Visual Basic では Shared) メンバはすべて、スレッドセーフです。インスタンスメンバの場合は、スレッドセーフであるとは限りません。