ILGenerator.Emit Método

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

Coloca uma instrução no fluxo do MSIL (Microsoft Intermediate Language) para o compilador JIT (Just-In-Time).

Sobrecargas

Emit(OpCode, LocalBuilder)	Coloca a instrução especificada no fluxo da MSIL (Microsoft Intermediate Language) seguido pelo índice da variável local fornecida.
Emit(OpCode, Type)	Coloca a instrução especificada no fluxo da MSIL (Microsoft Intermediate Language) seguido pelo token de metadados para o tipo fornecido.
Emit(OpCode, String)	Coloca a instrução especificada no fluxo da MSIL (Microsoft Intermediate Language) seguido pelo token de metadados para a cadeia de caracteres fornecida.
Emit(OpCode, Single)	Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, SByte)	Coloca a instrução especificada e o argumento de caractere no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, MethodInfo)	Coloca a instrução especificada no fluxo da MSIL (Microsoft Intermediate Language) seguido pelo token de metadados para o método fornecido.
Emit(OpCode, SignatureHelper)	Coloca a instrução especificada e o token de assinatura no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, Label[])	Coloca a instrução especificada para o fluxo da MSIL (Microsoft Intermediate Language) e deixa espaço para incluir um rótulo após a realização das correções.
Emit(OpCode, FieldInfo)	Coloca a instrução especificada e o token de metadados para o campo especificado no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, ConstructorInfo)	Coloca a instrução especificada e o token de metadados para o construtor especificado no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, Int64)	Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, Int32)	Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, Int16)	Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, Double)	Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode, Byte)	Coloca a instrução especificada e o argumento de caractere no fluxo de instruções da MSIL (Microsoft Intermediate Language).
Emit(OpCode)	Coloca a instrução especificada no fluxo de instruções.
Emit(OpCode, Label)	Coloca a instrução especificada para o fluxo da MSIL (Microsoft Intermediate Language) e deixa espaço para incluir um rótulo após a realização das correções.

Emit(OpCode, LocalBuilder)

Origem:

ILGenerator.cs

Coloca a instrução especificada no fluxo da MSIL (Microsoft Intermediate Language) seguido pelo índice da variável local fornecida.

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

local

LocalBuilder

Uma variável local.

Exceções

ArgumentException

O método pai do parâmetro local não corresponde ao método associado a este ILGenerator.

ArgumentNullException

local é null.

InvalidOperationException

opcode é uma instrução de byte único e local representa uma variável local com um índice maior que Byte.MaxValue.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode, Type)

Origem:

ILGenerator.cs

Coloca a instrução especificada no fluxo da MSIL (Microsoft Intermediate Language) seguido pelo token de metadados para o tipo fornecido.

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL a ser colocada no fluxo.

cls

Type

Um Type.

Exceções

ArgumentNullException

cls é null.

Comentários

Os valores de instrução são definidos na OpCodes enumeração . O local de cls é registrado para que o token possa ser corrigido, se necessário, ao persistir o módulo em um arquivo PE (executável portátil).

Emit(OpCode, String)

Origem:

ILGenerator.cs

Coloca a instrução especificada no fluxo da MSIL (Microsoft Intermediate Language) seguido pelo token de metadados para a cadeia de caracteres fornecida.

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

str

String

O String a ser emitido.

Comentários

Os valores de instrução são definidos na OpCodes enumeração . O local de str será registrado para correções futuras se o módulo for persistido em um arquivo PE (executável portátil).

Emit(OpCode, Single)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL a ser colocada no fluxo.

arg

Single

O argumento Single enviado por push para o fluxo imediatamente após a instrução.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode, SByte)

Origem:

ILGenerator.cs

Importante

Esta API não está em conformidade com CLS.

Coloca a instrução especificada e o argumento de caractere no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL a ser colocada no fluxo.

arg

SByte

O argumento de caractere enviado por push para o fluxo imediatamente após a instrução.

Atributos

CLSCompliantAttribute

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode, MethodInfo)

Origem:

ILGenerator.cs

Coloca a instrução especificada no fluxo da MSIL (Microsoft Intermediate Language) seguido pelo token de metadados para o método fornecido.

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

meth

MethodInfo

Um MethodInfo que representa um método.

Exceções

ArgumentNullException

meth é null.

NotSupportedException

meth é um método genérico para o qual a propriedade IsGenericMethodDefinition é false.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

O local de é registrado para que o fluxo de meth instruções possa ser corrigido, se necessário, ao persistir o módulo em um arquivo PE (executável portátil).

Se meth representar um método genérico, ele deverá ser uma definição de método genérico. Ou seja, sua propriedade MethodInfo.IsGenericMethodDefinition deve ser true.

Emit(OpCode, SignatureHelper)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o token de assinatura no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

signature

SignatureHelper

Um auxiliar para construir um token de assinatura.

Exceções

ArgumentNullException

signature é null.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode, Label[])

Origem:

ILGenerator.cs

Coloca a instrução especificada para o fluxo da MSIL (Microsoft Intermediate Language) e deixa espaço para incluir um rótulo após a realização das correções.

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

labels

Label[]

A matriz de objetos de rótulo para a qual ramificar deste local. Todos os rótulos serão usados.

Exceções

ArgumentNullException

con é null. Essa exceção é nova no .NET Framework 4.

Exemplos

O exemplo de código abaixo ilustra a criação de um método dinâmico com uma tabela de saltos. A tabela de salto é criada usando uma 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}));
   }
}

Comentários

Emite uma tabela de comutador.

Os valores de instrução são definidos na OpCodes enumeração .

Os rótulos são criados usando DefineLabel e sua localização dentro do fluxo é corrigida usando MarkLabel. Se uma instrução de byte único for usada, o rótulo poderá representar um salto de no máximo 127 bytes ao longo do fluxo. opcode deve representar uma instrução de branch. Como os branches são instruções relativas, label serão substituídos pelo deslocamento correto para branch durante o processo de correção.

Emit(OpCode, FieldInfo)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o token de metadados para o campo especificado no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

field

FieldInfo

Um FieldInfo que representa um campo.

Comentários

Os valores de instrução são definidos na OpCodes enumeração . O local de é registrado para que o fluxo de field instruções possa ser corrigido, se necessário, ao persistir o módulo em um arquivo PE (executável portátil).

Emit(OpCode, ConstructorInfo)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o token de metadados para o construtor especificado no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

con

ConstructorInfo

Um ConstructorInfo que representa um construtor.

Exceções

ArgumentNullException

con é null. Essa exceção é nova no .NET Framework 4.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

O local de é registrado para que o fluxo de con instruções possa ser corrigido, se necessário, ao persistir o módulo em um arquivo PE (executável portátil).

Emit(OpCode, Int64)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL a ser colocada no fluxo.

arg

Int64

O argumento numérico enviado por push para o fluxo imediatamente após a instrução.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode, Int32)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL a ser colocada no fluxo.

arg

Int32

O argumento numérico enviado por push para o fluxo imediatamente após a instrução.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode, Int16)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

arg

Int16

O argumento Int enviado por push para o fluxo imediatamente após a instrução.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode, Double)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o argumento numérico no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL a ser colocada no fluxo. Definido na enumeração OpCodes.

arg

Double

O argumento numérico enviado por push para o fluxo imediatamente após a instrução.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode, Byte)

Origem:

ILGenerator.cs

Coloca a instrução especificada e o argumento de caractere no fluxo de instruções da MSIL (Microsoft Intermediate Language).

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL a ser colocada no fluxo.

arg

Byte

O argumento de caractere enviado por push para o fluxo imediatamente após a instrução.

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Emit(OpCode)

Origem:

ILGenerator.cs

Coloca a instrução especificada no fluxo de instruções.

C#

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

Parâmetros

opcode

OpCode

A instrução do MSIL (Microsoft Intermediate Language) a ser colocada no fluxo.

Exemplos

O exemplo de código abaixo demonstra o uso de Emit para gerar saída MSIL por meio de uma instância do 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}));
   }
}

Comentários

Se o opcode parâmetro exigir um argumento, o chamador deverá garantir que o comprimento do argumento corresponda ao comprimento do parâmetro declarado. Caso contrário, os resultados serão imprevisíveis. Por exemplo, se a instrução Emit exigir um operando de 2 bytes e o chamador fornecer um operando de 4 bytes, o runtime emitirá dois bytes adicionais para o fluxo de instruções. Esses bytes extras serão Nop instruções.

Os valores de instrução são definidos em OpCodes.

Emit(OpCode, Label)

Origem:

ILGenerator.cs

Coloca a instrução especificada para o fluxo da MSIL (Microsoft Intermediate Language) e deixa espaço para incluir um rótulo após a realização das correções.

C#

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

Parâmetros

opcode

OpCode

A instrução MSIL para ser emitida para o fluxo.

label

Label

O rótulo para o qual ramificar deste local.

Exemplos

O exemplo de código abaixo ilustra a criação de um método dinâmico com uma tabela de saltos. A tabela de saltos é criada usando uma 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}));
   }
}

Comentários

Os valores de instrução são definidos na OpCodes enumeração .

Os rótulos são criados usando DefineLabele sua localização dentro do fluxo é corrigida usando MarkLabel. Se uma instrução de byte único for usada, o rótulo poderá representar um salto de no máximo 127 bytes ao longo do fluxo. opcode deve representar uma instrução de branch. Como os branches são instruções relativas, label serão substituídos pelo deslocamento correto para branch durante o processo de correção.