OpCodes.Switch Pole

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

netstandard.dll, System.Reflection.Primitives.dll

Zdroj:

OpCodes.cs

Implementuje tabulku odkazů.

public static readonly System.Reflection.Emit.OpCode Switch;

Hodnota pole

OpCode

Příklady

Následující ukázka kódu ukazuje použití Switch opcode k vygenerování tabulky jump pomocí pole Label.

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

Poznámky

Následující tabulka uvádí šestnáctkový formát sestavení instrukce a formát sestavení MSIL (Microsoft Intermediate Language) spolu se stručným přehledem referencí:

Formát	Formát sestavení	Description
45 <int32unsigned int32<>>...<int32>	přepínač (N, t1, t2... tN)	Přeskočí na jednu z N hodnot.

Přechodné chování zásobníku v sekvenčním pořadí je:

1. Hodnota se vloží do zásobníku.

2. Hodnota se vynoří ze zásobníku a spuštění se přenese do instrukce s posunem indexovaným hodnotou, kde je hodnota menší než N.

Instrukce switch implementuje tabulku odkazů. Formát instrukce představuje unsigned int32 počet cílů N, následovaný N hodnotami int32 určujícími cíle skoku. Tyto cíle jsou reprezentovány jako posuny (kladné nebo záporné) od začátku instrukce, která následuje za touto switch instrukcí.

Instrukce switch vyskočí hodnotu ze zásobníku a porovná ji jako celé číslo bez znaménka s N. Pokud je hodnota menší než N, provádění se přenese do cíle indexovaného hodnotou, kde jsou cíle číslovány od 0 (například hodnota 0 přebírá první cíl, hodnota 1 převezme druhý cíl atd.). Pokud je hodnota větší nebo rovna N, provádění pokračuje v další instrukci (fall through).

Pokud má cílová instrukce jeden nebo více kódů předpon, lze ovládací prvek přenést pouze na první z těchto předpon.

Pomocí této instrukce nelze provádět řídicí přenosy do a z trybloků , catchfilter, a finally . (Tyto převody jsou výrazně omezeny a musí místo toho používat pokyny k opuštění dovolené.)

Následující Emit přetížení metody může použít switch opcode. Argument Label[] je pole Popisky představující 32bitové posuny.

• ILGenerator.Emit(OpCode, Label[])