ILGenerator.Emit Méthode

Définition

Espace de noms:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

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

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

C#

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

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 .

Emit(OpCode, Type)

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é.

C#

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

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).

Emit(OpCode, String)

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.

C#

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

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).

Emit(OpCode, Single)

Source:

ILGenerator.cs

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

C#

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

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 .

Emit(OpCode, SByte)

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.

C#

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

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 .

Emit(OpCode, MethodInfo)

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.

C#

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

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.

Emit(OpCode, SignatureHelper)

Source:

ILGenerator.cs

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

C#

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

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 .

Emit(OpCode, Label[])

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.

C#

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

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.

C#

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

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.

Emit(OpCode, FieldInfo)

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.

C#

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

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).

Emit(OpCode, ConstructorInfo)

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.

C#

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

Paramètres

opcode

OpCode

Instruction MSIL à émettre dans le flux.

con

ConstructorInfo

ConstructorInfo qui représente un constructeur.

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).

Emit(OpCode, Int64)

Source:

ILGenerator.cs

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

C#

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

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 .

Emit(OpCode, Int32)

Source:

ILGenerator.cs

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

C#

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

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 .

Emit(OpCode, Int16)

Source:

ILGenerator.cs

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

C#

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

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 .

Emit(OpCode, Double)

Source:

ILGenerator.cs

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

C#

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

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 .

Emit(OpCode, Byte)

Source:

ILGenerator.cs

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

C#

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

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 .

Emit(OpCode)

Source:

ILGenerator.cs

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

C#

public abstract void Emit (System.Reflection.Emit.OpCode 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.

C#

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

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.

Emit(OpCode, Label)

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.

C#

public abstract void Emit (System.Reflection.Emit.OpCode opcode, System.Reflection.Emit.Label 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.

C#

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

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.