MethodBuilder.CreateMethodBody(Byte[], Int32) Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Erstellt den Text der Methode unter Verwendung eines angegebenen Bytearrays von MSIL-Anweisungen (Microsoft Intermediate Language).
public:
void CreateMethodBody(cli::array <System::Byte> ^ il, int count);public void CreateMethodBody (byte[] il, int count);member this.CreateMethodBody : byte[] * int -> unitPublic Sub CreateMethodBody (il As Byte(), count As Integer)Parameter
- il
- Byte[]
Ein Array mit gültigen MSIL-Anweisungen. Wenn dieser Parameter null ist, wird der Methodentext gelöscht.
- count
- Int32
Die Anzahl der gültigen Bytes im MSIL-Array. Dieser Wert wird ignoriert, wenn MSIL null ist.
Ausnahmen
count liegt nicht innerhalb des Bereichs der Indizes des angegebenen Arrays der MSIL-Anweisungen und il ist nicht null.
Der enthaltende Typ wurde zuvor mit CreateType() erstellt.
- oder -
Diese Methode wurde zuvor in diesem MethodBuilder mit einem il-Argument aufgerufen, das nicht null war.
- oder -
Für die aktuelle Methode ist die IsGenericMethod-Eigenschaft true, aber die IsGenericMethodDefinition-Eigenschaft ist false.
Beispiele
Im folgenden Beispiel wird eine einfache Methode, die zwei ganze Zahlen hinzufügt, mithilfe von opcode CreateMethodBodygeneriert.
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 ) );
}
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}));
}
}
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
End Class
Hinweise
Diese Methode erstellt den Text der Methode aus il, einem Array, das MSIL-Anweisungen als Opcodes enthält. Die Anzahl der Bytes der gültigen MSIL wird anhand der Anzahl angegeben.
Hinweis
Dies wird derzeit nicht vollständig unterstützt. Der Benutzer kann den Speicherort von Tokenfixups und Ausnahmehandlern nicht angeben.
Gilt für:
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für