OpCodes Klasa

Definicja

Przestrzeń nazw:

System.Reflection.Emit

Zestaw:

System.Reflection.Primitives.dll

Źródło:

OpCodes.cs

Zawiera reprezentacje pól instrukcji języka Microsoft Intermediate Language (MSIL) dla emisji przez ILGenerator składowe klasy (na przykład Emit(OpCode)).

public ref class OpCodes

public class OpCodes

type OpCodes = class

Public Class OpCodes

Dziedziczenie

Object

OpCodes

Przykłady

W poniższym przykładzie pokazano konstrukcję metody dynamicznej przy użyciu ILGenerator funkcji emitowania OpCodes do elementu 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

Uwagi

Aby uzyskać szczegółowy opis kodów opcode elementów członkowskich, zobacz dokumentację infrastruktury języka wspólnego (CLI), szczególnie "Partition III: CIL Instruction Set" i "Partition II: Metadata Definition and Semantics" (Partycja III: zestaw instrukcji CIL) i "Partition II: Metadata Definition and Semantics". Aby uzyskać więcej informacji, zobacz ECMA 335 Common Language Infrastructure (CLI).

Pola

Add	Dodaje dwie wartości i wypycha wynik do stosu oceny.
Add_Ovf	Dodaje dwie liczby całkowite, sprawdza przepełnienie i wypycha wynik do stosu oceny.
Add_Ovf_Un	Dodaje dwie niepodpisane wartości całkowite, sprawdza przepełnienie i wypycha wynik do stosu oceny.
And	Oblicza bitowe wartości AND z dwóch wartości i wypycha wynik do stosu oceny.
Arglist	Zwraca niezarządzany wskaźnik do listy argumentów bieżącej metody.
Beq	Transferuje kontrolkę do instrukcji docelowej, jeśli dwie wartości są równe.
Beq_S	Transferuje kontrolkę do instrukcji docelowej (formularza krótkiego), jeśli dwie wartości są równe.
Bge	Transferuje kontrolkę do instrukcji docelowej, jeśli pierwsza wartość jest większa lub równa drugiej wartości.
Bge_S	Transferuje kontrolkę do instrukcji docelowej (formularza krótkiego), jeśli pierwsza wartość jest większa lub równa drugiej wartości.
Bge_Un	Transferuje kontrolkę do instrukcji docelowej, jeśli pierwsza wartość jest większa niż druga, podczas porównywania niepodpisanych wartości całkowitych lub niepodpisanych wartości zmiennoprzecinkowych.
Bge_Un_S	Transferuje kontrolkę do instrukcji docelowej (skróconej formy), jeśli pierwsza wartość jest większa niż druga wartość, podczas porównywania niepodpisanych wartości całkowitych lub nieurządkowanych wartości zmiennoprzecinkowych.
Bgt	Transferuje kontrolkę do instrukcji docelowej, jeśli pierwsza wartość jest większa niż druga wartość.
Bgt_S	Transferuje kontrolkę do instrukcji docelowej (formularza krótkiego), jeśli pierwsza wartość jest większa niż druga wartość.
Bgt_Un	Transferuje kontrolkę do instrukcji docelowej, jeśli pierwsza wartość jest większa niż druga, podczas porównywania niepodpisanych wartości całkowitych lub niepodpisanych wartości zmiennoprzecinkowych.
Bgt_Un_S	Transferuje kontrolkę do instrukcji docelowej (skróconej formy), jeśli pierwsza wartość jest większa niż druga wartość, podczas porównywania niepodpisanych wartości całkowitych lub nieurządkowanych wartości zmiennoprzecinkowych.
Ble	Transferuje kontrolkę do instrukcji docelowej, jeśli pierwsza wartość jest mniejsza lub równa drugiej wartości.
Ble_S	Transferuje kontrolkę do instrukcji docelowej (formularza krótkiego), jeśli pierwsza wartość jest mniejsza lub równa drugiej wartości.
Ble_Un	Transferuje kontrolkę do instrukcji docelowej, jeśli pierwsza wartość jest mniejsza lub równa drugiej wartości, podczas porównywania niepodpisanych wartości całkowitych lub nieurządkowanych wartości zmiennoprzecinkowych.
Ble_Un_S	Transferuje kontrolkę do instrukcji docelowej (skróconej formy), jeśli pierwsza wartość jest mniejsza lub równa drugiej wartości, podczas porównywania niepodpisanych wartości całkowitych lub nieurządkowanych wartości zmiennoprzecinkowych.
Blt	Transferuje kontrolkę do instrukcji docelowej, jeśli pierwsza wartość jest mniejsza niż druga wartość.
Blt_S	Transferuje kontrolkę do instrukcji docelowej (formularza krótkiego), jeśli pierwsza wartość jest mniejsza niż druga wartość.
Blt_Un	Transferuje kontrolkę do instrukcji docelowej, jeśli pierwsza wartość jest mniejsza niż druga, podczas porównywania niepodpisanych wartości całkowitych lub nieurządkowanych wartości zmiennoprzecinkowych.
Blt_Un_S	Transferuje kontrolkę do instrukcji docelowej (formularza krótkiego), jeśli pierwsza wartość jest mniejsza niż druga wartość, podczas porównywania niepodpisanych wartości całkowitych lub niepodpisanych wartości zmiennoprzecinkowych.
Bne_Un	Transferuje kontrolkę do instrukcji docelowej, gdy dwie niepodpisane wartości całkowite lub nieurządzone wartości zmiennoprzecinkowe nie są równe.
Bne_Un_S	Transferuje kontrolkę do instrukcji docelowej (krótkiej formy), gdy dwie niepodpisane wartości całkowite lub nieurządkowane wartości zmiennoprzecinkowe nie są równe.
Box	Konwertuje typ wartości na odwołanie do obiektu (typ O).
Br	Bezwarunkowo przenosi kontrolę do instrukcji docelowej.
Br_S	Bezwarunkowo przenosi kontrolę do instrukcji docelowej (krótka forma).
Break	Sygnalizuje, że infrastruktura języka wspólnego (CLI) informuje debugera o tym, że punkt przerwania został potknięty.
Brfalse	Transferuje kontrolkę do instrukcji docelowej, jeśli value to false, odwołanie o wartości null (Nothing w Visual Basic) lub zero.
Brfalse_S	Transferuje kontrolkę do instrukcji docelowej, jeśli value to false, odwołanie o wartości null lub zero.
Brtrue	Transferuje kontrolkę do instrukcji docelowej, jeśli value ma truewartość , nie ma wartości null lub innej niż zero.
Brtrue_S	Transferuje kontrolkę do instrukcji docelowej (krótkiej formy), jeśli value ma truewartość , nie ma wartości null lub innej niż zero.
Call	Wywołuje metodę wskazaną przez deskryptor metody przekazywanej.
Calli	Wywołuje metodę wskazaną na stosie oceny (jako wskaźnik do punktu wejścia) z argumentami opisanymi przez konwencję wywołującą.
Callvirt	Wywołuje metodę z opóźnieniem w obiekcie, wypychając wartość zwracaną do stosu oceny.
Castclass	Próbuje rzutować obiekt przekazany przez odwołanie do określonej klasy.
Ceq	Porównuje dwie wartości. Jeśli są równe, wartość całkowita 1 (int32) jest wypychana do stosu oceny; w przeciwnym razie wartość 0 (int32) jest wypychana do stosu oceny.
Cgt	Porównuje dwie wartości. Jeśli pierwsza wartość jest większa niż druga, wartość całkowita 1 (int32) jest wypychana do stosu oceny; w przeciwnym razie wartość 0 (int32) jest wypychana do stosu oceny.
Cgt_Un	Porównuje dwie niepodpisane lub niepodpisane wartości. Jeśli pierwsza wartość jest większa niż druga, wartość całkowita 1 (int32) jest wypychana do stosu oceny; w przeciwnym razie wartość 0 (int32) jest wypychana do stosu oceny.
Ckfinite	Zgłasza wartość ArithmeticException , jeśli wartość nie jest liczbą skończona.
Clt	Porównuje dwie wartości. Jeśli pierwsza wartość jest mniejsza niż druga, wartość całkowita 1 (int32) jest wypychana do stosu oceny; w przeciwnym razie wartość 0 (int32) jest wypychana do stosu oceny.
Clt_Un	Porównuje niepodpisane lub niepodpisane wartości value1 i value2. Jeśli value1 wartość jest mniejsza niż value2, wartość całkowita 1 (int32) jest wypychana do stosu oceny. W przeciwnym razie wartość 0 (int32) jest wypychana do stosu oceny.
Constrained	Ogranicza typ, na którym jest wykonywane wywołanie metody wirtualnej.
Conv_I	Konwertuje wartość na stos oceny na native intwartość .
Conv_I1	Konwertuje wartość na stos ewaluacyjny na int8, a następnie rozszerza (pady) na int32.
Conv_I2	Konwertuje wartość na stos ewaluacyjny na int16, a następnie rozszerza (pady) na int32.
Conv_I4	Konwertuje wartość na stos oceny na int32wartość .
Conv_I8	Konwertuje wartość na stos oceny na int64wartość .
Conv_Ovf_I	Konwertuje podpisaną wartość na stos oceny na podpisany native int, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I_Un	Konwertuje wartość niepodpisaną na stos oceny na podpisany native int, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I1	Konwertuje podpisaną wartość na stos oceny na podpisany int8 i rozszerza ją na int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I1_Un	Konwertuje wartość niepodpisaną na stos oceny na podpisany int8 i rozszerza ją na int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I2	Konwertuje podpisaną wartość na stos oceny na podpisany int16 i rozszerza ją na int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I2_Un	Konwertuje wartość niepodpisaną na stos oceny na podpisany int16 i rozszerza ją na int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I4	Konwertuje podpisaną wartość na stos oceny na podpisany int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I4_Un	Konwertuje wartość niepodpisaną na stos oceny na podpisany int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I8	Konwertuje podpisaną wartość na stos oceny na podpisany int64, zgłaszając przepełnienie OverflowException .
Conv_Ovf_I8_Un	Konwertuje wartość niepodpisaną na stos oceny na podpisany int64, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U	Konwertuje wartość podpisaną na szczycie stosu ewaluacyjne na unsigned native int, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U_Un	Konwertuje wartość niepodpisaną na stos oceny na unsigned native int, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U1	Konwertuje podpisaną wartość na stos oceny na unsigned int8 i rozszerza ją na int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U1_Un	Konwertuje niepodpisaną wartość na stos oceny na unsigned int8 i rozszerza ją na int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U2	Konwertuje podpisaną wartość na stos oceny na unsigned int16 i rozszerza ją na int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U2_Un	Konwertuje niepodpisaną wartość na stos oceny na unsigned int16 i rozszerza ją na int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U4	Konwertuje wartość podpisaną na szczycie stosu ewaluacyjne na unsigned int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U4_Un	Konwertuje wartość niepodpisaną na stos oceny na unsigned int32, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U8	Konwertuje wartość podpisaną na szczycie stosu ewaluacyjne na unsigned int64, zgłaszając przepełnienie OverflowException .
Conv_Ovf_U8_Un	Konwertuje wartość niepodpisaną na stos oceny na unsigned int64, zgłaszając przepełnienie OverflowException .
Conv_R_Un	Konwertuje wartość niepodpisanej liczby całkowitej na stos oceny na float32wartość .
Conv_R4	Konwertuje wartość na stos oceny na float32wartość .
Conv_R8	Konwertuje wartość na stos oceny na float64wartość .
Conv_U	Konwertuje wartość na stos oceny na unsigned native intwartość , a następnie rozszerza ją na native int.
Conv_U1	Konwertuje wartość na stos oceny na unsigned int8wartość , a następnie rozszerza ją na int32.
Conv_U2	Konwertuje wartość na stos oceny na unsigned int16wartość , a następnie rozszerza ją na int32.
Conv_U4	Konwertuje wartość na stos oceny na unsigned int32wartość , a następnie rozszerza ją na int32.
Conv_U8	Konwertuje wartość na stos oceny na unsigned int64wartość , a następnie rozszerza ją na int64.
Cpblk	Kopiuje określoną liczbę bajtów z adresu źródłowego do adresu docelowego.
Cpobj	Kopiuje typ wartości znajdujący się pod adresem obiektu (typ &lub ) do adresu obiektu docelowego (typ &, lub ).native intnative int
Div	Dzieli dwie wartości i wypycha wynik jako zmiennoprzecinkowy (typ ) lub iloraz (typ Fint32) na stos oceny.
Div_Un	Dzieli dwie niepodpisane wartości całkowite i wypycha wynik (int32) do stosu oceny.
Dup	Kopiuje bieżącą najwyższą wartość na stosie oceny, a następnie wypycha kopię do stosu ewaluacyjnego.
Endfilter	Transferuje kontrolkę z filter klauzuli wyjątku z powrotem do procedury obsługi wyjątków infrastruktury języka wspólnego (CLI).
Endfinally	Przenosi kontrolę z fault klauzuli or finally bloku wyjątków z powrotem do procedury obsługi wyjątków infrastruktury języka wspólnego (CLI).
Initblk	Inicjuje określony blok pamięci pod określonym adresem dla danego rozmiaru i wartości początkowej.
Initobj	Inicjuje każde pole typu wartości pod określonym adresem do odwołania o wartości null lub 0 odpowiedniego typu pierwotnego.
Isinst	Sprawdza, czy odwołanie do obiektu (typ O) jest wystąpieniem określonej klasy.
Jmp	Zamyka bieżącą metodę i przechodzi do określonej metody.
Ldarg	Ładuje argument (przywoływany przez określoną wartość indeksu) na stos.
Ldarg_0	Ładuje argument w indeksie 0 do stosu oceny.
Ldarg_1	Ładuje argument w indeksie 1 do stosu oceny.
Ldarg_2	Ładuje argument w indeksie 2 do stosu oceny.
Ldarg_3	Ładuje argument w indeksie 3 do stosu oceny.
Ldarg_S	Ładuje argument (przywoływany przez określony indeks krótkiej formy) na stos oceny.
Ldarga	Załaduj adres argumentu do stosu oceny.
Ldarga_S	Załaduj adres argumentu w skrócie do stosu oceny.
Ldc_I4	Wypycha podaną wartość typu int32 do stosu oceny jako int32.
Ldc_I4_0	Wypycha wartość całkowitą o wartości 0 do stosu oceny jako int32.
Ldc_I4_1	Wypycha wartość całkowitą o wartości 1 do stosu oceny jako int32.
Ldc_I4_2	Wypycha wartość całkowitą 2 do stosu oceny jako int32.
Ldc_I4_3	Wypycha wartość całkowitą o wartości 3 do stosu oceny jako int32.
Ldc_I4_4	Wypycha wartość całkowitą o wartości 4 do stosu oceny jako int32.
Ldc_I4_5	Wypycha wartość całkowitą o wartości 5 do stosu oceny jako int32.
Ldc_I4_6	Wypycha wartość całkowitą o wartości 6 do stosu oceny jako int32.
Ldc_I4_7	Wypycha wartość całkowitą o wartości 7 do stosu oceny jako int32.
Ldc_I4_8	Wypycha wartość całkowitą o wartości 8 do stosu oceny jako int32.
Ldc_I4_M1	Wypycha wartość całkowitą -1 do stosu oceny jako int32.
Ldc_I4_S	Wypycha podaną int8 wartość do stosu oceny jako krótką formę int32.
Ldc_I8	Wypycha podaną wartość typu int64 do stosu oceny jako int64.
Ldc_R4	Wypycha podaną wartość typu float32 do stosu oceny jako typ F (float).
Ldc_R8	Wypycha podaną wartość typu float64 do stosu oceny jako typ F (float).
Ldelem	Ładuje element w określonym indeksie tablicy na początku stosu oceny jako typ określony w instrukcji.
Ldelem_I	Ładuje element z typem native int w określonym indeksie tablicy na początku stosu oceny jako native int.
Ldelem_I1	Ładuje element z typem int8 w określonym indeksie tablicy na początku stosu oceny jako int32.
Ldelem_I2	Ładuje element z typem int16 w określonym indeksie tablicy na początku stosu oceny jako int32.
Ldelem_I4	Ładuje element z typem int32 w określonym indeksie tablicy na początku stosu oceny jako int32.
Ldelem_I8	Ładuje element z typem int64 w określonym indeksie tablicy na początku stosu oceny jako int64.
Ldelem_R4	Ładuje element z typem float32 w określonym indeksie tablicy na początku stosu oceny jako typ F (float).
Ldelem_R8	Ładuje element z typem float64 w określonym indeksie tablicy na początku stosu oceny jako typ F (float).
Ldelem_Ref	Ładuje element zawierający odwołanie do obiektu w określonym indeksie tablicy na początku stosu oceny jako typ O (odwołanie do obiektu).
Ldelem_U1	Ładuje element z typem unsigned int8 w określonym indeksie tablicy na początku stosu oceny jako int32.
Ldelem_U2	Ładuje element z typem unsigned int16 w określonym indeksie tablicy na początku stosu oceny jako int32.
Ldelem_U4	Ładuje element z typem unsigned int32 w określonym indeksie tablicy na początku stosu oceny jako int32.
Ldelema	Ładuje adres elementu tablicy w określonym indeksie tablicy na początku stosu oceny jako typ & (zarządzany wskaźnik).
Ldfld	Znajduje wartość pola w obiekcie, którego odwołanie znajduje się obecnie na stosie oceny.
Ldflda	Znajduje adres pola w obiekcie, którego odwołanie znajduje się obecnie na stosie oceny.
Ldftn	Wypycha niezarządzany wskaźnik (typ native int) do kodu natywnego implementjącego określoną metodę na stosie oceny.
Ldind_I	Ładuje wartość typu native int jako native int wartość na stos oceny pośrednio.
Ldind_I1	Ładuje wartość typu int8 jako element int32 na stos oceny pośrednio.
Ldind_I2	Ładuje wartość typu int16 jako element int32 na stos oceny pośrednio.
Ldind_I4	Ładuje wartość typu int32 jako element int32 na stos oceny pośrednio.
Ldind_I8	Ładuje wartość typu int64 jako element int64 na stos oceny pośrednio.
Ldind_R4	Ładuje wartość typu float32 jako typ F (zmiennoprzecinkowy) na stos oceny pośrednio.
Ldind_R8	Ładuje wartość typu float64 jako typ F (zmiennoprzecinkowy) na stos oceny pośrednio.
Ldind_Ref	Ładuje odwołanie do obiektu jako typ O (odwołanie do obiektu) na stos oceny pośrednio.
Ldind_U1	Ładuje wartość typu unsigned int8 jako element int32 na stos oceny pośrednio.
Ldind_U2	Ładuje wartość typu unsigned int16 jako element int32 na stos oceny pośrednio.
Ldind_U4	Ładuje wartość typu unsigned int32 jako element int32 na stos oceny pośrednio.
Ldlen	Wypycha liczbę elementów tablicy jednowymiarowej opartej na zerze do stosu oceny.
Ldloc	Ładuje zmienną lokalną w określonym indeksie do stosu oceny.
Ldloc_0	Ładuje zmienną lokalną na indeksie 0 do stosu oceny.
Ldloc_1	Ładuje zmienną lokalną w indeksie 1 do stosu oceny.
Ldloc_2	Ładuje zmienną lokalną w indeksie 2 do stosu oceny.
Ldloc_3	Ładuje zmienną lokalną w indeksie 3 do stosu oceny.
Ldloc_S	Ładuje zmienną lokalną w określonym indeksie do stosu oceny, krótki formularz.
Ldloca	Ładuje adres zmiennej lokalnej w określonym indeksie na stosie oceny.
Ldloca_S	Ładuje adres zmiennej lokalnej w określonym indeksie na stosie oceny, krótki formularz.
Ldnull	Wypycha odwołanie o wartości null (typ O) do stosu oceny.
Ldobj	Kopiuje obiekt typu wartości wskazywany przez adres na początku stosu oceny.
Ldsfld	Wypycha wartość pola statycznego do stosu oceny.
Ldsflda	Wypycha adres pola statycznego do stosu oceny.
Ldstr	Wypycha nowe odwołanie do obiektu do literału ciągu przechowywanego w metadanych.
Ldtoken	Konwertuje token metadanych na reprezentację środowiska uruchomieniowego, wypychając go do stosu oceny.
Ldvirtftn	Wypycha niezarządzany wskaźnik (typ native int) do kodu natywnego implementowania określonej metody wirtualnej skojarzonej z określonym obiektem na stosie oceny.
Leave	Zamyka chroniony region kodu, bezwarunkowo przenosząc kontrolę do określonej instrukcji docelowej.
Leave_S	Zamyka chroniony region kodu, bezwarunkowo przenosząc kontrolę do instrukcji docelowej (krótka forma).
Localloc	Przydziela określoną liczbę bajtów z lokalnej puli pamięci dynamicznej i wypycha adres (wskaźnik przejściowy, typ *) pierwszego przydzielonego bajtu do stosu oceny.
Mkrefany	Wypycha typizowane odwołanie do wystąpienia określonego typu na stos oceny.
Mul	Mnoży dwie wartości i wypycha wynik na stosie oceny.
Mul_Ovf	Mnoży dwie wartości całkowite, przeprowadza kontrolę przepełnienia i wypycha wynik do stosu oceny.
Mul_Ovf_Un	Mnoży dwie niepodpisane wartości całkowite, sprawdza przepełnienie i wypycha wynik do stosu oceny.
Neg	Neguje wartość i wypycha wynik do stosu oceny.
Newarr	Wypycha odwołanie do obiektu do nowej tablicy jednowymiarowej opartej na zerach, której elementy mają określony typ do stosu oceny.
Newobj	Tworzy nowy obiekt lub nowe wystąpienie typu wartości, wypychając odwołanie do obiektu (typ O) do stosu oceny.
Nop	Wypełnia miejsce, jeśli kody operacyjne są poprawiane. Nie jest wykonywana żadna znacząca operacja, chociaż można użyć cyklu przetwarzania.
Not	Oblicza bitowe uzupełnienie wartości całkowitej na stosie i wypycha wynik do stosu oceny co ten sam typ.
Or	Oblicz bitowe uzupełnienie dwóch wartości całkowitych na stosie i wypchnie wynik do stosu oceny.
Pop	Usuwa wartość obecnie na stosie oceny.
Prefix1	Jest to zarezerwowana instrukcja.
Prefix2	Jest to zarezerwowana instrukcja.
Prefix3	Jest to zarezerwowana instrukcja.
Prefix4	Jest to zarezerwowana instrukcja.
Prefix5	Jest to zarezerwowana instrukcja.
Prefix6	Jest to zarezerwowana instrukcja.
Prefix7	Jest to zarezerwowana instrukcja.
Prefixref	Jest to zarezerwowana instrukcja.
Readonly	Określa, że kolejna operacja adres tablicy nie wykonuje sprawdzania typu w czasie wykonywania i zwraca zarządzany wskaźnik, którego niezmienność jest ograniczona.
Refanytype	Pobiera token typu osadzony w odwołaniu wpisanym.
Refanyval	Pobiera adres (typ &) osadzony w wpisanym odwołaniu.
Rem	Dzieli dwie wartości i wypycha resztę do stosu oceny.
Rem_Un	Dzieli dwie niepodpisane wartości i wypycha resztę do stosu oceny.
Ret	Zwraca wartość z bieżącej metody, wypychając wartość zwracaną (jeśli istnieje) ze stosu oceny wywoływanego do stosu oceny obiektu wywołującego.
Rethrow	Ponownie zwraca bieżący wyjątek.
Shl	Przesuwa wartość całkowitą do lewej (w zerach) przez określoną liczbę bitów, wypychając wynik do stosu ewaluacyjnego.
Shr	Przesuwa wartość całkowitą (w logowaniu) po prawej stronie przez określoną liczbę bitów, wypychając wynik do stosu oceny.
Shr_Un	Przesuwa niepodpisaną wartość całkowitą (w zerach) po prawej stronie o określoną liczbę bitów, wypychając wynik do stosu oceny.
Sizeof	Wypycha rozmiar w bajtach podanego typu wartości do stosu ewaluacyjnego.
Starg	Przechowuje wartość na stosie ewaluacyjnym w miejscu argumentu w określonym indeksie.
Starg_S	Przechowuje wartość na stosie ewaluacyjnym w miejscu argumentu w określonym indeksie, krótkim formularzu.
Stelem	Zamienia element tablicy w danym indeksie na wartość stosu oceny, którego typ jest określony w instrukcji.
Stelem_I	Zastępuje element tablicy w danym indeksie wartością native int stosu oceny.
Stelem_I1	Zastępuje element tablicy w danym indeksie wartością int8 stosu oceny.
Stelem_I2	Zastępuje element tablicy w danym indeksie wartością int16 stosu oceny.
Stelem_I4	Zastępuje element tablicy w danym indeksie wartością int32 stosu oceny.
Stelem_I8	Zastępuje element tablicy w danym indeksie wartością int64 stosu oceny.
Stelem_R4	Zastępuje element tablicy w danym indeksie wartością float32 stosu oceny.
Stelem_R8	Zastępuje element tablicy w danym indeksie wartością float64 stosu oceny.
Stelem_Ref	Zastępuje element tablicy w danym indeksie wartością ref obiektu (type O) na stosie oceny.
Stfld	Zastępuje wartość przechowywaną w polu odwołania do obiektu lub wskaźnika nową wartością.
Stind_I	Przechowuje wartość typu native int pod podanym adresem.
Stind_I1	Przechowuje wartość typu int8 pod podanym adresem.
Stind_I2	Przechowuje wartość typu int16 pod podanym adresem.
Stind_I4	Przechowuje wartość typu int32 pod podanym adresem.
Stind_I8	Przechowuje wartość typu int64 pod podanym adresem.
Stind_R4	Przechowuje wartość typu float32 pod podanym adresem.
Stind_R8	Przechowuje wartość typu float64 pod podanym adresem.
Stind_Ref	Przechowuje wartość odwołania do obiektu pod podanym adresem.
Stloc	Wyświetla bieżącą wartość z górnej części stosu oceny i przechowuje ją na liście zmiennych lokalnych w określonym indeksie.
Stloc_0	Wyświetla bieżącą wartość z góry stosu oceny i przechowuje ją na liście zmiennych lokalnych na indeksie 0.
Stloc_1	Wyświetla bieżącą wartość z górnej części stosu oceny i przechowuje ją na liście zmiennych lokalnych w indeksie 1.
Stloc_2	Wyświetla bieżącą wartość z górnej części stosu oceny i przechowuje ją na liście zmiennych lokalnych w indeksie 2.
Stloc_3	Wyświetla bieżącą wartość z góry stosu oceny i przechowuje ją na liście zmiennych lokalnych w indeksie 3.
Stloc_S	Wyświetla bieżącą wartość z górnej części stosu oceny i przechowuje ją na liście zmiennych lokalnych w lokalizacji index (krótka forma).
Stobj	Kopiuje wartość określonego typu ze stosu ewaluacyjnego do dostarczonego adresu pamięci.
Stsfld	Zastępuje wartość pola statycznego wartością ze stosu oceny.
Sub	Odejmuje jedną wartość z innej i wypycha wynik do stosu oceny.
Sub_Ovf	Odejmuje jedną wartość całkowitą z innej, sprawdza przepełnienie i wypycha wynik do stosu oceny.
Sub_Ovf_Un	Odejmuje jedną niepodpisaną wartość całkowitą z innej, przeprowadza sprawdzanie przepełnienia i wypycha wynik do stosu oceny.
Switch	Implementuje tabelę przesiadkową.
Tailcall	Wykonuje instrukcję wywołania metody postfixed, tak aby ramka stosu bieżącej metody została usunięta przed wykonaniem rzeczywistej instrukcji wywołania.
Throw	Zgłasza obiekt wyjątku aktualnie na stosie oceny.
Unaligned	Wskazuje, że adres obecnie na szczycie stosu oceny może nie być wyrównany do naturalnego rozmiaru natychmiast po ldind, ldobjstindstfldstobjldfldinitblklub cpblk instrukcji.
Unbox	Konwertuje skrzynkową reprezentację typu wartości na formularz bez skrzynki odbiorczej.
Unbox_Any	Konwertuje skrzynkową reprezentację typu określonego w instrukcji na formularz bez skrzynki odbiorczej.
Volatile	Określa, że adres obecnie na szczycie stosu oceny może być niestabilny, a wyniki odczytu tej lokalizacji nie mogą być buforowane lub że nie można pominąć wielu magazynów w tej lokalizacji.
Xor	Oblicza bitowe XOR dwóch pierwszych wartości na stosie oceny, wypychając wynik do stosu oceny.

Metody

Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera bieżące wystąpienie. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
TakesSingleByteArgument(OpCode)	Zwraca wartość true lub false, jeśli podany kod opcode przyjmuje pojedynczy argument bajtowy.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)