ILGenerator.Emit Método

Definición

Espacio de nombres:

System.Reflection.Emit

Ensamblado:

System.Reflection.Emit.ILGeneration.dll

Coloca una instrucción máquina en la secuencia del Lenguaje intermedio de Microsoft (MSIL) para el compilador Just-In-Time (JIT).

Sobrecargas

Emit(OpCode, LocalBuilder)	Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) seguida del índice de la variable local indicada.
Emit(OpCode, Type)	Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) seguida del símbolo (token) de metadatos del tipo indicado.
Emit(OpCode, String)	Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) seguida del símbolo (token) de metadatos de la cadena indicada.
Emit(OpCode, Single)	Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, SByte)	Coloca la instrucción máquina y el argumento de carácter especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, MethodInfo)	Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) seguida del símbolo (token) de metadatos del método indicado.
Emit(OpCode, SignatureHelper)	Coloca la instrucción máquina especificada y un símbolo (token) de firma en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, Label[])	Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) y deja espacio para incluir una etiqueta cuando se efectúen correcciones.
Emit(OpCode, FieldInfo)	Coloca la instrucción máquina y el símbolo (token) de metadatos especificados del campo especificado en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, ConstructorInfo)	Coloca la instrucción máquina y el símbolo (token) de metadatos especificados del constructor especificado en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, Int64)	Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, Int32)	Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, Int16)	Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, Double)	Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode, Byte)	Coloca la instrucción máquina y el argumento de carácter especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).
Emit(OpCode)	Coloca la instrucción máquina especificada en la secuencia de instrucciones máquina.
Emit(OpCode, Label)	Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) y deja espacio para incluir una etiqueta cuando se efectúen correcciones.

Emit(OpCode, LocalBuilder)

Source:

ILGenerator.cs

Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) seguida del índice de la variable local indicada.

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

local

LocalBuilder

Variable local.

Excepciones

ArgumentException

El método primario de local no coincide con el método asociado a este ILGenerator.

ArgumentNullException

local es null.

InvalidOperationException

opcode es una instrucción máquina de un solo byte y local representa una variable local con un índice mayor que Byte.MaxValue.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode, Type)

Source:

ILGenerator.cs

Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) seguida del símbolo (token) de metadatos del tipo indicado.

C#

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

Parámetros

opcode

OpCode

Instrucción máquina MSIL que se va a colocar en la secuencia.

cls

Type

Objeto Type.

Excepciones

ArgumentNullException

cls es null.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración . La ubicación de cls se registra para que el token se pueda aplicar revisiones si es necesario al conservar el módulo en un archivo ejecutable portátil (PE).

Emit(OpCode, String)

Source:

ILGenerator.cs

Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) seguida del símbolo (token) de metadatos de la cadena indicada.

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

str

String

String que se va a emitir.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración . La ubicación de str se registra para futuras correcciones si el módulo se conserva en un archivo ejecutable portátil (PE).

Emit(OpCode, Single)

Source:

ILGenerator.cs

Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

Instrucción máquina MSIL que se va a colocar en la secuencia.

arg

Single

Argumento Single que se inserta en la secuencia inmediatamente después de la instrucción máquina.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode, SByte)

Source:

ILGenerator.cs

Importante

Esta API no es conforme a CLS.

Coloca la instrucción máquina y el argumento de carácter especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

Instrucción máquina MSIL que se va a colocar en la secuencia.

arg

SByte

Argumento de carácter insertado en la secuencia inmediatamente después de la instrucción máquina.

Atributos

CLSCompliantAttribute

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode, MethodInfo)

Source:

ILGenerator.cs

Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) seguida del símbolo (token) de metadatos del método indicado.

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

meth

MethodInfo

MethodInfo que representa un método.

Excepciones

ArgumentNullException

meth es null.

NotSupportedException

meth es un método genérico para el que la propiedad IsGenericMethodDefinition es false.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

La ubicación de meth se registra para que el flujo de instrucciones se pueda aplicar revisiones si es necesario al conservar el módulo en un archivo ejecutable portátil (PE).

Si meth representa un método genérico, debe ser una definición de método genérico. Es decir, su propiedad MethodInfo.IsGenericMethodDefinition debe ser true.

Emit(OpCode, SignatureHelper)

Source:

ILGenerator.cs

Coloca la instrucción máquina especificada y un símbolo (token) de firma en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

signature

SignatureHelper

Asistente para crear un símbolo (token) de firma.

Excepciones

ArgumentNullException

signature es null.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode, Label[])

Source:

ILGenerator.cs

Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) y deja espacio para incluir una etiqueta cuando se efectúen correcciones.

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

labels

Label[]

Matriz de objetos de etiqueta en la que se va a realizar la bifurcación desde esta posición. Se utilizan todas las etiquetas.

Excepciones

ArgumentNullException

con es null. Esta excepción es nueva en .NET Framework 4.

Ejemplos

En el ejemplo de código siguiente se muestra la creación de un método dinámico con una tabla de saltos. La tabla de saltos se crea mediante una matriz 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}));
   }
}

Comentarios

Emite una tabla switch.

Los valores de instrucción se definen en la OpCodes enumeración .

Las etiquetas se crean mediante DefineLabel y su ubicación dentro de la secuencia se fija mediante MarkLabel. Si se usa una instrucción de un solo byte, la etiqueta puede representar un salto de 127 bytes como máximo a lo largo de la secuencia. opcode debe representar una instrucción de rama. Dado que las ramas son instrucciones relativas, label se reemplazará por el desplazamiento correcto a la rama durante el proceso de corrección.

Emit(OpCode, FieldInfo)

Source:

ILGenerator.cs

Coloca la instrucción máquina y el símbolo (token) de metadatos especificados del campo especificado en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

field

FieldInfo

FieldInfo que representa un campo.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración . La ubicación de field se registra para que el flujo de instrucciones se pueda aplicar revisiones si es necesario al conservar el módulo en un archivo ejecutable portátil (PE).

Emit(OpCode, ConstructorInfo)

Source:

ILGenerator.cs

Coloca la instrucción máquina y el símbolo (token) de metadatos especificados del constructor especificado en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

con

ConstructorInfo

ConstructorInfo que representa un constructor.

Excepciones

ArgumentNullException

con es null. Esta excepción es nueva en .NET Framework 4.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

La ubicación de con se registra para que el flujo de instrucciones se pueda aplicar revisiones si es necesario al conservar el módulo en un archivo ejecutable portátil (PE).

Emit(OpCode, Int64)

Source:

ILGenerator.cs

Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

Instrucción máquina MSIL que se va a colocar en la secuencia.

arg

Int64

Argumento numérico que se inserta en la secuencia inmediatamente después de la instrucción máquina.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode, Int32)

Source:

ILGenerator.cs

Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

Instrucción máquina MSIL que se va a colocar en la secuencia.

arg

Int32

Argumento numérico que se inserta en la secuencia inmediatamente después de la instrucción máquina.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode, Int16)

Source:

ILGenerator.cs

Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

arg

Int16

Argumento Int que se inserta en la secuencia inmediatamente después de la instrucción máquina.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode, Double)

Source:

ILGenerator.cs

Coloca la instrucción máquina y el argumento numérico especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

Instrucción máquina MSIL que se va a colocar en la secuencia. Se define en la enumeración OpCodes.

arg

Double

Argumento numérico que se inserta en la secuencia inmediatamente después de la instrucción máquina.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode, Byte)

Source:

ILGenerator.cs

Coloca la instrucción máquina y el argumento de carácter especificados en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

C#

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

Parámetros

opcode

OpCode

Instrucción máquina MSIL que se va a colocar en la secuencia.

arg

Byte

Argumento de carácter insertado en la secuencia inmediatamente después de la instrucción máquina.

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Emit(OpCode)

Source:

ILGenerator.cs

Coloca la instrucción máquina especificada en la secuencia de instrucciones máquina.

C#

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

Parámetros

opcode

OpCode

Instrucción máquina del Lenguaje intermedio de Microsoft (MSIL) que se va a colocar en la secuencia.

Ejemplos

En el ejemplo de código siguiente se muestra el uso de Emit para generar la salida de MSIL a través de una instancia 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}));
   }
}

Comentarios

Si el opcode parámetro requiere un argumento, el autor de la llamada debe asegurarse de que la longitud del argumento coincide con la longitud del parámetro declarado. De lo contrario, los resultados serán impredecibles. Por ejemplo, si la instrucción Emit requiere un operando de 2 bytes y el autor de la llamada proporciona un operando de 4 bytes, el tiempo de ejecución emitirá dos bytes adicionales a la secuencia de instrucciones. Estos bytes adicionales serán Nop instrucciones.

Los valores de instrucción se definen en OpCodes.

Emit(OpCode, Label)

Source:

ILGenerator.cs

Coloca la instrucción máquina especificada en la secuencia del Lenguaje intermedio de Microsoft (MSIL) y deja espacio para incluir una etiqueta cuando se efectúen correcciones.

C#

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

Parámetros

opcode

OpCode

La instrucción MSIL que se emiten en la secuencia.

label

Label

Etiqueta a la que se va a saltar desde esta posición.

Ejemplos

En el ejemplo de código siguiente se muestra la creación de un método dinámico con una tabla de saltos. La tabla de saltos se crea mediante una matriz 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}));
   }
}

Comentarios

Los valores de instrucción se definen en la OpCodes enumeración .

Las etiquetas se crean mediante DefineLabely su ubicación dentro de la secuencia se fija mediante MarkLabel. Si se usa una instrucción de un solo byte, la etiqueta puede representar un salto de 127 bytes como máximo a lo largo de la secuencia. opcode debe representar una instrucción de rama. Dado que las ramas son instrucciones relativas, label se reemplazará por el desplazamiento correcto a la rama durante el proceso de corrección.