Freigeben über

MethodBuilder.CreateMethodBody-Methode

  • Artikel

Erstellt den Methodenkörper unter Verwendung eines angegebenen Bytearrays von MSIL-Anweisungen (Microsoft Intermediate Language).

Namespace: System.Reflection.Emit
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Sub CreateMethodBody ( _
    il As Byte(), _
    count As Integer _
)
'Usage
Dim instance As MethodBuilder
Dim il As Byte()
Dim count As Integer

instance.CreateMethodBody(il, count)

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

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

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

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

Parameter

  • il
    Ein Array, das gültige MSIL-Anweisungen enthält. Wenn dieser Parameter NULL (Nothing in Visual Basic) ist, wird der Methodenkörper gelöscht.
  • count
    Die Anzahl der gültigen Bytes im MSIL-Array. Dieser Wert wird ignoriert, wenn MSIL NULL (Nothing in Visual Basic) ist.

Ausnahmen

Ausnahmetyp Bedingung

ArgumentOutOfRangeException

count liegt außerhalb des Indexbereichs des bereitgestellten MSIL-Anweisungsarrays, und il ist nicht NULL (Nothing in Visual Basic).

InvalidOperationException

Der enthaltende Typ wurde bereits mit CreateType erstellt.

– oder –

Diese Methode wurde zuvor für diesen MethodBuilder mit einem il-Argument aufgerufen, das nicht NULL (Nothing in Visual Basic) war.

– oder –

Für die aktuelle Methode ist die IsGenericMethod-Eigenschaft true, die IsGenericMethodDefinition-Eigenschaft ist jedoch false.

Hinweise

Diese Methode erstellt den Methodenkörper von il, einem Array, das MSIL-Anweisungen als Opcodes enthält. Die Anzahl der gültigen MSIL-Bytes wird durch count angegeben.

Hinweis

Dies wird derzeit nicht vollständig unterstützt. Der Benutzer kann den Speicherort von Fixups für Token und von Ausnahmehandlern nicht bereitstellen.

Beispiel

Im folgenden Beispiel wird über Opcode unter Verwendung von CreateMethodBody eine einfache Methode generiert, die zwei ganze Zahlen addiert.

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})); 
   }

}

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 ) );
}

Plattformen

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

MethodBuilder-Klasse
MethodBuilder-Member
System.Reflection.Emit-Namespace