ILGenerator.Emit Méthode

Référence

Définition

Espace de noms:: System.Reflection.Emit

Assembly:: System.Reflection.Emit.ILGeneration.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Paquet:: System.Reflection.Emit.ILGeneration v4.7.0

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.

Place une instruction dans le flux MSIL pour le compilateur juste-à-temps (JIT).

Surcharges

Emit(OpCode, LocalBuilder)	Place l'instruction spécifiée dans le flux MSIL, en la faisant suivre de l'index de la variable locale donnée.
Emit(OpCode, Type)	Place l'instruction spécifiée dans le flux MSIL, en la faisant suivre du jeton de métadonnées pour le type donné.
Emit(OpCode, String)	Place l'instruction spécifiée dans le flux MSIL, en la faisant suivre du jeton de métadonnées de la chaîne donnée.
Emit(OpCode, Single)	Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.
Emit(OpCode, SByte)	Place l'instruction et l'argument en caractères spécifiés dans le flux d'instructions MSIL.
Emit(OpCode, MethodInfo)	Place l'instruction spécifiée dans le flux MSIL, en la faisant suivre du jeton de métadonnées de la méthode donnée.
Emit(OpCode, SignatureHelper)	Place l'instruction et un jeton de signature spécifiés dans le flux d'instructions MSIL.
Emit(OpCode, Label[])	Place l'instruction spécifiée dans le flux MSIL et laisse suffisamment d'espace pour inclure une étiquette lorsque les corrections sont faites.
Emit(OpCode, FieldInfo)	Place l'instruction et le jeton de métadonnées spécifiés pour le champ donné dans le flux d'instructions MSIL.
Emit(OpCode, ConstructorInfo)	Place l'instruction et le jeton de métadonnées spécifiés pour le constructeur donné dans le flux d'instructions MSIL.
Emit(OpCode, Int64)	Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.
Emit(OpCode, Int32)	Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.
Emit(OpCode, Int16)	Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.
Emit(OpCode, Double)	Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.
Emit(OpCode, Byte)	Place l'instruction et l'argument en caractères spécifiés dans le flux d'instructions MSIL.
Emit(OpCode)	Place l'instruction spécifiée dans le flux d'instructions.
Emit(OpCode, Label)	Place l'instruction spécifiée dans le flux MSIL et laisse suffisamment d'espace pour inclure une étiquette lorsque les corrections sont faites.

Emit(OpCode, LocalBuilder)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction spécifiée dans le flux MSIL, en la faisant suivre de l'index de la variable locale donnée.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::LocalBuilder ^ local);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::LocalBuilder ^ local);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.LocalBuilder local);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.LocalBuilder local);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.LocalBuilder -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.LocalBuilder -> unit

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.LocalBuilder -> unit

Public Overridable Sub Emit (opcode As OpCode, local As LocalBuilder)

Public MustOverride Sub Emit (opcode As OpCode, local As LocalBuilder)

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

local: LocalBuilder

Variable locale.

Exceptions

ArgumentException

La méthode parente du paramètre local ne correspond pas à la méthode associée à ce ILGenerator.

ArgumentNullException

local a la valeur null.

InvalidOperationException

opcode est une instruction à octet unique et local représente une variable locale avec un index supérieur à Byte.MaxValue.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode, Type)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction spécifiée dans le flux MSIL, en la faisant suivre du jeton de métadonnées pour le type donné.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, Type ^ cls);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, Type ^ cls);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, Type cls);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, Type cls);

abstract member Emit : System.Reflection.Emit.OpCode * Type -> unit
override this.Emit : System.Reflection.Emit.OpCode * Type -> unit

abstract member Emit : System.Reflection.Emit.OpCode * Type -> unit

Public Overridable Sub Emit (opcode As OpCode, cls As Type)

Public MustOverride Sub Emit (opcode As OpCode, cls As Type)

Paramètres

opcode: OpCode

Instruction MSIL à placer dans le flux.

cls: Type

Type

Exceptions

ArgumentNullException

cls a la valeur null.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes . L’emplacement de cls est enregistré afin que le jeton puisse être corrigé si nécessaire lors de la persistance du module dans un fichier exécutable portable (PE).

S’applique à

Emit(OpCode, String)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction spécifiée dans le flux MSIL, en la faisant suivre du jeton de métadonnées de la chaîne donnée.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::String ^ str);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, System::String ^ str);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, string str);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, string str);

abstract member Emit : System.Reflection.Emit.OpCode * string -> unit
override this.Emit : System.Reflection.Emit.OpCode * string -> unit

abstract member Emit : System.Reflection.Emit.OpCode * string -> unit

Public Overridable Sub Emit (opcode As OpCode, str As String)

Public MustOverride Sub Emit (opcode As OpCode, str As String)

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

str: String

String à émettre.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes . L’emplacement de str est enregistré pour les correctifs futurs si le module est conservé dans un fichier exécutable portable (PE).

S’applique à

Emit(OpCode, Single)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, float arg);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, float arg);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, float arg);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, float arg);

abstract member Emit : System.Reflection.Emit.OpCode * single -> unit
override this.Emit : System.Reflection.Emit.OpCode * single -> unit

abstract member Emit : System.Reflection.Emit.OpCode * single -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Single)

Public MustOverride Sub Emit (opcode As OpCode, arg As Single)

Paramètres

opcode: OpCode

Instruction MSIL à placer dans le flux.

arg: Single

Argument Single faisant l'objet d'un push dans le flux immédiatement après l'instruction.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode, SByte)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Important

Cette API n’est pas conforme CLS.

Place l'instruction et l'argument en caractères spécifiés dans le flux d'instructions MSIL.

public:
 void Emit(System::Reflection::Emit::OpCode opcode, System::SByte arg);

[System.CLSCompliant(false)]
public void Emit (System.Reflection.Emit.OpCode opcode, sbyte arg);

[<System.CLSCompliant(false)>]
member this.Emit : System.Reflection.Emit.OpCode * sbyte -> unit

Public Sub Emit (opcode As OpCode, arg As SByte)

Paramètres

opcode: OpCode

Instruction MSIL à placer dans le flux.

arg: SByte

Argument en caractères faisant l'objet d'un push dans le flux immédiatement après l'instruction.

Attributs: CLSCompliantAttribute

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode, MethodInfo)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction spécifiée dans le flux MSIL, en la faisant suivre du jeton de métadonnées de la méthode donnée.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::MethodInfo ^ meth);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::MethodInfo ^ meth);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.MethodInfo meth);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.MethodInfo meth);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.MethodInfo -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.MethodInfo -> unit

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.MethodInfo -> unit

Public Overridable Sub Emit (opcode As OpCode, meth As MethodInfo)

Public MustOverride Sub Emit (opcode As OpCode, meth As MethodInfo)

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

meth: MethodInfo

MethodInfo qui représente une méthode.

Exceptions

ArgumentNullException

meth a la valeur null.

NotSupportedException

meth est une méthode générique pour laquelle la propriété IsGenericMethodDefinition est false.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

L’emplacement de meth est enregistré afin que le flux d’instructions puisse être corrigé si nécessaire lors de la persistance du module dans un fichier exécutable portable (PE).

Si meth représente une méthode générique, il doit s’agir d’une définition de méthode générique. Autrement dit, sa propriété MethodInfo.IsGenericMethodDefinition doit être true.

S’applique à

Emit(OpCode, SignatureHelper)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et un jeton de signature spécifiés dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::SignatureHelper ^ signature);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::SignatureHelper ^ signature);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.SignatureHelper signature);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.SignatureHelper signature);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.SignatureHelper -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.SignatureHelper -> unit

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.SignatureHelper -> unit

Public Overridable Sub Emit (opcode As OpCode, signature As SignatureHelper)

Public MustOverride Sub Emit (opcode As OpCode, signature As SignatureHelper)

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

signature: SignatureHelper

Assistance pour la construction d'un jeton de signature.

Exceptions

ArgumentNullException

signature a la valeur null.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode, Label[])

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction spécifiée dans le flux MSIL et laisse suffisamment d'espace pour inclure une étiquette lorsque les corrections sont faites.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, cli::array <System::Reflection::Emit::Label> ^ labels);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, cli::array <System::Reflection::Emit::Label> ^ labels);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.Label[] labels);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.Label[] labels);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label[] -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label[] -> unit

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label[] -> unit

Public Overridable Sub Emit (opcode As OpCode, labels As Label())

Public MustOverride Sub Emit (opcode As OpCode, labels As Label())

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

labels: Label[]

Tableau d'objets étiquette vers lesquels créer une branche à partir de cet emplacement. Toutes les étiquettes seront utilisées.

Exceptions

ArgumentNullException

con a la valeur null. Cette exception est nouvelle dans .NET Framework 4.

Exemples

L’exemple de code ci-dessous illustre la création d’une méthode dynamique avec une table de saut. La table de raccourcis est générée à l’aide d’un tableau de Label.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ BuildMyType()
{
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew AssemblyName;
   myAsmName->Name = "MyDynamicAssembly";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::Run );
   ModuleBuilder^ myModBuilder = myAsmBuilder->DefineDynamicModule( "MyJumpTableDemo" );
   TypeBuilder^ myTypeBuilder = myModBuilder->DefineType( "JumpTableDemo", TypeAttributes::Public );
   array<Type^>^temp0 = {int::typeid};
   MethodBuilder^ myMthdBuilder = myTypeBuilder->DefineMethod( "SwitchMe", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), String::typeid, temp0 );
   ILGenerator^ myIL = myMthdBuilder->GetILGenerator();
   Label defaultCase = myIL->DefineLabel();
   Label endOfMethod = myIL->DefineLabel();
   
   // We are initializing our jump table. Note that the labels
   // will be placed later using the MarkLabel method.
   array<Label>^jumpTable = gcnew array<Label>(5);
   jumpTable[ 0 ] = myIL->DefineLabel();
   jumpTable[ 1 ] = myIL->DefineLabel();
   jumpTable[ 2 ] = myIL->DefineLabel();
   jumpTable[ 3 ] = myIL->DefineLabel();
   jumpTable[ 4 ] = myIL->DefineLabel();
   
   // arg0, the number we passed, is pushed onto the stack.
   // In this case, due to the design of the code sample,
   // the value pushed onto the stack happens to match the
   // index of the label (in IL terms, the index of the offset
   // in the jump table). If this is not the case, such as
   // when switching based on non-integer values, rules for the correspondence
   // between the possible case values and each index of the offsets
   // must be established outside of the ILGenerator::Emit calls,
   // much as a compiler would.
   myIL->Emit( OpCodes::Ldarg_0 );
   myIL->Emit( OpCodes::Switch, jumpTable );
   
   // Branch on default case
   myIL->Emit( OpCodes::Br_S, defaultCase );
   
   // Case arg0 = 0
   myIL->MarkLabel( jumpTable[ 0 ] );
   myIL->Emit( OpCodes::Ldstr, "are no bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 1
   myIL->MarkLabel( jumpTable[ 1 ] );
   myIL->Emit( OpCodes::Ldstr, "is one banana" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 2
   myIL->MarkLabel( jumpTable[ 2 ] );
   myIL->Emit( OpCodes::Ldstr, "are two bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 3
   myIL->MarkLabel( jumpTable[ 3 ] );
   myIL->Emit( OpCodes::Ldstr, "are three bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 4
   myIL->MarkLabel( jumpTable[ 4 ] );
   myIL->Emit( OpCodes::Ldstr, "are four bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Default case
   myIL->MarkLabel( defaultCase );
   myIL->Emit( OpCodes::Ldstr, "are many bananas" );
   myIL->MarkLabel( endOfMethod );
   myIL->Emit( OpCodes::Ret );
   return myTypeBuilder->CreateType();
}

int main()
{
   Type^ myType = BuildMyType();
   Console::Write( "Enter an integer between 0 and 5: " );
   int theValue = Convert::ToInt32( Console::ReadLine() );
   Console::WriteLine( "---" );
   Object^ myInstance = Activator::CreateInstance( myType, gcnew array<Object^>(0) );
   array<Object^>^temp1 = {theValue};
   Console::WriteLine( "Yes, there {0} today!", myType->InvokeMember( "SwitchMe", BindingFlags::InvokeMethod, nullptr, myInstance, temp1 ) );
}

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

class DynamicJumpTableDemo
{
   public static Type BuildMyType()
   {
    AppDomain myDomain = Thread.GetDomain();
    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

    AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                        myAsmName,
                        AssemblyBuilderAccess.Run);
    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(
                        "MyJumpTableDemo");

    TypeBuilder myTypeBuilder = myModBuilder.DefineType("JumpTableDemo",
                            TypeAttributes.Public);
    MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("SwitchMe",
                             MethodAttributes.Public |
                             MethodAttributes.Static,
                                             typeof(string),
                                             new Type[] {typeof(int)});

    ILGenerator myIL = myMthdBuilder.GetILGenerator();

    Label defaultCase = myIL.DefineLabel();	
    Label endOfMethod = myIL.DefineLabel();	

    // We are initializing our jump table. Note that the labels
    // will be placed later using the MarkLabel method.

    Label[] jumpTable = new Label[] { myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel() };

    // arg0, the number we passed, is pushed onto the stack.
    // In this case, due to the design of the code sample,
    // the value pushed onto the stack happens to match the
    // index of the label (in IL terms, the index of the offset
    // in the jump table). If this is not the case, such as
    // when switching based on non-integer values, rules for the correspondence
    // between the possible case values and each index of the offsets
    // must be established outside of the ILGenerator.Emit calls,
    // much as a compiler would.

    myIL.Emit(OpCodes.Ldarg_0);
    myIL.Emit(OpCodes.Switch, jumpTable);
    
    // Branch on default case
    myIL.Emit(OpCodes.Br_S, defaultCase);

    // Case arg0 = 0
    myIL.MarkLabel(jumpTable[0]);
    myIL.Emit(OpCodes.Ldstr, "are no bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 1
    myIL.MarkLabel(jumpTable[1]);
    myIL.Emit(OpCodes.Ldstr, "is one banana");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 2
    myIL.MarkLabel(jumpTable[2]);
    myIL.Emit(OpCodes.Ldstr, "are two bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 3
    myIL.MarkLabel(jumpTable[3]);
    myIL.Emit(OpCodes.Ldstr, "are three bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 4
    myIL.MarkLabel(jumpTable[4]);
    myIL.Emit(OpCodes.Ldstr, "are four bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Default case
    myIL.MarkLabel(defaultCase);
    myIL.Emit(OpCodes.Ldstr, "are many bananas");

    myIL.MarkLabel(endOfMethod);
    myIL.Emit(OpCodes.Ret);
    
    return myTypeBuilder.CreateType();
   }

   public static void Main()
   {
    Type myType = BuildMyType();
    
    Console.Write("Enter an integer between 0 and 5: ");
    int theValue = Convert.ToInt32(Console.ReadLine());

    Console.WriteLine("---");
    Object myInstance = Activator.CreateInstance(myType, new object[0]);	
    Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe",
                               BindingFlags.InvokeMethod,
                               null,
                               myInstance,
                               new object[] {theValue}));
   }
}


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

 _

Class DynamicJumpTableDemo
   
   Public Shared Function BuildMyType() As Type

      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
                            AssemblyBuilderAccess.Run)
      Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyJumpTableDemo")
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType("JumpTableDemo", _
                                 TypeAttributes.Public)
      Dim myMthdBuilder As MethodBuilder = myTypeBuilder.DefineMethod("SwitchMe", _
                        MethodAttributes.Public Or MethodAttributes.Static, _
                        GetType(String), New Type() {GetType(Integer)})
      
      Dim myIL As ILGenerator = myMthdBuilder.GetILGenerator()
      
      Dim defaultCase As Label = myIL.DefineLabel()
      Dim endOfMethod As Label = myIL.DefineLabel()
      
      ' We are initializing our jump table. Note that the labels
      ' will be placed later using the MarkLabel method. 

      Dim jumpTable() As Label = {myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel()}
      
      ' arg0, the number we passed, is pushed onto the stack.
      ' In this case, due to the design of the code sample,
      ' the value pushed onto the stack happens to match the
      ' index of the label (in IL terms, the index of the offset
      ' in the jump table). If this is not the case, such as
      ' when switching based on non-integer values, rules for the correspondence
      ' between the possible case values and each index of the offsets
      ' must be established outside of the ILGenerator.Emit calls,
      ' much as a compiler would.

      myIL.Emit(OpCodes.Ldarg_0)
      myIL.Emit(OpCodes.Switch, jumpTable)
      
      ' Branch on default case
      myIL.Emit(OpCodes.Br_S, defaultCase)
      
      ' Case arg0 = 0
      myIL.MarkLabel(jumpTable(0))
      myIL.Emit(OpCodes.Ldstr, "are no bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 1
      myIL.MarkLabel(jumpTable(1))
      myIL.Emit(OpCodes.Ldstr, "is one banana")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 2
      myIL.MarkLabel(jumpTable(2))
      myIL.Emit(OpCodes.Ldstr, "are two bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 3
      myIL.MarkLabel(jumpTable(3))
      myIL.Emit(OpCodes.Ldstr, "are three bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 4
      myIL.MarkLabel(jumpTable(4))
      myIL.Emit(OpCodes.Ldstr, "are four bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Default case
      myIL.MarkLabel(defaultCase)
      myIL.Emit(OpCodes.Ldstr, "are many bananas")
      
      myIL.MarkLabel(endOfMethod)
      myIL.Emit(OpCodes.Ret)
      
      Return myTypeBuilder.CreateType()

   End Function 'BuildMyType
    
   
   Public Shared Sub Main()

      Dim myType As Type = BuildMyType()
      
      Console.Write("Enter an integer between 0 and 5: ")
      Dim theValue As Integer = Convert.ToInt32(Console.ReadLine())
      
      Console.WriteLine("---")
      Dim myInstance As [Object] = Activator.CreateInstance(myType, New Object() {})
      Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe", _
                         BindingFlags.InvokeMethod, Nothing, _
                             myInstance, New Object() {theValue}))

   End Sub

End Class

Remarques

Émet une table switch.

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

Les étiquettes sont créées à l’aide DefineLabel de et leur emplacement dans le flux est résolu à l’aide de MarkLabel. Si une instruction monooctet est utilisée, l’étiquette peut représenter un saut d’au plus 127 octets le long du flux. opcode doit représenter une instruction de branche. Étant donné que les branches sont des instructions relatives, label elles seront remplacées par le décalage vers la branche correct pendant le processus de correction.

S’applique à

Emit(OpCode, FieldInfo)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et le jeton de métadonnées spécifiés pour le champ donné dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::FieldInfo ^ field);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::FieldInfo ^ field);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.FieldInfo field);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.FieldInfo field);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.FieldInfo -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.FieldInfo -> unit

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.FieldInfo -> unit

Public Overridable Sub Emit (opcode As OpCode, field As FieldInfo)

Public MustOverride Sub Emit (opcode As OpCode, field As FieldInfo)

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

field: FieldInfo

FieldInfo qui représente un champ.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes . L’emplacement de field est enregistré afin que le flux d’instructions puisse être corrigé si nécessaire lors de la persistance du module dans un fichier exécutable portable (PE).

S’applique à

Emit(OpCode, ConstructorInfo)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et le jeton de métadonnées spécifiés pour le constructeur donné dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::ConstructorInfo ^ con);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::ConstructorInfo ^ con);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.ConstructorInfo con);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.ConstructorInfo con);

[System.Runtime.InteropServices.ComVisible(true)]
public virtual void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.ConstructorInfo con);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit

[<System.Runtime.InteropServices.ComVisible(true)>]
abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.ConstructorInfo -> unit

Public Overridable Sub Emit (opcode As OpCode, con As ConstructorInfo)

Public MustOverride Sub Emit (opcode As OpCode, con As ConstructorInfo)

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

con: ConstructorInfo

ConstructorInfo qui représente un constructeur.

Attributs: ComVisibleAttribute

Exceptions

ArgumentNullException

con a la valeur null. Cette exception est nouvelle dans .NET Framework 4.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

L’emplacement de con est enregistré afin que le flux d’instructions puisse être corrigé si nécessaire lors de la persistance du module dans un fichier exécutable portable (PE).

S’applique à

Emit(OpCode, Int64)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, long arg);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, long arg);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, long arg);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, long arg);

abstract member Emit : System.Reflection.Emit.OpCode * int64 -> unit
override this.Emit : System.Reflection.Emit.OpCode * int64 -> unit

abstract member Emit : System.Reflection.Emit.OpCode * int64 -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Long)

Public MustOverride Sub Emit (opcode As OpCode, arg As Long)

Paramètres

opcode: OpCode

Instruction MSIL à placer dans le flux.

arg: Int64

Argument numérique faisant l'objet d'un push dans le flux immédiatement après l'instruction.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode, Int32)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, int arg);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, int arg);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, int arg);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, int arg);

abstract member Emit : System.Reflection.Emit.OpCode * int -> unit
override this.Emit : System.Reflection.Emit.OpCode * int -> unit

abstract member Emit : System.Reflection.Emit.OpCode * int -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Integer)

Public MustOverride Sub Emit (opcode As OpCode, arg As Integer)

Paramètres

opcode: OpCode

Instruction MSIL à placer dans le flux.

arg: Int32

Argument numérique faisant l'objet d'un push dans le flux immédiatement après l'instruction.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode, Int16)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, short arg);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, short arg);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, short arg);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, short arg);

abstract member Emit : System.Reflection.Emit.OpCode * int16 -> unit
override this.Emit : System.Reflection.Emit.OpCode * int16 -> unit

abstract member Emit : System.Reflection.Emit.OpCode * int16 -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Short)

Public MustOverride Sub Emit (opcode As OpCode, arg As Short)

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

arg: Int16

Argument Int faisant l'objet d'un push dans le flux immédiatement après l'instruction.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode, Double)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et l'argument numérique spécifiés dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, double arg);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, double arg);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, double arg);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, double arg);

abstract member Emit : System.Reflection.Emit.OpCode * double -> unit
override this.Emit : System.Reflection.Emit.OpCode * double -> unit

abstract member Emit : System.Reflection.Emit.OpCode * double -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Double)

Public MustOverride Sub Emit (opcode As OpCode, arg As Double)

Paramètres

opcode: OpCode

Instruction MSIL à placer dans le flux. Définie dans l'énumération OpCodes.

arg: Double

Argument numérique faisant l'objet d'un push dans le flux immédiatement après l'instruction.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode, Byte)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction et l'argument en caractères spécifiés dans le flux d'instructions MSIL.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Byte arg);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, System::Byte arg);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, byte arg);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, byte arg);

abstract member Emit : System.Reflection.Emit.OpCode * byte -> unit
override this.Emit : System.Reflection.Emit.OpCode * byte -> unit

abstract member Emit : System.Reflection.Emit.OpCode * byte -> unit

Public Overridable Sub Emit (opcode As OpCode, arg As Byte)

Public MustOverride Sub Emit (opcode As OpCode, arg As Byte)

Paramètres

opcode: OpCode

Instruction MSIL à placer dans le flux.

arg: Byte

Argument en caractères faisant l'objet d'un push dans le flux immédiatement après l'instruction.

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

S’applique à

Emit(OpCode)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction spécifiée dans le flux d'instructions.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode);

public virtual void Emit (System.Reflection.Emit.OpCode opcode);

public abstract void Emit (System.Reflection.Emit.OpCode opcode);

abstract member Emit : System.Reflection.Emit.OpCode -> unit
override this.Emit : System.Reflection.Emit.OpCode -> unit

abstract member Emit : System.Reflection.Emit.OpCode -> unit

Public Overridable Sub Emit (opcode As OpCode)

Public MustOverride Sub Emit (opcode As OpCode)

Paramètres

opcode: OpCode

Instruction MSIL à placer dans le flux.

Exemples

L’exemple de code ci-dessous illustre l’utilisation de Emit pour générer une sortie MSIL via un instance de ILGenerator.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ BuildMyType()
{
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew AssemblyName;
   myAsmName->Name = "MyDynamicAssembly";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::Run );
   ModuleBuilder^ myModBuilder = myAsmBuilder->DefineDynamicModule( "MyJumpTableDemo" );
   TypeBuilder^ myTypeBuilder = myModBuilder->DefineType( "JumpTableDemo", TypeAttributes::Public );
   array<Type^>^temp0 = {int::typeid};
   MethodBuilder^ myMthdBuilder = myTypeBuilder->DefineMethod( "SwitchMe", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), String::typeid, temp0 );
   ILGenerator^ myIL = myMthdBuilder->GetILGenerator();
   Label defaultCase = myIL->DefineLabel();
   Label endOfMethod = myIL->DefineLabel();
   
   // We are initializing our jump table. Note that the labels
   // will be placed later using the MarkLabel method.
   array<Label>^jumpTable = gcnew array<Label>(5);
   jumpTable[ 0 ] = myIL->DefineLabel();
   jumpTable[ 1 ] = myIL->DefineLabel();
   jumpTable[ 2 ] = myIL->DefineLabel();
   jumpTable[ 3 ] = myIL->DefineLabel();
   jumpTable[ 4 ] = myIL->DefineLabel();
   
   // arg0, the number we passed, is pushed onto the stack.
   // In this case, due to the design of the code sample,
   // the value pushed onto the stack happens to match the
   // index of the label (in IL terms, the index of the offset
   // in the jump table). If this is not the case, such as
   // when switching based on non-integer values, rules for the correspondence
   // between the possible case values and each index of the offsets
   // must be established outside of the ILGenerator::Emit calls,
   // much as a compiler would.
   myIL->Emit( OpCodes::Ldarg_0 );
   myIL->Emit( OpCodes::Switch, jumpTable );
   
   // Branch on default case
   myIL->Emit( OpCodes::Br_S, defaultCase );
   
   // Case arg0 = 0
   myIL->MarkLabel( jumpTable[ 0 ] );
   myIL->Emit( OpCodes::Ldstr, "are no bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 1
   myIL->MarkLabel( jumpTable[ 1 ] );
   myIL->Emit( OpCodes::Ldstr, "is one banana" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 2
   myIL->MarkLabel( jumpTable[ 2 ] );
   myIL->Emit( OpCodes::Ldstr, "are two bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 3
   myIL->MarkLabel( jumpTable[ 3 ] );
   myIL->Emit( OpCodes::Ldstr, "are three bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 4
   myIL->MarkLabel( jumpTable[ 4 ] );
   myIL->Emit( OpCodes::Ldstr, "are four bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Default case
   myIL->MarkLabel( defaultCase );
   myIL->Emit( OpCodes::Ldstr, "are many bananas" );
   myIL->MarkLabel( endOfMethod );
   myIL->Emit( OpCodes::Ret );
   return myTypeBuilder->CreateType();
}

int main()
{
   Type^ myType = BuildMyType();
   Console::Write( "Enter an integer between 0 and 5: " );
   int theValue = Convert::ToInt32( Console::ReadLine() );
   Console::WriteLine( "---" );
   Object^ myInstance = Activator::CreateInstance( myType, gcnew array<Object^>(0) );
   array<Object^>^temp1 = {theValue};
   Console::WriteLine( "Yes, there {0} today!", myType->InvokeMember( "SwitchMe", BindingFlags::InvokeMethod, nullptr, myInstance, temp1 ) );
}

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

class DynamicJumpTableDemo
{
   public static Type BuildMyType()
   {
    AppDomain myDomain = Thread.GetDomain();
    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

    AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                        myAsmName,
                        AssemblyBuilderAccess.Run);
    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(
                        "MyJumpTableDemo");

    TypeBuilder myTypeBuilder = myModBuilder.DefineType("JumpTableDemo",
                            TypeAttributes.Public);
    MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("SwitchMe",
                             MethodAttributes.Public |
                             MethodAttributes.Static,
                                             typeof(string),
                                             new Type[] {typeof(int)});

    ILGenerator myIL = myMthdBuilder.GetILGenerator();

    Label defaultCase = myIL.DefineLabel();	
    Label endOfMethod = myIL.DefineLabel();	

    // We are initializing our jump table. Note that the labels
    // will be placed later using the MarkLabel method.

    Label[] jumpTable = new Label[] { myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel() };

    // arg0, the number we passed, is pushed onto the stack.
    // In this case, due to the design of the code sample,
    // the value pushed onto the stack happens to match the
    // index of the label (in IL terms, the index of the offset
    // in the jump table). If this is not the case, such as
    // when switching based on non-integer values, rules for the correspondence
    // between the possible case values and each index of the offsets
    // must be established outside of the ILGenerator.Emit calls,
    // much as a compiler would.

    myIL.Emit(OpCodes.Ldarg_0);
    myIL.Emit(OpCodes.Switch, jumpTable);
    
    // Branch on default case
    myIL.Emit(OpCodes.Br_S, defaultCase);

    // Case arg0 = 0
    myIL.MarkLabel(jumpTable[0]);
    myIL.Emit(OpCodes.Ldstr, "are no bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 1
    myIL.MarkLabel(jumpTable[1]);
    myIL.Emit(OpCodes.Ldstr, "is one banana");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 2
    myIL.MarkLabel(jumpTable[2]);
    myIL.Emit(OpCodes.Ldstr, "are two bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 3
    myIL.MarkLabel(jumpTable[3]);
    myIL.Emit(OpCodes.Ldstr, "are three bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 4
    myIL.MarkLabel(jumpTable[4]);
    myIL.Emit(OpCodes.Ldstr, "are four bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Default case
    myIL.MarkLabel(defaultCase);
    myIL.Emit(OpCodes.Ldstr, "are many bananas");

    myIL.MarkLabel(endOfMethod);
    myIL.Emit(OpCodes.Ret);
    
    return myTypeBuilder.CreateType();
   }

   public static void Main()
   {
    Type myType = BuildMyType();
    
    Console.Write("Enter an integer between 0 and 5: ");
    int theValue = Convert.ToInt32(Console.ReadLine());

    Console.WriteLine("---");
    Object myInstance = Activator.CreateInstance(myType, new object[0]);	
    Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe",
                               BindingFlags.InvokeMethod,
                               null,
                               myInstance,
                               new object[] {theValue}));
   }
}


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

 _

Class DynamicJumpTableDemo
   
   Public Shared Function BuildMyType() As Type

      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
                            AssemblyBuilderAccess.Run)
      Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyJumpTableDemo")
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType("JumpTableDemo", _
                                 TypeAttributes.Public)
      Dim myMthdBuilder As MethodBuilder = myTypeBuilder.DefineMethod("SwitchMe", _
                        MethodAttributes.Public Or MethodAttributes.Static, _
                        GetType(String), New Type() {GetType(Integer)})
      
      Dim myIL As ILGenerator = myMthdBuilder.GetILGenerator()
      
      Dim defaultCase As Label = myIL.DefineLabel()
      Dim endOfMethod As Label = myIL.DefineLabel()
      
      ' We are initializing our jump table. Note that the labels
      ' will be placed later using the MarkLabel method. 

      Dim jumpTable() As Label = {myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel()}
      
      ' arg0, the number we passed, is pushed onto the stack.
      ' In this case, due to the design of the code sample,
      ' the value pushed onto the stack happens to match the
      ' index of the label (in IL terms, the index of the offset
      ' in the jump table). If this is not the case, such as
      ' when switching based on non-integer values, rules for the correspondence
      ' between the possible case values and each index of the offsets
      ' must be established outside of the ILGenerator.Emit calls,
      ' much as a compiler would.

      myIL.Emit(OpCodes.Ldarg_0)
      myIL.Emit(OpCodes.Switch, jumpTable)
      
      ' Branch on default case
      myIL.Emit(OpCodes.Br_S, defaultCase)
      
      ' Case arg0 = 0
      myIL.MarkLabel(jumpTable(0))
      myIL.Emit(OpCodes.Ldstr, "are no bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 1
      myIL.MarkLabel(jumpTable(1))
      myIL.Emit(OpCodes.Ldstr, "is one banana")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 2
      myIL.MarkLabel(jumpTable(2))
      myIL.Emit(OpCodes.Ldstr, "are two bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 3
      myIL.MarkLabel(jumpTable(3))
      myIL.Emit(OpCodes.Ldstr, "are three bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 4
      myIL.MarkLabel(jumpTable(4))
      myIL.Emit(OpCodes.Ldstr, "are four bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Default case
      myIL.MarkLabel(defaultCase)
      myIL.Emit(OpCodes.Ldstr, "are many bananas")
      
      myIL.MarkLabel(endOfMethod)
      myIL.Emit(OpCodes.Ret)
      
      Return myTypeBuilder.CreateType()

   End Function 'BuildMyType
    
   
   Public Shared Sub Main()

      Dim myType As Type = BuildMyType()
      
      Console.Write("Enter an integer between 0 and 5: ")
      Dim theValue As Integer = Convert.ToInt32(Console.ReadLine())
      
      Console.WriteLine("---")
      Dim myInstance As [Object] = Activator.CreateInstance(myType, New Object() {})
      Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe", _
                         BindingFlags.InvokeMethod, Nothing, _
                             myInstance, New Object() {theValue}))

   End Sub

End Class

Remarques

Si le opcode paramètre nécessite un argument, l’appelant doit s’assurer que la longueur de l’argument correspond à la longueur du paramètre déclaré. Sinon, les résultats seront imprévisibles. Par exemple, si l’instruction Emit nécessite un opérande de 2 octets et que l’appelant fournit un opérande de 4 octets, le runtime émet deux octets supplémentaires dans le flux d’instructions. Ces octets supplémentaires sont des Nop instructions.

Les valeurs d’instruction sont définies dans OpCodes.

S’applique à

Emit(OpCode, Label)

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Place l'instruction spécifiée dans le flux MSIL et laisse suffisamment d'espace pour inclure une étiquette lorsque les corrections sont faites.

public:
 virtual void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::Label label);

public:
 abstract void Emit(System::Reflection::Emit::OpCode opcode, System::Reflection::Emit::Label label);

public virtual void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.Label label);

public abstract void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.Label label);

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label -> unit
override this.Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label -> unit

abstract member Emit : System.Reflection.Emit.OpCode * System.Reflection.Emit.Label -> unit

Public Overridable Sub Emit (opcode As OpCode, label As Label)

Public MustOverride Sub Emit (opcode As OpCode, label As Label)

Paramètres

opcode: OpCode

Instruction MSIL à émettre dans le flux.

label: Label

Étiquette vers laquelle créer une branche à partir de cet emplacement.

Exemples

L’exemple de code ci-dessous illustre la création d’une méthode dynamique avec une table de rebond. La table de rebond est générée à l’aide d’un tableau de Label.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ BuildMyType()
{
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew AssemblyName;
   myAsmName->Name = "MyDynamicAssembly";
   AssemblyBuilder^ myAsmBuilder = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::Run );
   ModuleBuilder^ myModBuilder = myAsmBuilder->DefineDynamicModule( "MyJumpTableDemo" );
   TypeBuilder^ myTypeBuilder = myModBuilder->DefineType( "JumpTableDemo", TypeAttributes::Public );
   array<Type^>^temp0 = {int::typeid};
   MethodBuilder^ myMthdBuilder = myTypeBuilder->DefineMethod( "SwitchMe", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), String::typeid, temp0 );
   ILGenerator^ myIL = myMthdBuilder->GetILGenerator();
   Label defaultCase = myIL->DefineLabel();
   Label endOfMethod = myIL->DefineLabel();
   
   // We are initializing our jump table. Note that the labels
   // will be placed later using the MarkLabel method.
   array<Label>^jumpTable = gcnew array<Label>(5);
   jumpTable[ 0 ] = myIL->DefineLabel();
   jumpTable[ 1 ] = myIL->DefineLabel();
   jumpTable[ 2 ] = myIL->DefineLabel();
   jumpTable[ 3 ] = myIL->DefineLabel();
   jumpTable[ 4 ] = myIL->DefineLabel();
   
   // arg0, the number we passed, is pushed onto the stack.
   // In this case, due to the design of the code sample,
   // the value pushed onto the stack happens to match the
   // index of the label (in IL terms, the index of the offset
   // in the jump table). If this is not the case, such as
   // when switching based on non-integer values, rules for the correspondence
   // between the possible case values and each index of the offsets
   // must be established outside of the ILGenerator::Emit calls,
   // much as a compiler would.
   myIL->Emit( OpCodes::Ldarg_0 );
   myIL->Emit( OpCodes::Switch, jumpTable );
   
   // Branch on default case
   myIL->Emit( OpCodes::Br_S, defaultCase );
   
   // Case arg0 = 0
   myIL->MarkLabel( jumpTable[ 0 ] );
   myIL->Emit( OpCodes::Ldstr, "are no bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 1
   myIL->MarkLabel( jumpTable[ 1 ] );
   myIL->Emit( OpCodes::Ldstr, "is one banana" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 2
   myIL->MarkLabel( jumpTable[ 2 ] );
   myIL->Emit( OpCodes::Ldstr, "are two bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 3
   myIL->MarkLabel( jumpTable[ 3 ] );
   myIL->Emit( OpCodes::Ldstr, "are three bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Case arg0 = 4
   myIL->MarkLabel( jumpTable[ 4 ] );
   myIL->Emit( OpCodes::Ldstr, "are four bananas" );
   myIL->Emit( OpCodes::Br_S, endOfMethod );
   
   // Default case
   myIL->MarkLabel( defaultCase );
   myIL->Emit( OpCodes::Ldstr, "are many bananas" );
   myIL->MarkLabel( endOfMethod );
   myIL->Emit( OpCodes::Ret );
   return myTypeBuilder->CreateType();
}

int main()
{
   Type^ myType = BuildMyType();
   Console::Write( "Enter an integer between 0 and 5: " );
   int theValue = Convert::ToInt32( Console::ReadLine() );
   Console::WriteLine( "---" );
   Object^ myInstance = Activator::CreateInstance( myType, gcnew array<Object^>(0) );
   array<Object^>^temp1 = {theValue};
   Console::WriteLine( "Yes, there {0} today!", myType->InvokeMember( "SwitchMe", BindingFlags::InvokeMethod, nullptr, myInstance, temp1 ) );
}

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

class DynamicJumpTableDemo
{
   public static Type BuildMyType()
   {
    AppDomain myDomain = Thread.GetDomain();
    AssemblyName myAsmName = new AssemblyName();
    myAsmName.Name = "MyDynamicAssembly";

    AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                        myAsmName,
                        AssemblyBuilderAccess.Run);
    ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(
                        "MyJumpTableDemo");

    TypeBuilder myTypeBuilder = myModBuilder.DefineType("JumpTableDemo",
                            TypeAttributes.Public);
    MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("SwitchMe",
                             MethodAttributes.Public |
                             MethodAttributes.Static,
                                             typeof(string),
                                             new Type[] {typeof(int)});

    ILGenerator myIL = myMthdBuilder.GetILGenerator();

    Label defaultCase = myIL.DefineLabel();	
    Label endOfMethod = myIL.DefineLabel();	

    // We are initializing our jump table. Note that the labels
    // will be placed later using the MarkLabel method.

    Label[] jumpTable = new Label[] { myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel(),
                      myIL.DefineLabel() };

    // arg0, the number we passed, is pushed onto the stack.
    // In this case, due to the design of the code sample,
    // the value pushed onto the stack happens to match the
    // index of the label (in IL terms, the index of the offset
    // in the jump table). If this is not the case, such as
    // when switching based on non-integer values, rules for the correspondence
    // between the possible case values and each index of the offsets
    // must be established outside of the ILGenerator.Emit calls,
    // much as a compiler would.

    myIL.Emit(OpCodes.Ldarg_0);
    myIL.Emit(OpCodes.Switch, jumpTable);
    
    // Branch on default case
    myIL.Emit(OpCodes.Br_S, defaultCase);

    // Case arg0 = 0
    myIL.MarkLabel(jumpTable[0]);
    myIL.Emit(OpCodes.Ldstr, "are no bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 1
    myIL.MarkLabel(jumpTable[1]);
    myIL.Emit(OpCodes.Ldstr, "is one banana");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 2
    myIL.MarkLabel(jumpTable[2]);
    myIL.Emit(OpCodes.Ldstr, "are two bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 3
    myIL.MarkLabel(jumpTable[3]);
    myIL.Emit(OpCodes.Ldstr, "are three bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Case arg0 = 4
    myIL.MarkLabel(jumpTable[4]);
    myIL.Emit(OpCodes.Ldstr, "are four bananas");
    myIL.Emit(OpCodes.Br_S, endOfMethod);

    // Default case
    myIL.MarkLabel(defaultCase);
    myIL.Emit(OpCodes.Ldstr, "are many bananas");

    myIL.MarkLabel(endOfMethod);
    myIL.Emit(OpCodes.Ret);
    
    return myTypeBuilder.CreateType();
   }

   public static void Main()
   {
    Type myType = BuildMyType();
    
    Console.Write("Enter an integer between 0 and 5: ");
    int theValue = Convert.ToInt32(Console.ReadLine());

    Console.WriteLine("---");
    Object myInstance = Activator.CreateInstance(myType, new object[0]);	
    Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe",
                               BindingFlags.InvokeMethod,
                               null,
                               myInstance,
                               new object[] {theValue}));
   }
}


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

 _

Class DynamicJumpTableDemo
   
   Public Shared Function BuildMyType() As Type

      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
                            AssemblyBuilderAccess.Run)
      Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule("MyJumpTableDemo")
      
      Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType("JumpTableDemo", _
                                 TypeAttributes.Public)
      Dim myMthdBuilder As MethodBuilder = myTypeBuilder.DefineMethod("SwitchMe", _
                        MethodAttributes.Public Or MethodAttributes.Static, _
                        GetType(String), New Type() {GetType(Integer)})
      
      Dim myIL As ILGenerator = myMthdBuilder.GetILGenerator()
      
      Dim defaultCase As Label = myIL.DefineLabel()
      Dim endOfMethod As Label = myIL.DefineLabel()
      
      ' We are initializing our jump table. Note that the labels
      ' will be placed later using the MarkLabel method. 

      Dim jumpTable() As Label = {myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel(), _
                  myIL.DefineLabel()}
      
      ' arg0, the number we passed, is pushed onto the stack.
      ' In this case, due to the design of the code sample,
      ' the value pushed onto the stack happens to match the
      ' index of the label (in IL terms, the index of the offset
      ' in the jump table). If this is not the case, such as
      ' when switching based on non-integer values, rules for the correspondence
      ' between the possible case values and each index of the offsets
      ' must be established outside of the ILGenerator.Emit calls,
      ' much as a compiler would.

      myIL.Emit(OpCodes.Ldarg_0)
      myIL.Emit(OpCodes.Switch, jumpTable)
      
      ' Branch on default case
      myIL.Emit(OpCodes.Br_S, defaultCase)
      
      ' Case arg0 = 0
      myIL.MarkLabel(jumpTable(0))
      myIL.Emit(OpCodes.Ldstr, "are no bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 1
      myIL.MarkLabel(jumpTable(1))
      myIL.Emit(OpCodes.Ldstr, "is one banana")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 2
      myIL.MarkLabel(jumpTable(2))
      myIL.Emit(OpCodes.Ldstr, "are two bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 3
      myIL.MarkLabel(jumpTable(3))
      myIL.Emit(OpCodes.Ldstr, "are three bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Case arg0 = 4
      myIL.MarkLabel(jumpTable(4))
      myIL.Emit(OpCodes.Ldstr, "are four bananas")
      myIL.Emit(OpCodes.Br_S, endOfMethod)
      
      ' Default case
      myIL.MarkLabel(defaultCase)
      myIL.Emit(OpCodes.Ldstr, "are many bananas")
      
      myIL.MarkLabel(endOfMethod)
      myIL.Emit(OpCodes.Ret)
      
      Return myTypeBuilder.CreateType()

   End Function 'BuildMyType
    
   
   Public Shared Sub Main()

      Dim myType As Type = BuildMyType()
      
      Console.Write("Enter an integer between 0 and 5: ")
      Dim theValue As Integer = Convert.ToInt32(Console.ReadLine())
      
      Console.WriteLine("---")
      Dim myInstance As [Object] = Activator.CreateInstance(myType, New Object() {})
      Console.WriteLine("Yes, there {0} today!", myType.InvokeMember("SwitchMe", _
                         BindingFlags.InvokeMethod, Nothing, _
                             myInstance, New Object() {theValue}))

   End Sub

End Class

Remarques

Les valeurs d’instruction sont définies dans l’énumération OpCodes .

Les étiquettes sont créées à l’aide DefineLabelde , et leur emplacement dans le flux est résolu à l’aide de MarkLabel. Si une instruction codée sur un octet est utilisée, l’étiquette peut représenter un saut d’au plus 127 octets le long du flux. opcode doit représenter une instruction de branche. Étant donné que les branches sont des instructions relatives, label sera remplacé par le décalage correct vers la branche pendant le processus de correction.

S’applique à

Partager via

ILGenerator.Emit Méthode

Définition

Surcharges

Emit(OpCode, LocalBuilder)

Paramètres

Exceptions

Remarques

S’applique à

Emit(OpCode, Type)

Paramètres

Exceptions

Remarques

S’applique à

Emit(OpCode, String)

Paramètres

Remarques

S’applique à

Emit(OpCode, Single)

Paramètres

Remarques

S’applique à

Emit(OpCode, SByte)

Paramètres

Remarques

S’applique à

Emit(OpCode, MethodInfo)

Paramètres

Exceptions

Remarques

S’applique à

Emit(OpCode, SignatureHelper)

Paramètres

Exceptions

Remarques

S’applique à

Emit(OpCode, Label[])

Paramètres

Exceptions

Exemples

Remarques

S’applique à

Emit(OpCode, FieldInfo)

Paramètres

Remarques

S’applique à

Emit(OpCode, ConstructorInfo)

Paramètres

Exceptions

Remarques

S’applique à

Emit(OpCode, Int64)

Paramètres

Remarques

S’applique à

Emit(OpCode, Int32)

Paramètres

Remarques

S’applique à

Emit(OpCode, Int16)

Paramètres

Remarques

S’applique à

Emit(OpCode, Double)

Paramètres

Remarques

S’applique à

Emit(OpCode, Byte)

Paramètres

Remarques

S’applique à

Emit(OpCode)

Paramètres

Exemples

Remarques

S’applique à

Emit(OpCode, Label)

Paramètres

Exemples

Remarques