OpCodes Třída

  • Reference

Definice

Obor názvů:
System.Reflection.Emit
Sestavení:
System.Reflection.Primitives.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll
Zdroj:
OpCodes.cs
Zdroj:
OpCodes.cs
Zdroj:
OpCodes.cs

Poskytuje reprezentaci polí instrukcí jazyka MSIL (Microsoft Intermediate Language) pro emise členy ILGenerator 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 k vygenerování 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 opcode členů najdete v dokumentaci k common language infrastructure (CLI), zejména v části 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

Add

Sečte 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 zkušebního zásobníku.
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

Pokud jsou dvě hodnoty rovny, přenese ovládací prvek na cílovou instrukci.
Beq_S

Přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud jsou dvě hodnoty stejné.
Bge

Přenese ovládací prvek na cílovou instrukci, pokud je první hodnota větší nebo rovna druhé hodnotě.
Bge_S

Přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota větší nebo rovna druhé hodnotě.
Bge_Un

Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci, pokud je první hodnota větší než druhá hodnota.
Bge_Un_S

Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota.
Bgt

Pokud je první hodnota větší než druhá hodnota, přenese řízení na cílovou instrukci.
Bgt_S

Pokud je první hodnota větší než druhá hodnota, přenese řízení na cílovou instrukci (krátký formulář).
Bgt_Un

Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci, pokud je první hodnota větší než druhá hodnota.
Bgt_Un_S

Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota.
Ble

Pokud je první hodnota menší nebo rovna druhé hodnotě, přenese ovládací prvek na cílovou instrukci.
Ble_S

Přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší nebo rovna druhé hodnotě.
Ble_Un

Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci, pokud je první hodnota menší nebo rovna druhé hodnotě.
Ble_Un_S

Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší nebo rovna druhé hodnotě.
Blt

Pokud je první hodnota menší než druhá hodnota, přenese řízení na cílovou instrukci.
Blt_S

Pokud je první hodnota menší než druhá hodnota, přenese ovládací prvek na cílovou instrukci (krátký formulář).
Blt_Un

Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci, pokud je první hodnota menší než druhá hodnota.
Blt_Un_S

Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší než druhá hodnota.
Bne_Un

Přenese ovládací prvek na cílovou instrukci, pokud se nerovnají dvě celočíselné hodnoty bez znaménka nebo neuspořádané plovoucí hodnoty.
Bne_Un_S

Přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud se dvě celočíselné hodnoty bez znaménka nebo neuspořádané plovoucí hodnoty nerovnají.
Box

Převede typ hodnoty na odkaz na objekt (typ O).
Br

Bezpodmínečně přenese řízení na cílovou instrukci.
Br_S

Bezpodmínečně přenese řízení na cílovou instrukci (krátký formulář).
Break

Signalizuje rozhraní příkazového řádku (Common Language Infrastructure) a informuje ladicí program, že došlo k zarážce.
Brfalse

Přenese ovládací prvek na cílovou instrukci, pokud value je false, odkaz null (Nothing v jazyce Visual Basic) nebo nula.
Brfalse_S

Přenese ovládací prvek na cílovou instrukce, pokud value je false, odkaz s hodnotou null nebo nula.
Brtrue

Přenese ovládací prvek do cílové instrukce, pokud value je true, není null nebo nenulový.
Brtrue_S

Přenese řízení na cílovou instrukci (krátký formulář), pokud value je true, není null nebo nenulová.
Call

Zavolá metodu označenou předaným popisovačem metody.
Calli

Zavolá metodu uvedenou ve zkušebním zásobníku (jako ukazatel na vstupní bod) s argumenty popsanými konvencí volání.
Callvirt

Zavolá 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. Pokud jsou stejné, celočíselná hodnota 1 (int32) je vložena do zásobníku vyhodnocení; jinak se hodnota 0 (int32) nasdílí do zásobníku vyhodnocení.
Cgt

Porovná dvě hodnoty. Pokud je první hodnota větší než druhá, celočíselná hodnota 1 (int32) je vložena do zásobníku vyhodnocení; jinak se hodnota 0 (int32) nasdílí do zásobníku vyhodnocení.
Cgt_Un

Porovná dvě hodnoty bez znaménka nebo neuspořádané hodnoty. Pokud je první hodnota větší než druhá, celočíselná hodnota 1 (int32) je vložena do zásobníku vyhodnocení; jinak se hodnota 0 (int32) nasdílí do zásobníku vyhodnocení.
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) je vložena do zásobníku vyhodnocení; jinak se hodnota 0 (int32) nasdílí do zásobníku vyhodnocení.
Clt_Un

Porovná hodnoty bez znaménka nebo neuspořádané hodnoty value1 a value2. Pokud value1 je menší než value2, pak se do zásobníku vyhodnocení nasdílí celočíselná hodnota 1 (int32). V opačném případě se hodnota 0 (int32) nasdílí do zásobníku vyhodnocení.
Constrained

Omezuje typ, pro který 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 zásobníkem vyhodnocení na int8a pak ji rozšíří (vysunou) na int32.
Conv_I2

Převede hodnotu nad zásobníkem vyhodnocení na int16a pak ji rozšíří (vysunou) 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 nad zásobníkem vyhodnocení na podepsanou native inthodnotu , která vyvolá OverflowException přetečení.
Conv_Ovf_I_Un

Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou native inthodnotu , která vyvolá OverflowException přetečení.
Conv_Ovf_I1

Převede podepsanou hodnotu nad zkušební zásobník na podepsanou int8 a rozšíří ji na int32hodnotu , která OverflowException vyvolá přetečení.
Conv_Ovf_I1_Un

Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou int8 a rozšíří ji na int32hodnotu , která OverflowException vyvolá přetečení.
Conv_Ovf_I2

Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou int16 a rozšíří ji na int32hodnotu , která OverflowException vyvolá přetečení.
Conv_Ovf_I2_Un

Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou int16 a rozšíří ji na int32hodnotu , která OverflowException vyvolá přetečení.
Conv_Ovf_I4

Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou int32hodnotu , která vyvolá OverflowException přetečení.
Conv_Ovf_I4_Un

Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou int32hodnotu , která vyvolá OverflowException přetečení.
Conv_Ovf_I8

Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou int64hodnotu , která vyvolá OverflowException přetečení.
Conv_Ovf_I8_Un

Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou int64hodnotu , která vyvolá OverflowException přetečení.
Conv_Ovf_U

Převede hodnotu se signou hodnotou nad zásobníkem vyhodnocení na unsigned native inthodnotu , která vyvolá přetečení OverflowException .
Conv_Ovf_U_Un

Převede hodnotu bez znaménka v horní části zkušebního zásobníku na unsigned native inthodnotu , která vyvolá při OverflowException přetečení.
Conv_Ovf_U1

Převede podepsanou hodnotu nad zásobníkem unsigned int8 vyhodnocení na a rozšíří ji na int32hodnotu , která vyvolá přetečení OverflowException .
Conv_Ovf_U1_Un

Převede hodnotu bez znaménka nad zásobníkem vyhodnocení na unsigned int8 a rozšíří ji na int32hodnotu , která OverflowException vyvolá přetečení.
Conv_Ovf_U2

Převede podepsanou hodnotu nad zásobníkem unsigned int16 vyhodnocení na a rozšíří ji na int32hodnotu , která vyvolá přetečení OverflowException .
Conv_Ovf_U2_Un

Převede hodnotu bez znaménka nad zásobníkem vyhodnocení na unsigned int16 a rozšíří ji na int32hodnotu , která OverflowException vyvolá přetečení.
Conv_Ovf_U4

Převede hodnotu se signou hodnotou nad zásobníkem vyhodnocení na unsigned int32hodnotu , která vyvolá přetečení OverflowException .
Conv_Ovf_U4_Un

Převede hodnotu bez znaménka v horní části zkušebního zásobníku na unsigned int32hodnotu , která vyvolá při OverflowException přetečení.
Conv_Ovf_U8

Převede hodnotu se signou hodnotou nad zásobníkem vyhodnocení na unsigned int64hodnotu , která vyvolá přetečení OverflowException .
Conv_Ovf_U8_Un

Převede hodnotu bez znaménka v horní části zkušebního zásobníku na unsigned int64hodnotu , která vyvolá při OverflowException 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 zásobník vyhodnocení na unsigned native inta rozšíří ji na native int.
Conv_U1

Převede hodnotu nad zásobník vyhodnocení na unsigned int8a rozšíří ji na int32.
Conv_U2

Převede hodnotu nad zásobník vyhodnocení na unsigned int16a rozšíří ji na int32.
Conv_U4

Převede hodnotu nad zásobník vyhodnocení na unsigned int32a rozšíří ji na int32.
Conv_U8

Převede hodnotu nad zásobník vyhodnocení na unsigned int64a 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 nasdílí výsledek jako hodnotu s plovoucí desetinou čárkou (typ F) nebo kvocient (typ int32) do zásobníku vyhodnocení.
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 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 klauzule nebo finally bloku výjimky zpět do obslužné rutiny výjimky common language infrastructure (CLI).
Initblk

Inicializuje zadaný blok paměti na konkrétní adrese pro danou velikost a počáteční hodnotu.
Initobj

Inicializuje každé pole typu hodnoty na zadané adrese na odkaz null nebo 0 příslušného primitivního typu.
Isinst

Testuje, zda je odkaz na objekt (typ O) instancí 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 v indexu 0 do zásobníku vyhodnocení.
Ldarg_1

Načte argument v indexu 1 do zásobníku vyhodnocení.
Ldarg_2

Načte argument v indexu 2 do zásobníku vyhodnocení.
Ldarg_3

Načte argument v indexu 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 stručné podobě do zkušebního zásobníku.
Ldc_I4

Nasdílí zadanou hodnotu typu int32 do zásobníku vyhodnocení jako int32.
Ldc_I4_0

Nasdílí celočíselnou hodnotu 0 do zkušebního zásobníku int32jako .
Ldc_I4_1

Nasdílí celočíselnou hodnotu 1 do zásobníku vyhodnocení jako int32.
Ldc_I4_2

Nasdílí celočíselnou hodnotu 2 do zásobníku vyhodnocení jako int32.
Ldc_I4_3

Nasdílí celočíselnou hodnotu 3 do vyhodnocovacího zásobníku int32jako .
Ldc_I4_4

Nasdílí celočíselnou hodnotu 4 do zásobníku vyhodnocení jako int32.
Ldc_I4_5

Nasdílí celočíselnou hodnotu 5 do vyhodnocovacího zásobníku int32jako .
Ldc_I4_6

Nasdílí celočíselnou hodnotu 6 do vyhodnocovacího zásobníku int32jako .
Ldc_I4_7

Nasdílí celočíselnou hodnotu 7 do vyhodnocovacího zásobníku int32jako .
Ldc_I4_8

Nasdílí celočíselnou hodnotu 8 do zásobníku vyhodnocení jako int32.
Ldc_I4_M1

Nasdílí celočíselnou hodnotu -1 do zkušebního zásobníku int32jako .
Ldc_I4_S

Nasdílí zadanou int8 hodnotu do zkušebního zásobníku int32jako krátký formulář.
Ldc_I8

Nasdílí zadanou hodnotu typu int64 do zásobníku vyhodnocení jako int64.
Ldc_R4

Nasdílí zadanou hodnotu typu float32 do zkušebního zásobníku jako typ F (float).
Ldc_R8

Nasdílí zadanou hodnotu typu float64 do zkušebního zásobníku jako typ F (float).
Ldelem

Načte prvek v zadaném indexu pole do horní části zkušebního zásobníku jako typ zadaný v pokynech.
Ldelem_I

Načte prvek s typem native int v zadaném indexu pole do horní části zkušebního zásobníku native intjako .
Ldelem_I1

Načte element s typem int8 v zadaném indexu pole do horní části zkušebního zásobníku int32jako .
Ldelem_I2

Načte element s typem int16 v zadaném indexu pole do horní části zkušebního zásobníku int32jako .
Ldelem_I4

Načte element s typem int32 v zadaném indexu pole do horní části zkušebního zásobníku int32jako .
Ldelem_I8

Načte element s typem int64 v zadaném indexu pole do horní části zkušebního zásobníku int64jako .
Ldelem_R4

Načte prvek s typem float32 v zadaném indexu pole do horní části zkušebního zásobníku jako typ F (float).
Ldelem_R8

Načte prvek s typem float64 v zadaném indexu pole do horní části 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 do horní části zásobníku vyhodnocení jako typ O (odkaz na objekt).
Ldelem_U1

Načte element s typem unsigned int8 v zadaném indexu pole do horní části zkušebního zásobníku int32jako .
Ldelem_U2

Načte element s typem unsigned int16 v zadaném indexu pole do horní části zkušebního zásobníku int32jako .
Ldelem_U4

Načte element s typem unsigned int32 v zadaném indexu pole do horní části zkušebního zásobníku int32jako .
Ldelema

Načte adresu prvku pole v zadaném indexu pole do horní části zásobníku vyhodnocení 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

Odešle nespravovaný ukazatel (typ native int) do nativního kódu implementovaného konkrétní metodu do zkušebního zásobníku.
Ldind_I

Nepřímo načte hodnotu typu native int do native int zásobníku vyhodnocení.
Ldind_I1

Načte hodnotu typu int8 jako hodnotu int32 do zásobníku vyhodnocení nepřímo.
Ldind_I2

Načte hodnotu typu int16 jako hodnotu int32 do zásobníku vyhodnocení nepřímo.
Ldind_I4

Načte hodnotu typu int32 jako hodnotu int32 do zásobníku vyhodnocení nepřímo.
Ldind_I8

Načte hodnotu typu int64 jako hodnotu int64 do 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

Nepřímo načte odkaz na objekt jako typ O (odkaz na objekt) do vyhodnocovacího zásobníku.
Ldind_U1

Načte hodnotu typu unsigned int8 jako hodnotu int32 do zásobníku vyhodnocení nepřímo.
Ldind_U2

Načte hodnotu typu unsigned int16 jako hodnotu int32 do zásobníku vyhodnocení nepřímo.
Ldind_U4

Načte hodnotu typu unsigned int32 jako hodnotu int32 do zásobníku vyhodnocení nepřímo.
Ldlen

Nasdílí počet prvků jednorozměrného pole založeného na nule do vyhodnocovací sady.
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 v indexu 0 do zásobníku vyhodnocení.
Ldloc_1

Načte místní proměnnou v indexu 1 do zásobníku vyhodnocení.
Ldloc_2

Načte místní proměnnou v indexu 2 do zásobníku vyhodnocení.
Ldloc_3

Načte místní proměnnou v indexu 3 do zásobníku vyhodnocení.
Ldloc_S

Načte místní proměnnou v určitém indexu do zásobníku vyhodnocení v krátké formě.
Ldloca

Načte adresu místní proměnné na konkrétním indexu do zásobníku vyhodnocení.
Ldloca_S

Načte adresu místní proměnné v určitém indexu do zásobníku vyhodnocení v krátké podobě.
Ldnull

Nasdílí do zásobníku vyhodnocení odkaz s hodnotou null (typ O).
Ldobj

Zkopíruje objekt typu hodnoty, na který odkazuje adresa, do horní části 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í odkaz na nový 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 zkušebního zásobníku.
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řenese řízení na konkrétní cílovou instrukci.
Leave_S

Ukončí chráněnou oblast kódu a bezpodmínečně přenese řízení na cílovou instrukci (krátký formulář).
Localloc

Přidělí určitý počet bajtů z místního dynamického fondu paměti a nasdílí adresu (přechodný ukazatel, typ *) prvního přiděleného bajtu do zásobníku vyhodnocení.
Mkrefany

Nasdílí typový odkaz na instanci určitého typu do zkušebního zásobníku.
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 určitého typu, do zásobníku vyhodnocení.
Newobj

Vytvoří nový objekt nebo novou instanci hodnotového typu a nasdílí odkaz na objekt (typ O) do zásobníku vyhodnocení.
Nop

Pokud jsou opcode opravené, vyplní místo. Neprovádí se žádná smysluplná operace, i když je možné využívat 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

Vypočítá bitový doplněk dvou celočíselných hodnot nad zásobníkem a nasdílí výsledek do zkušební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í za běhu žádnou kontrolu typu a že vrátí spravovaný ukazatel, jehož proměnlivost je omezená.
Refanytype

Načte token typu vložený do zadaného odkazu.
Refanyval

Načte adresu (typ &) vloženou do zadaného odkazu.
Rem

Rozdělí dvě hodnoty a zbytek nasdílí do zkušebního zásobníku.
Rem_Un

Rozdělí dvě nepodepsané hodnoty a zbytek nasdílí do zkušebního zásobníku.
Ret

Vrátí hodnotu z aktuální metody a nasdílí návratovou hodnotu (pokud je k dispozici) z vyhodnocovacího zásobníku volané do testovacího zásobníku volajícího.
Rethrow

Znovu vyvolá aktuální výjimku.
Shl

Posune celočíselnou hodnotu doleva (v nulách) o zadaný počet bitů a výsledek se přesune do zásobníku vyhodnocení.
Shr

Posune celočíselnou hodnotu (v znaménku) doprava o zadaný počet bitů a nasdílí výsledek do zásobníku vyhodnocení.
Shr_Un

Posune celočíselnou hodnotu bez znaménka (v nulech) doprava o zadaný počet bitů a výsledek se přepíše do zásobníku vyhodnocení.
Sizeof

Vloží velikost zadaného typu hodnoty v bajtech do zásobníku vyhodnocení.
Starg

Uloží hodnotu nad zásobník vyhodnocení ve slotu argumentu v zadaném indexu.
Starg_S

Uloží hodnotu nad zásobník vyhodnocení ve slotu argumentů v zadaném krátkém formátu indexu.
Stelem

Nahradí prvek pole v daném indexu hodnotou ve zkušebním zásobníku, jejíž typ je určen v instrukci.
Stelem_I

Nahradí prvek pole v daném indexu native int hodnotou v zásobníku vyhodnocení.
Stelem_I1

Nahradí prvek pole v daném indexu int8 hodnotou v zásobníku vyhodnocení.
Stelem_I2

Nahradí prvek pole v daném indexu int16 hodnotou v zásobníku vyhodnocení.
Stelem_I4

Nahradí prvek pole v daném indexu int32 hodnotou v zásobníku vyhodnocení.
Stelem_I8

Nahradí prvek pole v daném indexu int64 hodnotou v zásobníku vyhodnocení.
Stelem_R4

Nahradí prvek pole v daném indexu float32 hodnotou v zásobníku vyhodnocení.
Stelem_R8

Nahradí prvek pole v daném indexu float64 hodnotou v zásobníku vyhodnocení.
Stelem_Ref

Nahradí prvek pole v daném indexu hodnotou odkaz 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

Otevře 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

Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v indexu 0.
Stloc_1

Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v indexu 1.
Stloc_2

Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v indexu 2.
Stloc_3

Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v indexu 3.
Stloc_S

Přemísťuje 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 zkušebního zásobníku do zadané adresy paměti.
Stsfld

Nahradí hodnotu statického pole hodnotou ze sady vyhodnocení.
Sub

Odečte jednu hodnotu od druhé a výsledek se 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 vyhodnocovacího zásobníku.
Sub_Ovf_Un

Odečte jednu celočíselnou hodnotu bez znaménka od druhé, provede kontrolu přetečení a výsledek nasdílí do zásobníku vyhodnocení.
Switch

Implementuje tabulku odkazů.
Tailcall

Provádí příponu metody volání instrukce tak, že aktuální metoda zásobníku rámec je odstraněna před provedením skutečného volání instrukce.
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á s přirozenou velikostí bezprostředně následující ldindinstrukce , , stind, ldfld, stobjinitblkstfldldobj, nebo .cpblk
Unbox

Převede reprezentaci typu hodnoty v rámečku do jeho nezasílané podoby.
Unbox_Any

Převede zadanou reprezentaci typu zadaného v instrukcích do jeho unboxed podoby.
Volatile

Určuje, že adresa, která je aktuálně na vrcholu zásobníku hodnocení, může být nestálou 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

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetHashCode()

Slouží jako výchozí hashovací funkce.

(Zděděno od Object)
GetType()

Získá aktuální Type instanci.

(Zděděno od Object)
MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(Zděděno od Object)
TakesSingleByteArgument(OpCode)

Vrátí hodnotu true nebo false, pokud zadaný opcode přebírá jeden bajt argument.
ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)

Platí pro