MethodBuilder.CreateMethodBody(Byte[], Int32) Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Crée le corps de la méthode en utilisant un tableau d’octets d’instructions MSIL (Microsoft Intermediate Language) spécifié.
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)Paramètres
- il
- Byte[]
Tableau contenant des instructions MSIL valides. Si ce paramètre est null, le corps de la méthode est effacé.
- count
- Int32
Nombre d’octets valides dans le tableau MSIL. Cette valeur est ignorée si MSIL est null.
Exceptions
count n’est pas compris dans la plage d’index du tableau d’instructions MSIL fourni, et il n’est pas null.
Le type conteneur a déjà été créé à l’aide de CreateType().
- ou -
Cette méthode a été appelée précédemment sur ce MethodBuilder avec un argument il qui n’était pas null.
- ou -
Pour la méthode actuelle, la propriété IsGenericMethod est true, mais la propriété IsGenericMethodDefinition est false.
Exemples
Dans l’exemple fourni ci-dessous, une méthode simple qui ajoute deux entiers est générée via opcode à l’aide de CreateMethodBody.
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
Remarques
Cette méthode crée le corps de la méthode à partir de il, un tableau contenant des instructions MSIL sous forme d’opcodes. Le nombre d’octets de MSIL valide est donné par nombre.
Notes
Ce n’est actuellement pas entièrement pris en charge. L’utilisateur ne peut pas fournir l’emplacement des correctifs de jeton et des gestionnaires d’exceptions.
S’applique à
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour