OpCodes Třída

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

System.Reflection.Primitives.dll

Sestavení:

mscorlib.dll

Sestavení:

netstandard.dll

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

public ref class OpCodes

public class OpCodes

[System.Runtime.InteropServices.ComVisible(true)]
public class OpCodes

type OpCodes = class

[<System.Runtime.InteropServices.ComVisible(true)>]
type OpCodes = class

Public Class OpCodes

Dědičnost

Object

OpCodes

Atributy

ComVisibleAttribute

Příklady

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

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ CreateDynamicType()
{
   array<Type^>^ctorParams = {int::typeid,int::typeid};
   AppDomain^ myDomain = Thread::GetDomain();
   AssemblyName^ myAsmName = gcnew 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", int::typeid, FieldAttributes::Public );
   FieldBuilder^ yField = pointTypeBld->DefineField( "y", int::typeid, FieldAttributes::Public );
   Type^ objType = Type::GetType( "System.Object" );
   ConstructorInfo^ objCtor = objType->GetConstructor( gcnew array<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, void::typeid, nullptr );
   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})";
   array<Type^>^wlParams = {String::typeid,Object::typeid,Object::typeid};
   
   // We need the MethodInfo to pass into EmitCall later.
   MethodInfo^ writeLineMI = Console::typeid->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, int::typeid );
   
   // 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, int::typeid );
   
   // 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, nullptr );
   
   // 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();
}

int main()
{
   array<Object^>^ctorParams = gcnew array<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, nullptr, ptInstance, gcnew array<Object^>(0) );
}

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 členů opcode najdete v dokumentaci k Common Language Infrastructure (CLI), zejména "Partition III: CIL Instruction Set" a "Partition II: Metadata Definition and Smantics". Další informace najdete v tématu ECMA 335 Common Language Infrastructure (CLI).

Pole

Add	Přidá dvě hodnoty a nasdílí výsledek 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á bitovou hodnotu 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 ovládací prvek na cílovou instrukci, pokud je první hodnota větší než druhá hodnota, při porovnávání nepodepsaných celočíselné hodnoty nebo neuspořádané hodnoty float.
Bge_Un_S	Převede ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota, při porovnávání nepodepsaných celočíselné hodnoty 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 instrukce (krátký formulář), pokud je první hodnota větší než druhá hodnota.
Bgt_Un	Převede ovládací prvek na cílovou instrukci, pokud je první hodnota větší než druhá hodnota, při porovnávání nepodepsaných celočíselné hodnoty nebo neuspořádané hodnoty float.
Bgt_Un_S	Převede ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota, při porovnávání nepodepsaných celočíselné hodnoty nebo neuspořádané plovoucí hodnoty.
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 ovládací prvek na cílovou instrukci, pokud je první hodnota menší nebo rovna druhé hodnotě, při porovnávání nepřiřazených celočíselné hodnoty nebo neuspořádané plovoucí hodnoty.
Ble_Un_S	Převede ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší nebo rovna druhé hodnotě, při porovnávání neznamovaných celočíselné hodnoty nebo neuspořádané plovoucí hodnoty.
Blt	Převede řízení na cílovou instrukci, pokud je první hodnota menší než druhá hodnota.
Blt_S	Převede ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší než druhá hodnota.
Blt_Un	Převede ovládací prvek 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 ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší než druhá hodnota, při porovnávání nepodepsaných celočíselné hodnoty nebo neuspořádané hodnoty float.
Bne_Un	Převede řízení na cílovou instrukci, pokud nejsou stejné dvě celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Bne_Un_S	Převede ovládací prvek na cílovou instrukce (krátký formulář), pokud nejsou stejné dvě celočíselné hodnoty bez znaménka nebo neuspořádané hodnoty float.
Box	Převede typ hodnoty na odkaz na objekt (typ O).
Br	Bezpodmínečně přenáší kontrolu na cílovou instrukce.
Br_S	Bezpodmínečně přenese kontrolu na cílovou instrukce (krátký formulář).
Break	Signalizuje common language infrastructure (CLI) informovat ladicí program, že došlo k přerušení bodu.
Brfalse	Přenese řízení na cílovou instrukci, pokud value je false, nulový odkaz (Nothingv Visual Basic) nebo nula.
Brfalse_S	Přenese řízení na cílovou instrukci, pokud value je false, nulový odkaz nebo nula.
Brtrue	Převede řízení na cílovou instrukci, pokud value není truenull nebo nenulová.
Brtrue_S	Převede ovládací prvek na cílovou instrukci (krátký formulář), pokud value není truenull nebo není nula.
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 v konvenci volání.
Callvirt	Volá metodu s pozdní vazbou na objekt a nasdílí návratovou hodnotu do zkušebního zásobníku.
Castclass	Pokusí se přetypovat objekt předaný odkazem na zadanou třídu.
Ceq	Porovná dvě hodnoty. Pokud jsou stejné, celočíselná hodnota 1 (int32) se vloží do zkušebního zásobníku; jinak se 0 (int32) vloží 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 zásobníku vyhodnocení; jinak se 0 (int32) vloží do zkušebního zásobníku.
Cgt_Un	Porovná dvě nepodepsané nebo neuspořádané hodnoty. Pokud je první hodnota větší než druhá, celočíselná hodnota 1 (int32) se vloží do zásobníku vyhodnocení; jinak se 0 (int32) vloží do zkušebního zásobníku.
Ckfinite	ArithmeticException Vyvolá, pokud hodnota není konečné číslo.
Clt	Porovná dvě hodnoty. Pokud je první hodnota menší než druhá, celočíselná hodnota 1 (int32) se vloží do zásobníku vyhodnocení; jinak se 0 (int32) vloží 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) nasdílí do zkušebního zásobníku.
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 int.
Conv_I1	Převede hodnotu nad zkušební zásobník na int8a pak ji rozšíří na int32.
Conv_I2	Převede hodnotu nad zkušební zásobník na int16a pak ji rozšíří na int32.
Conv_I4	Převede hodnotu nad zkušební zásobník na int32.
Conv_I8	Převede hodnotu nad zkušební zásobník na int64.
Conv_Ovf_I	Převede podepsanou hodnotu v horní části zkušebního zásobníku na podepsanou native int, která se vyvolá OverflowException při přetečení.
Conv_Ovf_I_Un	Převede nepodepsanou hodnotu v horní části zkušebního zásobníku na podepsanou native int, vyvolání OverflowException přetečení.
Conv_Ovf_I1	Převede podepsanou hodnotu nad zkušební zásobník 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 zkušební zásobník na podepsanou int8 a rozšíří ji na int32, která se vyvolá OverflowException při přetečení.
Conv_Ovf_I2	Převede podepsanou hodnotu v horní části zkušebního zásobníku na podepsanou int16 a rozšíří ji na int32, která se vyvolá OverflowException při přetečení.
Conv_Ovf_I2_Un	Převede nepodepsanou hodnotu nad zkušební zásobník na podepsanou int16 a rozšíří ji na int32, která se vyvolá OverflowException při přetečení.
Conv_Ovf_I4	Převede podepsanou hodnotu v horní části zkušebního zásobníku na podepsanou int32, která se vyvolá OverflowException při přetečení.
Conv_Ovf_I4_Un	Převede nepodepsanou hodnotu v horní části zkušebního zásobníku na podepsanou int32, vyvolání OverflowException přetečení.
Conv_Ovf_I8	Převede podepsanou hodnotu v horní části zkušebního zásobníku na podepsanou int64, která se vyvolá OverflowException při přetečení.
Conv_Ovf_I8_Un	Převede nepodepsanou hodnotu v horní části zkušebního zásobníku na podepsanou int64, vyvolání OverflowException přetečení.
Conv_Ovf_U	Převede podepsanou hodnotu nad zkušebním zásobníkem na unsigned native int, která se vyvolá OverflowException při přetečení.
Conv_Ovf_U_Un	Převede nepodepsanou hodnotu nad zásobníkem vyhodnocení na unsigned native inthodnotu , která se vyvolá OverflowException při přetečení.
Conv_Ovf_U1	Převede podepsanou hodnotu nad zásobníkem vyhodnocení na unsigned int8 a rozšíří ji na int32, vyvolání OverflowException přetečení.
Conv_Ovf_U1_Un	Převede nepodepsanou hodnotu nad zásobníkem unsigned int8 vyhodnocení na a rozšíří ji na int32, vyvolání OverflowException přetečení.
Conv_Ovf_U2	Převede podepsanou hodnotu nad zásobníkem vyhodnocení na unsigned int16 a rozšíří ji na int32, vyvolání OverflowException přetečení.
Conv_Ovf_U2_Un	Převede nepodepsanou hodnotu nad zásobníkem unsigned int16 vyhodnocení na a rozšíří ji na int32, vyvolání OverflowException přetečení.
Conv_Ovf_U4	Převede podepsanou hodnotu nad zkušebním zásobníkem na unsigned int32, která se vyvolá OverflowException při přetečení.
Conv_Ovf_U4_Un	Převede nepodepsanou hodnotu nad zásobníkem vyhodnocení na unsigned int32hodnotu , která se vyvolá OverflowException při přetečení.
Conv_Ovf_U8	Převede podepsanou hodnotu nad zkušebním zásobníkem na unsigned int64, která se vyvolá OverflowException při přetečení.
Conv_Ovf_U8_Un	Převede nepodepsanou hodnotu nad zásobníkem vyhodnocení na unsigned int64hodnotu , která se vyvolá OverflowException při přetečení.
Conv_R_Un	Převede celočíselnou hodnotu bez znaménka nad zkušební zásobník na float32.
Conv_R4	Převede hodnotu nad zkušební zásobník na float32.
Conv_R8	Převede hodnotu nad zkušební zásobník na float64.
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 native int ) na adresu cílového objektu (typ &nebo native int).
Div	Rozdělí dvě hodnoty a výsledek nasdílí jako plovoucí desetinu (typ F) nebo quotient (typ int32) do zkušebního zásobníku.
Div_Un	Rozdělí dvě celočíselné hodnoty bez znaménka a nasdílí výsledek (int32) do zásobníku vyhodnocení.
Dup	Zkopíruje aktuální nejvyšší hodnotu ve zkušebním zásobníku a potom nasdílí kopii do zkušebního zásobníku.
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 nebo finally klauzule bloku výjimky 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 argument (odkazovaný zadanou hodnotou indexu) do zásobníku.
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 v indexu 3 do zásobníku vyhodnocení.
Ldarg_S	Načte argument (odkazovaný zadaným krátkým indexem formuláře) do zásobníku vyhodnocení.
Ldarga	Načtěte adresu argumentu do zásobníku vyhodnocení.
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 vyhodnocovací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 int32jako hodnotu .
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 zkušebního zásobníku int32jako hodnotu .
Ldc_I4_S	Vloží zadanou int8 hodnotu do zkušebního zásobníku int32jako 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 do zadaného indexu pole do horní části zkušebního zásobníku jako typ zadaný v instrukcích.
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 do horní části zkušebního zásobníku jako .int32
Ldelem_I2	Načte prvek s typem int16 v zadaném indexu pole do horní části zkušebního zásobníku jako .int32
Ldelem_I4	Načte prvek s typem int32 v zadaném indexu pole do horní části zkušebního zásobníku jako .int32
Ldelem_I8	Načte prvek s typem int64 v zadaném indexu pole do horní části zkušebního 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 element obsahující odkaz na objekt v zadaném indexu pole na začátek zkušebního zásobníku jako typ O (odkaz na objekt).
Ldelem_U1	Načte prvek s typem unsigned int8 v zadaném indexu pole do horní části zkušebního zásobníku jako .int32
Ldelem_U2	Načte prvek s typem unsigned int16 v zadaném indexu pole do horní části zkušebního zásobníku jako .int32
Ldelem_U4	Načte prvek s typem unsigned int32 v zadaném indexu pole do horní části zkušebního 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ě v zásobníku vyhodnocení.
Ldflda	Vyhledá adresu pole v objektu, jehož odkaz je aktuálně ve zkušebním zásobníku.
Ldftn	Odešle nespravovaný ukazatel (typ native int) do nativního kódu implementovaného konkrétní metodu do zásobníku vyhodnocení.
Ldind_I	Načte hodnotu typu native int jako native int objekt do zásobníku vyhodnocení nepřímo.
Ldind_I1	Načte hodnotu typu int8 jako hodnotu do int32 zásobníku vyhodnocení nepřímo.
Ldind_I2	Načte hodnotu typu int16 jako hodnotu do int32 zásobníku vyhodnocení nepřímo.
Ldind_I4	Načte hodnotu typu int32 jako hodnotu do int32 zásobníku vyhodnocení nepřímo.
Ldind_I8	Načte hodnotu typu int64 jako hodnotu do int64 zásobníku vyhodnocení nepřímo.
Ldind_R4	Načte hodnotu typu float32 jako typ F (float) do zásobníku vyhodnocení nepřímo.
Ldind_R8	Načte hodnotu typu float64 jako typ F (float) do zásobníku vyhodnocení 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 hodnotu do int32 zásobníku vyhodnocení nepřímo.
Ldind_U2	Načte hodnotu typu unsigned int16 jako hodnotu do int32 zásobníku vyhodnocení nepřímo.
Ldind_U4	Načte hodnotu typu unsigned int32 jako hodnotu do int32 zásobníku vyhodnocení 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 na určitý index 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 zkušebního zásobníku.
Ldloc_3	Načte místní proměnnou v indexu 3 do zkušebního zásobníku.
Ldloc_S	Načte místní proměnnou v určitém indexu do zkušebního zásobníku krátký formulář.
Ldloca	Načte adresu místní proměnné na určitý index do zkušebního zásobníku.
Ldloca_S	Načte adresu místní proměnné na určitý index do zkušebního zásobníku, krátkého formuláře.
Ldnull	Vloží odkaz null (typ O) do zkušebního zásobníku.
Ldobj	Zkopíruje objekt typu hodnoty, na který odkazuje adresa na začátek zkušebního zásobníku.
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	Nasdílí nový objekt odkaz na řetězcový literál uložený v metadatech.
Ldtoken	Převede token metadat na reprezentaci modulu runtime a nasdílí ho do zásobníku vyhodnocení.
Ldvirtftn	Odešle 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 a bezpodmínečně převede kontrolu 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 nasdílí výsledek do zásobníku vyhodnocení.
Mul_Ovf_Un	Vynásobí dvě celočíselné hodnoty bez znaménka, provede kontrolu přetečení a nasdílí výsledek do zásobníku vyhodnocení.
Neg	Neguje hodnotu a nasdílí výsledek do zásobníku vyhodnocení.
Newarr	Nasdílí odkaz na objekt do nového jednorozměrného pole založeného na nule, jehož prvky jsou specifického typu do zásobníku vyhodnocení.
Newobj	Vytvoří nový objekt nebo novou instanci typu hodnoty, 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 zkušebního zásobníku jako stejný typ.
Or	Výpočet bitového doplňku dvou celočíselné hodnoty nad zásobníkem a nasdílí výsledek do zkušebního zásobníku.
Pop	Odebere hodnotu, která je aktuálně nad zkušebním zásobníkem.
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ásledující operace maticové adresy neprovádí žádnou kontrolu typu za běhu a že vrací spravovaný ukazatel, jehož ztlumitelnost je omezena.
Refanytype	Načte token typu vložený do typového odkazu.
Refanyval	Načte adresu (typ &) vloženou do zadaného odkazu.
Rem	Rozdělí dvě hodnoty a nasdílí zbytek do zásobníku vyhodnocení.
Rem_Un	Rozdělí dvě nepodepsané hodnoty a zbytek nasdílí do zkušebního zásobníku.
Ret	Vrátí se z aktuální metody a 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 nulech) o zadaný počet bitů a nasdílí výsledek do vyhodnocovacího zásobníku.
Shr	Posune celočíselnou hodnotu (znaménko) doprava zadaným počtem bitů a nasdílí výsledek do zásobníku vyhodnocení.
Shr_Un	Posune celočíselnou hodnotu bez znaménka (v nulech) doprava zadaným počtem bitů a nasdílí výsledek do zásobníku vyhodnocení.
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 argumentů v zadaném indexu.
Starg_S	Uloží hodnotu nad zásobník vyhodnocení v slotu argumentů v zadaném indexu ve krátkém formátu.
Stelem	Nahradí maticový prvek v daném indexu hodnotou ve zkušebním zásobníku, jehož typ je zadán v pokynu.
Stelem_I	Nahradí maticový prvek v daném indexu native int hodnotou ve zkušebním zásobníku.
Stelem_I1	Nahradí maticový prvek v daném indexu int8 hodnotou ve zkušebním zásobníku.
Stelem_I2	Nahradí maticový prvek v daném indexu int16 hodnotou ve zkušebním zásobníku.
Stelem_I4	Nahradí maticový prvek v daném indexu int32 hodnotou ve zkušebním zásobníku.
Stelem_I8	Nahradí maticový prvek v daném indexu int64 hodnotou ve zkušebním zásobníku.
Stelem_R4	Nahradí maticový prvek v daném indexu float32 hodnotou ve zkušebním zásobníku.
Stelem_R8	Nahradí maticový prvek v daném indexu float64 hodnotou ve zkušebním zásobníku.
Stelem_Ref	Nahradí maticový prvek 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	Uloží hodnotu typu native int na zadanou adresu.
Stind_I1	Uloží hodnotu typu int8 na zadanou adresu.
Stind_I2	Uloží hodnotu typu int16 na zadanou adresu.
Stind_I4	Uloží hodnotu typu int32 na zadanou adresu.
Stind_I8	Uloží hodnotu typu int64 na zadanou adresu.
Stind_R4	Uloží hodnotu typu float32 na zadanou adresu.
Stind_R8	Uloží hodnotu typu float64 na zadanou adresu.
Stind_Ref	Uloží hodnotu odkazu na objekt na zadanou adresu.
Stloc	Zobrazí aktuální hodnotu z horní části zkušebního zásobníku a uloží ji do seznamu místních proměnných v zadaném indexu.
Stloc_0	Zobrazí aktuální hodnotu z horní části zkušebního zásobníku a uloží ji do seznamu místních proměnných na indexu 0.
Stloc_1	Zobrazí aktuální hodnotu z horní části zkušebního zásobníku a uloží ji do seznamu místních proměnných na indexu 1.
Stloc_2	Zobrazí aktuální hodnotu z horní části zkušebního zásobníku a uloží ji do seznamu místních proměnných na indexu 2.
Stloc_3	Zobrazí aktuální hodnotu z horní části zkušebního zásobníku a uloží ji do seznamu místních proměnných v indexu 3.
Stloc_S	Zobrazí aktuální hodnotu z horní části zkušebního zásobníku a uloží ji do seznamu místních proměnných v index (krátkém formuláři).
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 zkušebního zásobníku.
Sub	Odečte jednu hodnotu od druhé a výsledek nasdílí do zásobníku vyhodnocení.
Sub_Ovf	Odečte jednu celočíselnou hodnotu od druhé, provede kontrolu přetečení a výsledek nasdílí do zásobníku vyhodnocení.
Sub_Ovf_Un	Odečte jednu celočíselnou hodnotu bez znaménka od jiného, provede kontrolu přetečení a výsledek nasdílí do zásobníku vyhodnocení.
Switch	Implementuje přeskakovací tabulku.
Tailcall	Provede pofixovanou pokyn k volání metody, aby byl před provedením skutečné instrukce volání odebrán rámec zásobníku aktuální metody.
Throw	Vyvolá objekt výjimky 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í ldind, , , , ldfld, , stobjldobjstfldinitblk, nebo cpblk instrukce. stind
Unbox	Převede krabicové vyjádření typu hodnoty na jeho unboxed form.
Unbox_Any	Převede krabicovou reprezentaci typu zadaného v instrukci na jeho unboxed form.
Volatile	Určuje, že adresa, která je aktuálně na vrcholu zkušebního zásobníku, 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á bitovou hodnotu XOR prvních dvou hodnot v zásobníku vyhodnocení a nasdílí výsledek do zásobníku vyhodnocení.

Metody

Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetType()	Type Získá aktuální instanci. (Zděděno od Object)
MemberwiseClone()	Vytvoří použádnou kopii aktuálního souboru 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)