Udostępnij za pośrednictwem


OpCodes Klasa

Definicja

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
[System.Runtime.InteropServices.ComVisible(true)]
public class OpCodes
type OpCodes = class
[<System.Runtime.InteropServices.ComVisible(true)>]
type OpCodes = class
Public Class OpCodes
Dziedziczenie
OpCodes
Atrybuty

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)

Dotyczy