OpCodes Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

netstandard.dll, System.Reflection.Primitives.dll

Zdroj:

OpCodes.cs

Poskytuje reprezentaci polí pokynů jazyka MSIL (Microsoft Intermediate Language) pro emise členy třídy ILGenerator (například Emit(OpCode)).

public ref class OpCodes

public class OpCodes

type OpCodes = class

Public Class OpCodes

Dědičnost

Object

OpCodes

Příklady

Následující příklad ukazuje konstrukci dynamické metody pomocí ILGenerator emitování OpCodes do .MethodBuilder

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

class EmitWriteLineDemo {

   public static Type CreateDynamicType() {
       Type[] ctorParams = new Type[] {typeof(int),
                   typeof(int)};
    
       AppDomain myDomain = Thread.GetDomain();
       AssemblyName myAsmName = new AssemblyName();
       myAsmName.Name = "MyDynamicAssembly";

       AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                      myAsmName,
                      AssemblyBuilderAccess.Run);

       ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
                                    "Point.dll");

       TypeBuilder pointTypeBld = pointModule.DefineType("Point",
                                  TypeAttributes.Public);

       FieldBuilder xField = pointTypeBld.DefineField("x", typeof(int),
                                                      FieldAttributes.Public);
       FieldBuilder yField = pointTypeBld.DefineField("y", typeof(int),
                                                      FieldAttributes.Public);

       Type objType = Type.GetType("System.Object");
       ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

       ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
                                   MethodAttributes.Public,
                                   CallingConventions.Standard,
                                   ctorParams);
       ILGenerator ctorIL = pointCtor.GetILGenerator();

       // First, you build the constructor.
       ctorIL.Emit(OpCodes.Ldarg_0);
       ctorIL.Emit(OpCodes.Call, objCtor);
       ctorIL.Emit(OpCodes.Ldarg_0);
       ctorIL.Emit(OpCodes.Ldarg_1);
       ctorIL.Emit(OpCodes.Stfld, xField);
       ctorIL.Emit(OpCodes.Ldarg_0);
       ctorIL.Emit(OpCodes.Ldarg_2);
       ctorIL.Emit(OpCodes.Stfld, yField);
       ctorIL.Emit(OpCodes.Ret);

       //  Now, you'll build a method to output some information on the
       // inside your dynamic class. This method will have the following
       // definition in C#:
    //  public void WritePoint()

       MethodBuilder writeStrMthd = pointTypeBld.DefineMethod(
                                     "WritePoint",
                             MethodAttributes.Public,
                                             typeof(void),
                                             null);

       ILGenerator writeStrIL = writeStrMthd.GetILGenerator();

       // The below ILGenerator created demonstrates a few ways to create
       // string output through STDIN.

       // ILGenerator.EmitWriteLine(string) will generate a ldstr and a
       // call to WriteLine for you.

       writeStrIL.EmitWriteLine("The value of this current instance is:");

       // Here, you will do the hard work yourself. First, you need to create
       // the string we will be passing and obtain the correct WriteLine overload
       // for said string. In the below case, you are substituting in two values,
       // so the chosen overload is Console.WriteLine(string, object, object).

       String inStr = "({0}, {1})";
       Type[] wlParams = new Type[] {typeof(string),
                     typeof(object),
                     typeof(object)};

       // We need the MethodInfo to pass into EmitCall later.

       MethodInfo writeLineMI = typeof(Console).GetMethod(
                            "WriteLine",
                        wlParams);

       // Push the string with the substitutions onto the stack.
       // This is the first argument for WriteLine - the string one.

       writeStrIL.Emit(OpCodes.Ldstr, inStr);

       // Since the second argument is an object, and it corresponds to
       // to the substitution for the value of our integer field, you
       // need to box that field to an object. First, push a reference
       // to the current instance, and then push the value stored in
       // field 'x'. We need the reference to the current instance (stored
       // in local argument index 0) so Ldfld can load from the correct
       // instance (this one).

       writeStrIL.Emit(OpCodes.Ldarg_0);
       writeStrIL.Emit(OpCodes.Ldfld, xField);

       // Now, we execute the box opcode, which pops the value of field 'x',
       // returning a reference to the integer value boxed as an object.

       writeStrIL.Emit(OpCodes.Box, typeof(int));

       // Atop the stack, you'll find our string inStr, followed by a reference
       // to the boxed value of 'x'. Now, you need to likewise box field 'y'.

       writeStrIL.Emit(OpCodes.Ldarg_0);
       writeStrIL.Emit(OpCodes.Ldfld, yField);
       writeStrIL.Emit(OpCodes.Box, typeof(int));

       // Now, you have all of the arguments for your call to
       // Console.WriteLine(string, object, object) atop the stack:
       // the string InStr, a reference to the boxed value of 'x', and
       // a reference to the boxed value of 'y'.

       // Call Console.WriteLine(string, object, object) with EmitCall.

       writeStrIL.EmitCall(OpCodes.Call, writeLineMI, null);

       // Lastly, EmitWriteLine can also output the value of a field
       // using the overload EmitWriteLine(FieldInfo).

       writeStrIL.EmitWriteLine("The value of 'x' is:");
       writeStrIL.EmitWriteLine(xField);
       writeStrIL.EmitWriteLine("The value of 'y' is:");
       writeStrIL.EmitWriteLine(yField);

       // Since we return no value (void), the ret opcode will not
       // return the top stack value.

       writeStrIL.Emit(OpCodes.Ret);

       return pointTypeBld.CreateType();
   }

   public static void Main() {

      object[] ctorParams = new object[2];

      Console.Write("Enter a integer value for X: ");
      string myX = Console.ReadLine();
      Console.Write("Enter a integer value for Y: ");
      string myY = Console.ReadLine();

      Console.WriteLine("---");

      ctorParams[0] = Convert.ToInt32(myX);
      ctorParams[1] = Convert.ToInt32(myY);

      Type ptType = CreateDynamicType();

      object ptInstance = Activator.CreateInstance(ptType, ctorParams);
      ptType.InvokeMember("WritePoint",
              BindingFlags.InvokeMethod,
              null,
              ptInstance,
              new object[0]);
   }
}

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

 _

Class EmitWriteLineDemo
   
   
   Public Shared Function CreateDynamicType() As Type

      Dim ctorParams() As Type = {GetType(Integer), GetType(Integer)}
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
      
      Dim pointModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("PointModule", "Point.dll")
      
      Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", _
                                   TypeAttributes.Public)
      
      Dim xField As FieldBuilder = pointTypeBld.DefineField("x", _
                                GetType(Integer), _
                                FieldAttributes.Public)
      Dim yField As FieldBuilder = pointTypeBld.DefineField("y", _
                                GetType(Integer), _
                                FieldAttributes.Public)
      
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type(){})
      
      Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor( _
                             MethodAttributes.Public, _
                             CallingConventions.Standard, _
                             ctorParams)
      Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
      
      
      ' First, you build the constructor.

      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Call, objCtor)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      ctorIL.Emit(OpCodes.Ret)
      
      '  Now, you'll build a method to output some information on the
      ' inside your dynamic class. This method will have the following
      ' definition in C#:
      '  Public Sub WritePoint() 

      Dim writeStrMthd As MethodBuilder = pointTypeBld.DefineMethod("WritePoint", _
                                    MethodAttributes.Public, _
                                    Nothing, Nothing)
      
      Dim writeStrIL As ILGenerator = writeStrMthd.GetILGenerator()
      
      ' The below ILGenerator created demonstrates a few ways to create
      ' string output through STDIN. 
      ' ILGenerator.EmitWriteLine(string) will generate a ldstr and a 
      ' call to WriteLine for you.

      writeStrIL.EmitWriteLine("The value of this current instance is:")
      
      ' Here, you will do the hard work yourself. First, you need to create
      ' the string we will be passing and obtain the correct WriteLine overload
      ' for said string. In the below case, you are substituting in two values,
      ' so the chosen overload is Console.WriteLine(string, object, object).

      Dim inStr As [String] = "({0}, {1})"
      Dim wlParams() As Type = {GetType(String), GetType(Object), GetType(Object)}
      
      ' We need the MethodInfo to pass into EmitCall later.

      Dim writeLineMI As MethodInfo = GetType(Console).GetMethod("WriteLine", wlParams)
      
      ' Push the string with the substitutions onto the stack.
      ' This is the first argument for WriteLine - the string one. 

      writeStrIL.Emit(OpCodes.Ldstr, inStr)
      
      ' Since the second argument is an object, and it corresponds to
      ' to the substitution for the value of our integer field, you 
      ' need to box that field to an object. First, push a reference
      ' to the current instance, and then push the value stored in
      ' field 'x'. We need the reference to the current instance (stored
      ' in local argument index 0) so Ldfld can load from the correct
      ' instance (this one).

      writeStrIL.Emit(OpCodes.Ldarg_0)
      writeStrIL.Emit(OpCodes.Ldfld, xField)
      
      ' Now, we execute the box opcode, which pops the value of field 'x',
      ' returning a reference to the integer value boxed as an object.

      writeStrIL.Emit(OpCodes.Box, GetType(Integer))
      
      ' Atop the stack, you'll find our string inStr, followed by a reference
      ' to the boxed value of 'x'. Now, you need to likewise box field 'y'.

      writeStrIL.Emit(OpCodes.Ldarg_0)
      writeStrIL.Emit(OpCodes.Ldfld, yField)
      writeStrIL.Emit(OpCodes.Box, GetType(Integer))
      
      ' Now, you have all of the arguments for your call to
      ' Console.WriteLine(string, object, object) atop the stack:
      ' the string InStr, a reference to the boxed value of 'x', and
      ' a reference to the boxed value of 'y'.
      ' Call Console.WriteLine(string, object, object) with EmitCall.

      writeStrIL.EmitCall(OpCodes.Call, writeLineMI, Nothing)
      
      ' Lastly, EmitWriteLine can also output the value of a field
      ' using the overload EmitWriteLine(FieldInfo).

      writeStrIL.EmitWriteLine("The value of 'x' is:")
      writeStrIL.EmitWriteLine(xField)
      writeStrIL.EmitWriteLine("The value of 'y' is:")
      writeStrIL.EmitWriteLine(yField)
      
      ' Since we return no value (void), the ret opcode will not
      ' return the top stack value.

      writeStrIL.Emit(OpCodes.Ret)
      
      Return pointTypeBld.CreateType()

   End Function 'CreateDynamicType
    
   
   Public Shared Sub Main()
      
      Dim ctorParams(1) As Object
      
      Console.Write("Enter a integer value for X: ")
      Dim myX As String = Console.ReadLine()
      Console.Write("Enter a integer value for Y: ")
      Dim myY As String = Console.ReadLine()
      
      Console.WriteLine("---")
      
      ctorParams(0) = Convert.ToInt32(myX)
      ctorParams(1) = Convert.ToInt32(myY)
      
      Dim ptType As Type = CreateDynamicType()

      Dim ptInstance As Object = Activator.CreateInstance(ptType, ctorParams)

      ptType.InvokeMember("WritePoint", _
              BindingFlags.InvokeMethod, _
              Nothing, ptInstance, Nothing)

   End Sub

End Class

Poznámky

Podrobný popis členských operačních kódů najdete v dokumentaci k common language infrastructure (CLI), zejména oddíl III: Sada instrukcí CIL a Oddíl II: Definice metadat a sémantika. Další informace najdete v tématu ECMA 335 Common Language Infrastructure (CLI).

Pole

Name	Description
Add	Přidá dvě hodnoty a výsledek nasdílí do zásobníku vyhodnocení.
Add_Ovf	Přidá dvě celá čísla, provede kontrolu přetečení a nasdílí výsledek do zásobníku vyhodnocení.
Add_Ovf_Un	Přidá dvě celočíselné hodnoty bez znaménka, provede kontrolu přetečení a nasdílí výsledek do zásobníku vyhodnocení.
And	Vypočítá bitový operátor AND dvou hodnot a nasdílí výsledek do zásobníku vyhodnocení.
Arglist	Vrátí nespravovaný ukazatel na seznam argumentů aktuální metody.
Beq	Přenese řízení na cílovou instrukci, pokud jsou dvě hodnoty stejné.
Beq_S	Převede řízení na cílovou instrukci (krátký formulář), pokud jsou dvě hodnoty stejné.
Bge	Převede řízení na cílovou instrukci, pokud je první hodnota větší nebo rovna druhé hodnotě.
Bge_S	Převede řízení na cílovou instrukci (krátký formulář), pokud je první hodnota větší nebo rovna druhé hodnotě.
Bge_Un	Převede řízení na cílovou instrukci, pokud je první hodnota větší než druhá hodnota při porovnávání celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Bge_Un_S	Přenese řízení na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota, při porovnávání celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Bgt	Převede řízení na cílovou instrukci, pokud je první hodnota větší než druhá hodnota.
Bgt_S	Převede řízení na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota.
Bgt_Un	Převede řízení na cílovou instrukci, pokud je první hodnota větší než druhá hodnota při porovnávání celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Bgt_Un_S	Přenese řízení na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota, při porovnávání celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Ble	Převede řízení na cílovou instrukci, pokud je první hodnota menší nebo rovna druhé hodnotě.
Ble_S	Převede řízení na cílovou instrukci (krátký formulář), pokud je první hodnota menší nebo rovna druhé hodnotě.
Ble_Un	Převede řízení na cílovou instrukci, pokud je první hodnota menší nebo rovna druhé hodnotě, při porovnávání celočíselné hodnoty bez znaménka nebo neuspořádané plovoucí hodnoty.
Ble_Un_S	Převede řízení na cílovou instrukci (krátký formulář), pokud je první hodnota menší nebo rovna druhé hodnotě, při porovnávání celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Blt	Převede řízení na cílovou instrukci, pokud je první hodnota menší než druhá hodnota.
Blt_S	Převede řízení na cílovou instrukci (krátký formulář), pokud je první hodnota menší než druhá hodnota.
Blt_Un	Převede řízení na cílovou instrukci, pokud je první hodnota menší než druhá hodnota při porovnávání celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Blt_Un_S	Převede řízení na cílovou instrukci (krátký formulář), pokud je první hodnota menší než druhá hodnota při porovnávání celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Bne_Un	Přenese řízení na cílovou instrukci, pokud nejsou stejné dvě celočíselné hodnoty nebo neuspořádané hodnoty float.
Bne_Un_S	Přenese řízení do cílové instrukce (krátký formulář), pokud se dvě celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float nerovnají.
Box	Převede typ hodnoty na odkaz na objekt (typ O).
Br	Bezpodmínečně přenáší kontrolu na cílovou instrukci.
Br_S	Bezpodmínečně přenáší řízení na cílovou instrukci (krátká forma).
Break	Signalizuje infrastrukturu common language infrastructure (CLI) k informování ladicího programu, že došlo k přerušení bodu.
Brfalse	Přenese řízení na cílovou instrukci, pokud je valuefalse, nulový odkaz (Nothing v Visual Basic) nebo nula.
Brfalse_S	Přenese řízení na cílovou instrukci, pokud value je false, odkaz null nebo nula.
Brtrue	Přenese řízení na cílovou instrukci, pokud value není truenull nebo nenulová.
Brtrue_S	Převede řízení na cílovou instrukci (krátký formulář), pokud value není truenull nebo nenulová.
Call	Volá metodu označenou předanou popisovačem metody.
Calli	Volá metodu uvedenou ve zkušebním zásobníku (jako ukazatel na vstupní bod) s argumenty popsanými konvencí volání.
Callvirt	Volá metodu s pozdní vazbou na objekt a nasdílí návratovou hodnotu do zásobníku vyhodnocení.
Castclass	Pokusí se přetypovat objekt předaný odkazem na zadanou třídu.
Ceq	Porovná dvě hodnoty. Jsou-li rovny, celočíselná hodnota 1 (int32) je vložena do vyhodnocovacího zásobníku; jinak je 0 (int32) vloženo do zkušebního zásobníku.
Cgt	Porovná dvě hodnoty. Pokud je první hodnota větší než druhá, celočíselná hodnota 1 (int32) se vloží do vyhodnocovacího zásobníku; jinak je 0 (int32) vloženo do zkušebního zásobníku.
Cgt_Un	Porovná dvě neseřazené nebo neuspořádané hodnoty. Pokud je první hodnota větší než druhá, celočíselná hodnota 1 (int32) se vloží do vyhodnocovacího zásobníku; jinak je 0 (int32) vloženo do zkušebního zásobníku.
Ckfinite	ArithmeticException Vyvolá chybu, pokud hodnota není konečným číslem.
Clt	Porovná dvě hodnoty. Pokud je první hodnota menší než druhá, celočíselná hodnota 1 (int32) se vloží do zásobníku vyhodnocení; jinak je 0 (int32) vloženo do zkušebního zásobníku.
Clt_Un	Porovná nepodepsané nebo neuspořádané hodnoty value1 a value2. Pokud value1 je menší než value2, pak se celočíselná hodnota 1 (int32) vloží do zkušebního zásobníku; jinak se 0 (int32) vloží do zásobníku vyhodnocení.
Constrained	Omezuje typ, na kterém se provádí volání virtuální metody.
Conv_I	Převede hodnotu nad zkušební zásobník na native inthodnotu .
Conv_I1	Převede hodnotu nad zkušební zásobník na int8, pak rozšíří (oblasti) na int32.
Conv_I2	Převede hodnotu nad zkušební zásobník na int16, pak rozšíří (oblasti) na int32.
Conv_I4	Převede hodnotu nad zkušební zásobník na int32hodnotu .
Conv_I8	Převede hodnotu nad zkušební zásobník na int64hodnotu .
Conv_Ovf_I	Převede podepsanou hodnotu nad zkušební zásobník na podepsanou native int, vyvolání OverflowException při přetečení.
Conv_Ovf_I_Un	Převede nepodepsanou hodnotu nad zkušební zásobník na podepsanou native int, vyvolání OverflowException při přetečení.
Conv_Ovf_I1	Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou int8 a rozšíří ji na int32, která se vyvolá OverflowException při přetečení.
Conv_Ovf_I1_Un	Převede nepodepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou int8 a rozšíří ji na int32, vyvolání OverflowException při přetečení.
Conv_Ovf_I2	Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou int16 a rozšíří ji na int32, vyvolání OverflowException při přetečení.
Conv_Ovf_I2_Un	Převede nepodepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou int16 a rozšíří ji na int32, vyvolání OverflowException při přetečení.
Conv_Ovf_I4	Převede podepsanou hodnotu nad zkušební zásobník na podepsanou int32, vyvolání OverflowException při přetečení.
Conv_Ovf_I4_Un	Převede nepodepsanou hodnotu nad zkušební zásobník na podepsanou int32, vyvolání OverflowException při přetečení.
Conv_Ovf_I8	Převede podepsanou hodnotu nad zkušební zásobník na podepsanou int64, vyvolání OverflowException při přetečení.
Conv_Ovf_I8_Un	Převede nepodepsanou hodnotu nad zkušební zásobník na podepsanou int64, vyvolání OverflowException při přetečení.
Conv_Ovf_U	Převede podepsanou hodnotu nad zásobníkem vyhodnocení na unsigned native intvyvolání OverflowException přetečení.
Conv_Ovf_U_Un	Převede nepodepsanou hodnotu nad zásobníkem vyhodnocení na unsigned native intvyvolání OverflowException přetečení.
Conv_Ovf_U1	Převede podepsanou hodnotu nad zásobníkem unsigned int8 vyhodnocení a rozšíří ji na int32, vyvolání OverflowException při přetečení.
Conv_Ovf_U1_Un	Převede nepodepsanou hodnotu nad zásobníkem unsigned int8 vyhodnocení a rozšíří ji na int32, vyvolání OverflowException při přetečení.
Conv_Ovf_U2	Převede podepsanou hodnotu nad zásobníkem unsigned int16 vyhodnocení a rozšíří ji na int32, vyvolání OverflowException při přetečení.
Conv_Ovf_U2_Un	Převede nepodepsanou hodnotu nad zásobníkem unsigned int16 vyhodnocení a rozšíří ji na int32, vyvolání OverflowException při přetečení.
Conv_Ovf_U4	Převede podepsanou hodnotu nad zásobníkem vyhodnocení na unsigned int32vyvolání OverflowException přetečení.
Conv_Ovf_U4_Un	Převede nepodepsanou hodnotu nad zásobníkem vyhodnocení na unsigned int32vyvolání OverflowException přetečení.
Conv_Ovf_U8	Převede podepsanou hodnotu nad zásobníkem vyhodnocení na unsigned int64vyvolání OverflowException přetečení.
Conv_Ovf_U8_Un	Převede nepodepsanou hodnotu nad zásobníkem vyhodnocení na unsigned int64vyvolání OverflowException přetečení.
Conv_R_Un	Převede celočíselnou hodnotu bez znaménka nad zkušební zásobník na float32hodnotu .
Conv_R4	Převede hodnotu nad zkušební zásobník na float32hodnotu .
Conv_R8	Převede hodnotu nad zkušební zásobník na float64hodnotu .
Conv_U	Převede hodnotu nad zkušební zásobník na unsigned native inthodnotu a rozšíří ji na native int.
Conv_U1	Převede hodnotu nad zkušební zásobník na unsigned int8hodnotu a rozšíří ji na int32.
Conv_U2	Převede hodnotu nad zkušební zásobník na unsigned int16hodnotu a rozšíří ji na int32.
Conv_U4	Převede hodnotu nad zkušební zásobník na unsigned int32hodnotu a rozšíří ji na int32.
Conv_U8	Převede hodnotu nad zkušební zásobník na unsigned int64hodnotu a rozšíří ji na int64.
Cpblk	Zkopíruje zadaný počet bajtů ze zdrojové adresy na cílovou adresu.
Cpobj	Zkopíruje typ hodnoty umístěný na adrese objektu (typ &nebo) na adresu cílového objektu (typ nebo native int&).native int
Div	Rozdělí dvě hodnoty a výsledek nasdílí jako plovoucí desetinu (typ F) nebo quotient (typ int32) do vyhodnocovací zásobníku.
Div_Un	Rozdělí dvě celočíselné hodnoty bez znaménka a nasdílí výsledek (int32) do zkušebního zásobníku.
Dup	Zkopíruje aktuální nejvyšší hodnotu v zásobníku vyhodnocení a pak nasdílí kopii do zásobníku vyhodnocení.
Endfilter	Přenese řízení z filter klauzule výjimky zpět do obslužné rutiny výjimky Common Language Infrastructure (CLI).
Endfinally	Přenese řízení z fault bloku výjimky nebo finally klauzule zpět do obslužné rutiny výjimky Common Language Infrastructure (CLI).
Initblk	Inicializuje zadaný blok paměti na konkrétní adresu na danou velikost a počáteční hodnotu.
Initobj	Inicializuje každé pole typu hodnoty na zadanou adresu na odkaz null nebo 0 z příslušného primitivního typu.
Isinst	Testuje, zda je odkaz na objekt (typ O) instance konkrétní třídy.
Jmp	Ukončí aktuální metodu a přeskočí na zadanou metodu.
Ldarg	Načte do zásobníku argument (odkazovaný zadanou hodnotou indexu).
Ldarg_0	Načte argument na index 0 do zkušebního zásobníku.
Ldarg_1	Načte argument na index 1 do zkušebního zásobníku.
Ldarg_2	Načte argument na index 2 do zkušebního zásobníku.
Ldarg_3	Načte argument na index 3 do zásobníku vyhodnocení.
Ldarg_S	Načte argument (odkazovaný zadaným indexem krátkého formuláře) do zásobníku vyhodnocení.
Ldarga	Načtěte adresu argumentu do zkušebního zásobníku.
Ldarga_S	Načtěte adresu argumentu ve krátké podobě do zásobníku vyhodnocení.
Ldc_I4	Vloží zadanou hodnotu typu int32 do zkušebního zásobníku int32jako hodnotu .
Ldc_I4_0	Nasdílí celočíselnou hodnotu 0 do vyhodnocovacího zásobníku int32jako hodnotu .
Ldc_I4_1	Nasdílí celočíselnou hodnotu 1 do vyhodnocovacího zásobníku int32jako hodnotu .
Ldc_I4_2	Nasdílí celočíselnou hodnotu 2 do vyhodnocovacího zásobníku int32jako hodnotu .
Ldc_I4_3	Nasdílí celočíselnou hodnotu 3 do zkušebního zásobníku int32jako hodnotu .
Ldc_I4_4	Nasdílí celočíselnou hodnotu 4 do vyhodnocovacího zásobníku int32jako hodnotu .
Ldc_I4_5	Nasdílí celočíselnou hodnotu 5 do vyhodnocovacího zásobníku int32jako hodnotu .
Ldc_I4_6	Nasdílí celočíselnou hodnotu 6 do vyhodnocovacího zásobníku jako hodnotu int32.
Ldc_I4_7	Nasdílí celočíselnou hodnotu 7 do vyhodnocovacího zásobníku int32jako hodnotu .
Ldc_I4_8	Nasdílí celočíselnou hodnotu 8 do vyhodnocovacího zásobníku int32jako hodnotu .
Ldc_I4_M1	Nasdílí celočíselnou hodnotu -1 do vyhodnocovacího zásobníku jako hodnotu int32.
Ldc_I4_S	Vloží zadanou int8int32hodnotu do zkušebního zásobníku jako krátký formulář.
Ldc_I8	Vloží zadanou hodnotu typu int64 do zkušebního zásobníku int64jako hodnotu .
Ldc_R4	Vloží zadanou hodnotu typu float32 do zkušebního zásobníku jako typ F (float).
Ldc_R8	Vloží zadanou hodnotu typu float64 do zkušebního zásobníku jako typ F (float).
Ldelem	Načte prvek v zadaném indexu pole na začátek zkušebního zásobníku jako typ zadaný v instrukci.
Ldelem_I	Načte prvek s typem native int v zadaném indexu pole na začátek zkušebního zásobníku jako .native int
Ldelem_I1	Načte prvek s typem int8 v zadaném indexu pole na začátek vyhodnocovací zásobníku jako .int32
Ldelem_I2	Načte prvek s typem int16 v zadaném indexu pole na začátek vyhodnocovací zásobníku jako .int32
Ldelem_I4	Načte prvek s typem int32 v zadaném indexu pole na začátek vyhodnocovací zásobníku jako .int32
Ldelem_I8	Načte prvek s typem int64 v zadaném indexu pole na začátek vyhodnocovací zásobníku jako .int64
Ldelem_R4	Načte prvek s typem float32 v zadaném indexu pole na začátek zkušebního zásobníku jako typ F (float).
Ldelem_R8	Načte prvek s typem float64 v zadaném indexu pole na začátek zkušebního zásobníku jako typ F (float).
Ldelem_Ref	Načte prvek obsahující odkaz na objekt v zadaném indexu pole na začátek vyhodnocovací zásobníku jako typ O (odkaz na objekt).
Ldelem_U1	Načte prvek s typem unsigned int8 v zadaném indexu pole na začátek vyhodnocovací zásobníku jako .int32
Ldelem_U2	Načte prvek s typem unsigned int16 v zadaném indexu pole na začátek vyhodnocovací zásobníku jako .int32
Ldelem_U4	Načte prvek s typem unsigned int32 v zadaném indexu pole na začátek vyhodnocovací zásobníku jako .int32
Ldelema	Načte adresu prvku pole v zadaném indexu pole na začátek zkušebního zásobníku jako typ & (spravovaný ukazatel).
Ldfld	Vyhledá hodnotu pole v objektu, jehož odkaz je aktuálně ve zkušebním zásobníku.
Ldflda	Vyhledá adresu pole v objektu, jehož odkaz je aktuálně ve zkušebním zásobníku.
Ldftn	Nasdílí nespravovaný ukazatel (typ native int) nativnímu kódu implementovanému konkrétní metodu do zásobníku vyhodnocení.
Ldind_I	Načte hodnotu typu native int jako hodnotu native int do zásobníku vyhodnocení nepřímo.
Ldind_I1	Načte hodnotu typu int8 jako objekt int32 do zkušebního zásobníku nepřímo.
Ldind_I2	Načte hodnotu typu int16 jako objekt int32 do zkušebního zásobníku nepřímo.
Ldind_I4	Načte hodnotu typu int32 jako objekt int32 do zkušebního zásobníku nepřímo.
Ldind_I8	Načte hodnotu typu int64 jako objekt int64 do zkušebního zásobníku nepřímo.
Ldind_R4	Načte hodnotu typu float32 jako typ F (float) do zkušebního zásobníku nepřímo.
Ldind_R8	Načte hodnotu typu float64 jako typ F (float) do zkušebního zásobníku nepřímo.
Ldind_Ref	Načte odkaz na objekt jako typ O (odkaz na objekt) do zásobníku vyhodnocení nepřímo.
Ldind_U1	Načte hodnotu typu unsigned int8 jako objekt int32 do zkušebního zásobníku nepřímo.
Ldind_U2	Načte hodnotu typu unsigned int16 jako objekt int32 do zkušebního zásobníku nepřímo.
Ldind_U4	Načte hodnotu typu unsigned int32 jako objekt int32 do zkušebního zásobníku nepřímo.
Ldlen	Nasdílí počet prvků jednorozměrného pole založeného na nule do zásobníku vyhodnocení.
Ldloc	Načte místní proměnnou v určitém indexu do zásobníku vyhodnocení.
Ldloc_0	Načte místní proměnnou na index 0 do zásobníku vyhodnocení.
Ldloc_1	Načte místní proměnnou na index 1 do zásobníku vyhodnocení.
Ldloc_2	Načte místní proměnnou na index 2 do zásobníku vyhodnocení.
Ldloc_3	Načte místní proměnnou na index 3 do zásobníku vyhodnocení.
Ldloc_S	Načte místní proměnnou v určitém indexu do zásobníku vyhodnocení ve stručné podobě.
Ldloca	Načte adresu místní proměnné na určitý index do zásobníku vyhodnocení.
Ldloca_S	Načte adresu místní proměnné na určitý index do zásobníku vyhodnocení ve stručné podobě.
Ldnull	Vloží odkaz null (typ O) do zásobníku vyhodnocení.
Ldobj	Zkopíruje objekt typu hodnoty, na který odkazuje adresa, na začátek zásobníku vyhodnocení.
Ldsfld	Nasdílí hodnotu statického pole do zásobníku vyhodnocení.
Ldsflda	Nasdílí adresu statického pole do zásobníku vyhodnocení.
Ldstr	Vloží nový odkaz na objekt do řetězcového literálu uloženého v metadatech.
Ldtoken	Převede token metadat na jeho reprezentaci za běhu a nasdílí ho do zásobníku vyhodnocení.
Ldvirtftn	Vloží nespravovaný ukazatel (typ native int) do nativního kódu implementovaného konkrétní virtuální metodu přidruženou k zadanému objektu do zásobníku vyhodnocení.
Leave	Ukončí chráněnou oblast kódu a bezpodmínečně převede kontrolu na konkrétní cílovou instrukci.
Leave_S	Ukončí chráněnou oblast kódu, bezpodmínečně přenáší řízení na cílovou instrukci (krátký formulář).
Localloc	Přidělí určitý počet bajtů z místního fondu dynamické paměti a odešle adresu (přechodný ukazatel, typ *) prvního přiděleného bajtu do zásobníku vyhodnocení.
Mkrefany	Nasdílí typový odkaz na instanci konkrétního typu do zásobníku vyhodnocení.
Mul	Vynásobí dvě hodnoty a nasdílí výsledek do zásobníku vyhodnocení.
Mul_Ovf	Vynásobí dvě celočíselné hodnoty, provede kontrolu přetečení a výsledek nasdílí do zásobníku vyhodnocení.
Mul_Ovf_Un	Vynásobí dvě celočíselné hodnoty bez znaménka, provede kontrolu přetečení a výsledek nasdílí do zásobníku vyhodnocení.
Neg	Neguje hodnotu a nasdílí výsledek do zásobníku vyhodnocení.
Newarr	Vloží odkaz na objekt do nového jednorozměrného pole založeného na nule, jehož prvky jsou určitého typu, do zásobníku vyhodnocení.
Newobj	Vytvoří nový objekt nebo novou instanci typu hodnoty a nasdílí odkaz na objekt (typ O) do zásobníku vyhodnocení.
Nop	Vyplní mezeru, pokud jsou opcode opraveny. Žádná smysluplná operace se neprovádí, i když je možné spotřebovat cyklus zpracování.
Not	Vypočítá bitový doplněk celočíselné hodnoty nad zásobníkem a nasdílí výsledek do vyhodnocovacího zásobníku jako stejný typ.
Or	Vypočítá bitový doplněk dvou celočíselné hodnoty nad zásobníkem a nasdílí výsledek do vyhodnocovacího zásobníku.
Pop	Odebere hodnotu, která je aktuálně nad zásobníkem vyhodnocení.
Prefix1	Toto je rezervovaná instrukce.
Prefix2	Toto je rezervovaná instrukce.
Prefix3	Toto je rezervovaná instrukce.
Prefix4	Toto je rezervovaná instrukce.
Prefix5	Toto je rezervovaná instrukce.
Prefix6	Toto je rezervovaná instrukce.
Prefix7	Toto je rezervovaná instrukce.
Prefixref	Toto je rezervovaná instrukce.
Readonly	Určuje, že následná operace adresy pole neprovádí žádnou kontrolu typu za běhu a že vrací spravovaný ukazatel, jehož proměnlivost je omezená.
Refanytype	Načte token typu vložený do typového odkazu.
Refanyval	Načte adresu (typ &) vloženou do typového odkazu.
Rem	Rozdělí dvě hodnoty a nasdílí zbytek do zkušebního zásobníku.
Rem_Un	Rozdělí dvě nepodepsané hodnoty a nasdílí zbytek do zásobníku vyhodnocení.
Ret	Vrátí hodnotu z aktuální metody, která nasdílí návratovou hodnotu (pokud je k dispozici) ze zásobníku vyhodnocení volané do zásobníku vyhodnocení volajícího.
Rethrow	Znovu načítá aktuální výjimku.
Shl	Posune celočíselnou hodnotu doleva (v nulách) o zadaný počet bitů a posune výsledek do zásobníku vyhodnocení.
Shr	Posune celočíselnou hodnotu (znaménko) doprava o zadaný počet bitů a posune výsledek do vyhodnocovacího zásobníku.
Shr_Un	Posune celočíselnou hodnotu bez znaménka (v nulách) doprava o zadaný počet bitů a posune výsledek do vyhodnocovacího zásobníku.
Sizeof	Nasdílí velikost zadaného typu hodnoty v bajtech do zásobníku vyhodnocení.
Starg	Uloží hodnotu nad zásobník vyhodnocení v slotu argumentu v zadaném indexu.
Starg_S	Uloží hodnotu nad zásobník vyhodnocení v slotu argumentu v zadaném indexu krátkém formátu.
Stelem	Nahradí prvek pole v daném indexu hodnotou ve zkušebním zásobníku, jehož typ je zadán v instrukci.
Stelem_I	Nahradí prvek pole v daném indexu native int hodnotou ve zkušebním zásobníku.
Stelem_I1	Nahradí prvek pole v daném indexu int8 hodnotou ve zkušebním zásobníku.
Stelem_I2	Nahradí prvek pole v daném indexu int16 hodnotou ve zkušebním zásobníku.
Stelem_I4	Nahradí prvek pole v daném indexu int32 hodnotou ve zkušebním zásobníku.
Stelem_I8	Nahradí prvek pole v daném indexu int64 hodnotou ve zkušebním zásobníku.
Stelem_R4	Nahradí prvek pole v daném indexu float32 hodnotou ve zkušebním zásobníku.
Stelem_R8	Nahradí prvek pole v daném indexu float64 hodnotou ve zkušebním zásobníku.
Stelem_Ref	Nahradí prvek pole v daném indexu hodnotou ref objektu (typ O) ve zkušebním zásobníku.
Stfld	Nahradí hodnotu uloženou v poli odkazu na objekt nebo ukazatel novou hodnotou.
Stind_I	Ukládá hodnotu typu native int na zadanou adresu.
Stind_I1	Ukládá hodnotu typu int8 na zadanou adresu.
Stind_I2	Ukládá hodnotu typu int16 na zadanou adresu.
Stind_I4	Ukládá hodnotu typu int32 na zadanou adresu.
Stind_I8	Ukládá hodnotu typu int64 na zadanou adresu.
Stind_R4	Ukládá hodnotu typu float32 na zadanou adresu.
Stind_R8	Ukládá hodnotu typu float64 na zadanou adresu.
Stind_Ref	Uloží referenční hodnotu objektu na zadanou adresu.
Stloc	Zobrazí aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v zadaném indexu.
Stloc_0	Zobrazí aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných na indexu 0.
Stloc_1	Zobrazí aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji v seznamu místních proměnných na indexu 1.
Stloc_2	Zobrazí aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných na indexu 2.
Stloc_3	Zobrazí aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných na indexu 3.
Stloc_S	Zobrazí aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v index (krátké podobě).
Stobj	Zkopíruje hodnotu zadaného typu ze zásobníku vyhodnocení do zadané adresy paměti.
Stsfld	Nahradí hodnotu statického pole hodnotou ze zásobníku vyhodnocení.
Sub	Odečte jednu hodnotu od druhé a nasdílí výsledek do zásobníku vyhodnocení.
Sub_Ovf	Odečte jednu celočíselnou hodnotu od druhé, provede kontrolu přetečení a nasdílí výsledek do zásobníku vyhodnocení.
Sub_Ovf_Un	Odečte jednu celočíselnou hodnotu bez znaménka od druhé, provede kontrolu přetečení a nasdílí výsledek do zásobníku vyhodnocení.
Switch	Implementuje přeskakovací tabulku.
Tailcall	Provede příponu volání metody instrukce tak, aby se před spuštěním skutečné instrukce volání odebral rámec zásobníku aktuální metody.
Throw	Vyvolá objekt výjimky, který je aktuálně ve zkušebním zásobníku.
Unaligned	Označuje, že adresa, která je aktuálně na vrcholu zásobníku hodnocení, nemusí být zarovnaná k přirozené velikosti bezprostředně následující , , , , ldindstindldfldstfldldobjnebo stobj instrukce. initblkcpblk
Unbox	Převede krabicové vyjádření typu hodnoty na jeho unboxed form.
Unbox_Any	Převede krabicovou reprezentaci typu zadaného v pokynu na jeho unboxed form.
Volatile	Určuje, že adresa, která je aktuálně na vrcholu zásobníku vyhodnocení, může být nestálá a výsledky čtení tohoto umístění nelze uložit do mezipaměti nebo že více úložišť do tohoto umístění nelze potlačit.
Xor	Vypočítá bitové XOR prvních dvou hodnot v zásobníku vyhodnocení a nasdílí výsledek do zásobníku vyhodnocení.

Metody

Name	Description
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
TakesSingleByteArgument(OpCode)	Vrátí hodnotu true nebo false, pokud zadaný opcode přebírá jeden bajtový argument.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)