MethodBuilder.CreateMethodBody メソッドとは何？わかりやすく解説 Weblio辞書

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

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

MethodBuilder.CreateMethodBody メソッド

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

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

Visual Basic (宣言)

Public Sub CreateMethodBody ( _
    il As Byte(), _
    count As Integer _
)

Visual Basic (使用法)

Dim instance As MethodBuilder
Dim il As Byte()
Dim count As Integer

instance.CreateMethodBody(il, count)

public void CreateMethodBody (
    byte[] il,
    int count
)

C++

public:
void CreateMethodBody (
    array<unsigned char>^ il, 
    int count
)

public void CreateMethodBody (
    byte[] il, 
    int count
)

JScript

public function CreateMethodBody (
    il : byte[], 
    count : int
)

パラメータ

il: 有効な MSIL 命令を格納している配列。このパラメータが null 参照 (Visual Basic では Nothing) の場合は、メソッドの本体が消去されます。

count: MSIL 配列の有効なバイト数。この値は、MSIL が null 参照 (Visual Basic では Nothing) の場合は無視されます。

例外

例外の種類	条件
ArgumentOutOfRangeException	count が指定した MSIL 命令の配列のインデックス範囲外であり、il が null 参照 (Visual Basic では Nothing) ではありません。
InvalidOperationException	外側の型が CreateType を使用して作成されています。またはこのメソッドは、null 参照 (Visual Basic では Nothing) ではない引数 il を使用して、この MethodBuilder に対して以前に呼び出されました。または現在のメソッドでは、IsGenericMethod プロパティは true ですが、IsGenericMethodDefinition プロパティが false です。

例外の種類

条件

ArgumentOutOfRangeException

count が指定した MSIL 命令の配列のインデックス範囲外であり、il が null 参照 (Visual Basic では Nothing) ではありません。

InvalidOperationException

外側の型が CreateType を使用して作成されています。

または

このメソッドは、null 参照 (Visual Basic では Nothing) ではない引数 il を使用して、この MethodBuilder に対して以前に呼び出されました。

または

現在のメソッドでは、IsGenericMethod プロパティは true ですが、IsGenericMethodDefinition プロパティが false です。

解説

このメソッドは、MSIL 命令を格納している配列 il からメソッドの本体を作成します。有効な MSIL のバイト数を count で指定します。

メモ
現在、このメソッドは完全にはサポートされていません。ユーザーは、トークン修復の位置および例外ハンドラを提供できません。

使用例

CreateMethodBody を使用して、2 つの整数を加算する単純なメソッドをオペコードを通じて生成する例を次に示します。

Visual Basic

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

 _

Class MethodBodyDemo
   
   ' This class will demonstrate how to create a method body using 
   ' the MethodBuilder.CreateMethodBody(byte[], int) method.

   Public Shared Function
 BuildDynType() As Type
      
      Dim addType As Type = Nothing
      
      Dim currentDom As AppDomain = Thread.GetDomain()
      
      Dim myAsmName As New
 AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBldr As AssemblyBuilder = currentDom.DefineDynamicAssembly(myAsmName,
 _
                         AssemblyBuilderAccess.RunAndSave)
      
      ' The dynamic assembly space has been created.  Next, create a
 module
      ' within it.  The type Point will be reflected into this module.
      Dim myModuleBldr As ModuleBuilder = myAsmBldr.DefineDynamicModule("MyModule")
      
      Dim myTypeBldr As TypeBuilder = myModuleBldr.DefineType("Adder")
      
      Dim myMthdBldr As MethodBuilder = myTypeBldr.DefineMethod("DoAdd",
 _
                    MethodAttributes.Public Or MethodAttributes.Static,
 _
                        GetType(Integer), _
                    New Type() {GetType(Integer),
 GetType(Integer)})

      ' Build the array of Bytes holding the MSIL instructions.

      Dim ILcodes() As Byte
 = {&H2, &H3, &H58, &H2A}

      ' 02h is the opcode for ldarg.0 
      ' 03h is the opcode for ldarg.1 
      ' 58h is the opcode for add     
      ' 2Ah is the opcode for ret     
      
      myMthdBldr.CreateMethodBody(ILcodes, ILcodes.Length)
      
      addType = myTypeBldr.CreateType()
      
      Return addType

   End Function 'BuildDynType
   
   
   Public Shared Sub Main()
      
      Dim myType As Type = BuildDynType()
      Console.WriteLine("---")
      Console.Write("Enter the first integer to add: ")
      Dim aVal As Integer
 = Convert.ToInt32(Console.ReadLine())
      
      Console.Write("Enter the second integer to add: ")
      Dim bVal As Integer
 = Convert.ToInt32(Console.ReadLine())
      
      Dim adderInst As Object
 = Activator.CreateInstance(myType, New Object()
 {})
      
      Console.WriteLine("The value of adding {0} to {1} is: {2}.",
 _
             aVal, bVal, _
             myType.InvokeMember("DoAdd", _
                          BindingFlags.InvokeMethod, _
                          Nothing, _
                          adderInst, _
                          New Object() {aVal,
 bVal}))

   End Sub 'Main

End Class 'MethodBodyDemo

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

class MethodBodyDemo {
// This class will demonstrate how to create a method body using 
// the MethodBuilder.CreateMethodBody(byte[], int) method.

   public static Type BuildDynType() {
    
      Type addType = null;

        AppDomain currentDom = Thread.GetDomain();

        AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

        AssemblyBuilder myAsmBldr = currentDom.DefineDynamicAssembly(
                           myAsmName,
                           AssemblyBuilderAccess.RunAndSave);

        // The dynamic assembly space has been created.  Next, create
 a module
        // within it.  The type Point will be reflected into this module.

    ModuleBuilder myModuleBldr = myAsmBldr.DefineDynamicModule("MyModule");
      
    TypeBuilder myTypeBldr =  myModuleBldr.DefineType("Adder");

        MethodBuilder myMthdBldr = myTypeBldr.DefineMethod("DoAdd",
                                MethodAttributes.Public |
                                MethodAttributes.Static,
                                typeof(int),
                                new Type[] 
                                {typeof(int), typeof(int)});
        // Build the array of Bytes holding the MSIL instructions.

        byte[] ILcodes = new byte[] {
          0x02,   /* 02h is the opcode for ldarg.0 */
      0x03,   /* 03h is the opcode for ldarg.1 */
      0x58,   /* 58h is the opcode for add     */
      0x2A    /* 2Ah is the opcode for ret     */
    };
    
    myMthdBldr.CreateMethodBody(ILcodes, ILcodes.Length);

        addType = myTypeBldr.CreateType();

    return addType;
   }

   public static void Main()
 {

    Type myType = BuildDynType(); 
        Console.WriteLine("---");
    Console.Write("Enter the first integer to add: "); 
        int aVal = Convert.ToInt32(Console.ReadLine());
     
         Console.Write("Enter the second integer to add: ");
         int bVal = Convert.ToInt32(Console.ReadLine());
   
         object adderInst = Activator.CreateInstance(myType, new
 object[0]); 

    Console.WriteLine("The value of adding {0} to {1} is: {2}.",
               aVal, bVal,    
                    myType.InvokeMember("DoAdd",
                             BindingFlags.InvokeMethod,
                             null,
                             adderInst,
                             new object[] {aVal, bVal})); 
   }

}

C++

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
class MethodBodyDemo
{
public:

   // This class will demonstrate how to create a method body using
   // the MethodBuilder::CreateMethodBody(Byte[], int) method.
   static Type^ BuildDynType()
   {
      Type^ addType = nullptr;
      AppDomain^ currentDom = Thread::GetDomain();
      AssemblyName^ myAsmName = gcnew AssemblyName;
      myAsmName->Name = "MyDynamicAssembly";
      AssemblyBuilder^ myAsmBldr = currentDom->DefineDynamicAssembly( myAsmName,
 AssemblyBuilderAccess::RunAndSave );
      
      // The dynamic assembly space has been created.  Next, create
 a module
      // within it.  The type Point will be reflected into this module.
      ModuleBuilder^ myModuleBldr = myAsmBldr->DefineDynamicModule( "MyModule"
 );
      TypeBuilder^ myTypeBldr = myModuleBldr->DefineType( "Adder" );
      array<Type^>^temp0 = {int::typeid,int::typeid};
      MethodBuilder^ myMthdBldr = myTypeBldr->DefineMethod( "DoAdd",
 static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static),
 int::typeid, temp0 );
      
      // Build the array of Bytes holding the MSIL instructions.
      
      /* 02h is the opcode for ldarg.0 */
      /* 03h is the opcode for ldarg.1 */
      /* 58h is the opcode for add     */
      /* 2Ah is the opcode for ret     */
      array<Byte>^temp1 = {0x02,0x03,0x58,0x2A};
      array<Byte>^ILcodes = temp1;
      myMthdBldr->CreateMethodBody( ILcodes, ILcodes->Length );
      addType = myTypeBldr->CreateType();
      return addType;
   }

};

int main()
{
   Type^ myType = MethodBodyDemo::BuildDynType();
   Console::WriteLine( "---" );
   Console::Write( "Enter the first integer to add: " );
   int aVal = Convert::ToInt32( Console::ReadLine() );
   Console::Write( "Enter the second integer to add: " );
   int bVal = Convert::ToInt32( Console::ReadLine() );
   Object^ adderInst = Activator::CreateInstance( myType, gcnew array<Object^>(0)
 );
   array<Object^>^temp1 = {aVal,bVal};
   Console::WriteLine( "The value of adding {0} to {1} is: {2}.", aVal,
 bVal, myType->InvokeMember( "DoAdd", BindingFlags::InvokeMethod, nullptr,
 adderInst, temp1 ) );
}