MethodBuilder.CreateMethodBody メソッド

2008-03-28

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

Public Sub CreateMethodBody( _
   ByVal il() As Byte, _   ByVal count As Integer _)
[C#]
public void CreateMethodBody(byte[] il,intcount);
[C++]
public: void CreateMethodBody(unsigned charil __gc[],intcount);
[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 で呼び出されています。

ArgumentOutOfRangeException

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

InvalidOperationException

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

または

このメソッドが、既に非 null 参照 (Visual Basic では Nothing) の引数 il を使用してこの MethodBuilder で呼び出されています。

解説

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

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

使用例

[Visual Basic, C#, C++] CreateMethodBody を使用して、2 つの整数値を加算する単純な動的メソッドをオペコードを通じて生成する例を次に示します。

 
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



[C#] 

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 <mscorlib.dll>

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace 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 = 0;

      AppDomain*  currentDom = Thread::GetDomain();

      AssemblyName* myAsmName = new AssemblyName();
      myAsmName->Name = S"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(S"MyModule");

      TypeBuilder*  myTypeBldr =  myModuleBldr->DefineType(S"Adder");

      Type* temp0 [] = {__typeof(int), __typeof(int)};
      MethodBuilder*  myMthdBldr = myTypeBldr->DefineMethod(
         S"DoAdd",
         static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static),
         __typeof(int),
         temp0);
      // Build the array of Bytes holding the MSIL instructions.

      Byte temp1 [] = {
         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     */
      };
      Byte ILcodes [] = temp1;

      myMthdBldr->CreateMethodBody(ILcodes, ILcodes->Length);

      addType = myTypeBldr->CreateType();

      return addType;
   }
};

int main() {

   Type*  myType = MethodBodyDemo::BuildDynType();
   Console::WriteLine(S"---");
   Console::Write(S"Enter the first integer to add: ");
   int aVal = Convert::ToInt32(Console::ReadLine());

   Console::Write(S"Enter the second integer to add: ");
   int bVal = Convert::ToInt32(Console::ReadLine());

   Object* adderInst = Activator::CreateInstance(myType, new Object*[0]);

   Object* temp1 [] = {__box(aVal), __box(bVal)};
   Console::WriteLine(S"The value of adding {0} to {1} is: {2}.", __box(aVal), __box(bVal),
      myType->InvokeMember(S"DoAdd", BindingFlags::InvokeMethod, 0, adderInst, temp1));
}

[JScript] JScript のサンプルはありません。Visual Basic、C#、および C++ のサンプルを表示するには、このページの左上隅にある言語のフィルタボタンをクリックします。

必要条件

プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ

参照

MethodBuilder クラス | MethodBuilder メンバ | System.Reflection.Emit 名前空間

次の方法で共有

MethodBuilder.CreateMethodBody メソッド

パラメータ

例外

解説

使用例

必要条件

参照

その他のリソース