OpCodes Klasse

Definition

Stellt Felddarstellungen der MSIL (Microsoft Intermediate Language)-Anweisungen für die Ausgabe durch die ILGenerator-Klassenmember bereit, beispielsweise 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
Vererbung
OpCodes
Attribute

Beispiele

Im folgenden Beispiel wird die Konstruktion einer dynamischen Methode veranschaulicht, die ILGenerator zum Ausgeben OpCodes in eine 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

Hinweise

Eine detaillierte Beschreibung der Member opcodes finden Sie in der Dokumentation zur Common Language Infrastructure (CLI), insbesondere "Partition III: CIL-Anweisungssatz" und "Partition II: Metadatendefinition und Semantik". Weitere Informationen finden Sie unter ECMA 335 Common Language Infrastructure (CLI).

Felder

Add

Addiert zwei Werte und legt das Ergebnis auf dem Auswertungsstapel ab.

Add_Ovf

Addiert zwei ganze Zahlen, führt eine Überlaufprüfung durch und legt das Ergebnis auf dem Auswertungsstapel ab.

Add_Ovf_Un

Addiert zwei Ganzzahlwerte ohne Vorzeichen, führt eine Überlaufprüfung durch und legt das Ergebnis auf dem Auswertungsstapel ab.

And

Berechnet das bitweise AND für zwei Werte und legt das Ergebnis auf dem Auswertungsstapel ab.

Arglist

Gibt einen nicht verwalteten Zeiger auf die Argumentliste der aktuellen Methode zurück.

Beq

Überträgt die Steuerung an eine Zielanweisung, wenn zwei Werte übereinstimmen.

Beq_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn zwei Werte übereinstimmen.

Bge

Überträgt die Steuerung an eine Zielanweisung, wenn der erste Wert größer oder gleich dem zweiten Wert ist.

Bge_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn der erste Wert größer oder gleich dem zweiten Wert ist.

Bge_Un

Überträgt die Steuerung an eine Zielanweisung, wenn Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte verglichen werden und der erste Wert größer als der zweite Wert ist.

Bge_Un_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte verglichen werden und der erste Wert größer als der zweite Wert ist.

Bgt

Überträgt die Steuerung an eine Zielanweisung, wenn der erste Wert größer als der zweite Wert ist.

Bgt_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn der erste Wert größer als der zweite Wert ist.

Bgt_Un

Überträgt die Steuerung an eine Zielanweisung, wenn Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte verglichen werden und der erste Wert größer als der zweite Wert ist.

Bgt_Un_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte verglichen werden und der erste Wert größer als der zweite Wert ist.

Ble

Überträgt die Steuerung an eine Zielanweisung, wenn der erste Wert kleiner oder gleich dem zweiten Wert ist.

Ble_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn der erste Wert kleiner oder gleich dem zweiten Wert ist.

Ble_Un

Überträgt die Steuerung an eine Zielanweisung, wenn Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte verglichen werden und der erste Wert kleiner oder gleich dem zweiten Wert ist.

Ble_Un_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte verglichen werden und der erste Wert kleiner oder gleich dem zweiten Wert ist.

Blt

Überträgt die Steuerung an eine Zielanweisung, wenn der erste Wert kleiner als der zweite Wert ist.

Blt_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn der erste Wert kleiner als der zweite Wert ist.

Blt_Un

Überträgt die Steuerung an eine Zielanweisung, wenn Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte verglichen werden und der erste Wert kleiner als der zweite Wert ist.

Blt_Un_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte verglichen werden und der erste Wert kleiner als der zweite Wert ist.

Bne_Un

Überträgt die Steuerung an eine Zielanweisung, wenn zwei Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte ungleich sind.

Bne_Un_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn zwei Ganzzahlwerte ohne Vorzeichen oder ungeordnete Gleitkommawerte ungleich sind.

Box

Konvertiert einen Werttyp in einen Objektverweis (Typ O).

Br

Überträgt die Steuerung bedingungslos an eine Zielanweisung.

Br_S

Überträgt die Steuerung bedingungslos an eine Zielanweisung (Kurzform).

Break

Signalisiert CLI (Common Language Infrastructure), den Debugger darüber zu informieren, dass ein Haltepunkt erreicht wurde.

Brfalse

Überträgt die Steuerung an eine Zielanweisung, wenn value entweder false, ein NULL-Verweis (Nothing in Visual Basic) oder 0 (null) ist.

Brfalse_S

Überträgt die Steuerung an eine Zielanweisung, wenn value entweder false, ein NULL-Verweis oder 0 (null) ist.

Brtrue

Überträgt die Steuerung an eine Zielanweisung, wenn value entweder true, nicht NULL oder ungleich 0 (null) ist.

Brtrue_S

Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn value entweder true, nicht NULL oder ungleich 0 (null) ist.

Call

Ruft die Methode auf, die der übergebene Methodendeskriptor angibt.

Calli

Ruft die angegebene Methode auf dem Auswertungsstapel (als Zeiger auf einen Einstiegspunkt) mit Argumenten auf, die durch eine Aufrufkonvention beschrieben sind.

Callvirt

Ruft eine spät gebundene Methode für ein Objekt auf und legt den Rückgabewert auf dem Auswertungsstapel ab.

Castclass

Wandelt ein als Verweis übergebenes Objekt in die angegebene Klasse um.

Ceq

Vergleicht zwei Werte. Wenn sie gleich sind, wird der Ganzzahlwert 1 (int32) auf dem Auswertungsstapel abgelegt, andernfalls wird 0 (int32) auf dem Auswertungsstapel abgelegt.

Cgt

Vergleicht zwei Werte. Wenn der erste Wert größer als der zweite Wert ist, wird der Ganzzahlwert 1 (int32) auf dem Auswertungsstapel abgelegt, andernfalls wird 0 (int32) auf dem Auswertungsstapel abgelegt.

Cgt_Un

Vergleicht zwei Werte ohne Vorzeichen oder zwei ungeordnete Werte. Wenn der erste Wert größer als der zweite Wert ist, wird der Ganzzahlwert 1 (int32) auf dem Auswertungsstapel abgelegt, andernfalls wird 0 (int32) auf dem Auswertungsstapel abgelegt.

Ckfinite

Löst ArithmeticException aus, wenn der Wert keine endliche Zahl ist.

Clt

Vergleicht zwei Werte. Wenn der erste Wert kleiner als der zweite Wert ist, wird der Ganzzahlwert 1 (int32) auf dem Auswertungsstapel abgelegt, andernfalls wird 0 (int32) auf dem Auswertungsstapel abgelegt.

Clt_Un

Vergleicht die Werte ohne Vorzeichen oder die ungeordneten Werte value1 und value2. Wenn value1 kleiner als value2 ist, wird der Ganzzahlwert 1 (int32) auf dem Auswertungsstapel abgelegt, andernfalls wird 0 (int32) auf dem Auswertungsstapel abgelegt.

Constrained

Schränkt den Typ ein, für den eine virtuelle Methode aufgerufen wird.

Conv_I

Konvertiert den Wert an oberster Position des Auswertungsstapels in native int.

Conv_I1

Konvertiert den Wert an oberster Position des Auswertungsstapels in int8 und erweitert ihn dann zu int32 (durch Auffüllen).

Conv_I2

Konvertiert den Wert an oberster Position des Auswertungsstapels in int16 und erweitert ihn dann zu int32 (durch Auffüllen).

Conv_I4

Konvertiert den Wert an oberster Position des Auswertungsstapels in int32.

Conv_I8

Konvertiert den Wert an oberster Position des Auswertungsstapels in int64.

Conv_Ovf_I

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in native int. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_I_Un

Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in native int mit Vorzeichen und löst bei einem Überlauf eine OverflowException aus.

Conv_Ovf_I1

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in int8 mit Vorzeichen und erweitert ihn auf int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_I1_Un

Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in int8 mit Vorzeichen und erweitert ihn auf int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_I2

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in int16 mit Vorzeichen und erweitert ihn auf int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_I2_Un

Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in int16 mit Vorzeichen und erweitert ihn auf int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_I4

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_I4_Un

Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in int32 mit Vorzeichen und löst bei einem Überlauf eine OverflowException aus.

Conv_Ovf_I8

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in int64. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_I8_Un

Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in int64 mit Vorzeichen und löst bei einem Überlauf eine OverflowException aus.

Conv_Ovf_U

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in unsigned native int und löst bei einem Überlauf eine OverflowException aus.

Conv_Ovf_U_Un

Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in unsigned native int und löst bei einem Überlauf eine OverflowException aus.

Conv_Ovf_U1

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in unsigned int8 und erweitert ihn auf int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_U1_Un

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in unsigned int8 und erweitert ihn auf int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_U2

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in unsigned int16 und erweitert ihn auf int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_U2_Un

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in unsigned int16 und erweitert ihn auf int32. Bei einem Überlauf wird eine OverflowException ausgelöst.

Conv_Ovf_U4

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in unsigned int32 und löst bei einem Überlauf eine OverflowException aus.

Conv_Ovf_U4_Un

Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in unsigned int32 und löst bei einem Überlauf eine OverflowException aus.

Conv_Ovf_U8

Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in unsigned int64 und löst bei einem Überlauf eine OverflowException aus.

Conv_Ovf_U8_Un

Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in unsigned int64 und löst bei einem Überlauf eine OverflowException aus.

Conv_R_Un

Konvertiert den Ganzzahlwert ohne Vorzeichen an oberster Position des Auswertungsstapels in float32.

Conv_R4

Konvertiert den Wert an oberster Position des Auswertungsstapels in float32.

Conv_R8

Konvertiert den Wert an oberster Position des Auswertungsstapels in float64.

Conv_U

Konvertiert den Wert an oberster Position des Auswertungsstapels in unsigned native int und erweitert ihn dann zu native int.

Conv_U1

Konvertiert den Wert an oberster Position des Auswertungsstapels in unsigned int8 und erweitert ihn dann zu int32.

Conv_U2

Konvertiert den Wert an oberster Position des Auswertungsstapels in unsigned int16 und erweitert ihn dann zu int32.

Conv_U4

Konvertiert den Wert an oberster Position des Auswertungsstapels in unsigned int32 und erweitert ihn dann zu int32.

Conv_U8

Konvertiert den Wert an oberster Position des Auswertungsstapels in unsigned int64 und erweitert ihn dann zu int64.

Cpblk

Kopiert eine angegebene Anzahl von Bytes von einer Quelladresse an eine Zieladresse.

Cpobj

Kopiert den Werttyp, der an der Adresse eines Objekts gespeichert ist (Typ &, oder native int), an die Adresse des Zielobjekts (Typ &, oder native int).

Div

Dividiert zwei Werte und legt das Ergebnis als Gleitkommawert (Typ F) oder Quotient (Typ int32) auf dem Auswertungsstapel ab.

Div_Un

Dividiert zwei Ganzzahlwerte ohne Vorzeichen und legt das Ergebnis (int32) auf dem Auswertungsstapel ab.

Dup

Kopiert den obersten Wert auf dem Auswertungsstapel und legt die Kopie dann auf dem Auswertungsstapel ab.

Endfilter

Überträgt die Steuerung von der filter-Klausel einer Ausnahme zurück an den CLI-Ausnahmehandler (Common Language Infrastructure).

Endfinally

Überträgt die Steuerung aus der fault-Klausel oder finally-Klausel eines Ausnahmeblockes zurück an den CLI-Ausnahmehandler (Common Language Infrastructure).

Initblk

Initialisiert einen angegebenen Speicherblock an einer bestimmten Adresse mit einer angegebenen Größe und einem angegebenen Anfangswert.

Initobj

Initialisiert alle Felder des Werttyps an einer angegebenen Adresse mit einem NULL-Verweis oder dem Wert 0 des entsprechenden primitiven Typs.

Isinst

Überprüft, ob ein Objektverweis (Typ O) eine Instanz einer bestimmten Klasse ist.

Jmp

Beendet die aktuelle Methode und wechselt zur angegebenen Methode.

Ldarg

Lädt ein Argument, auf das ein angegebener Indexwert verweist, in den Stapel.

Ldarg_0

Lädt das Argument am Index 0 in den Auswertungsstapel.

Ldarg_1

Lädt das Argument am Index 1 in den Auswertungsstapel.

Ldarg_2

Lädt das Argument am Index 2 in den Auswertungsstapel.

Ldarg_3

Lädt das Argument am Index 3 in den Auswertungsstapel.

Ldarg_S

Lädt das Argument, auf das ein angegebener Kurzformindex verweist, in den Stapel.

Ldarga

Lädt eine Argumentadresse in den Auswertungsstapel.

Ldarga_S

Lädt eine Argumentadresse in Kurzform in den Auswertungsstapel.

Ldc_I4

Legt einen bereitgestellten Wert vom Typ int32 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_0

Legt den Ganzzahlwert 0 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_1

Legt den Ganzzahlwert 1 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_2

Legt den Ganzzahlwert 2 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_3

Legt den Ganzzahlwert 3 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_4

Legt den Ganzzahlwert 4 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_5

Legt den Ganzzahlwert 5 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_6

Legt den Ganzzahlwert 6 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_7

Legt den Ganzzahlwert 7 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_8

Legt den Ganzzahlwert 8 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_M1

Legt den Ganzzahlwert -1 als int32 auf dem Auswertungsstapel ab.

Ldc_I4_S

Legt den bereitgestellten int8-Wert als int32, Kurzform, auf dem Auswertungsstapel ab.

Ldc_I8

Legt einen bereitgestellten Wert vom Typ int64 als int64 auf dem Auswertungsstapel ab.

Ldc_R4

Legt einen bereitgestellten Wert vom Typ float32 als Typ F (Gleitkommawert) auf dem Auswertungsstapel ab.

Ldc_R8

Legt einen bereitgestellten Wert vom Typ float64 als Typ F (Gleitkommawert) auf dem Auswertungsstapel ab.

Ldelem

Lädt das Element an einem angegebenen Arrayindex als der in der Anweisung angegebene Typ auf die oberste Position des Auswertungsstapels.

Ldelem_I

Lädt das Element mit dem Typ native int an einem angegebenen Arrayindex als native int auf die oberste Position des Auswertungsstapels.

Ldelem_I1

Lädt das Element mit dem Typ int8 an einem angegebenen Arrayindex als int32 an die oberste Position des Auswertungsstapels.

Ldelem_I2

Lädt das Element mit dem Typ int16 an einem angegebenen Arrayindex als int32 an die oberste Position des Auswertungsstapels.

Ldelem_I4

Lädt das Element mit dem Typ int32 an einem angegebenen Arrayindex als int32 an die oberste Position des Auswertungsstapels.

Ldelem_I8

Lädt das Element mit dem Typ int64 an einem angegebenen Arrayindex als int64 an die oberste Position des Auswertungsstapels.

Ldelem_R4

Lädt das Element vom Typ float32 an einem angegebenen Arrayindex als Typ F (Gleitkommawert) an die oberste Position des Auswertungsstapels.

Ldelem_R8

Lädt das Element vom Typ float64 an einem angegebenen Arrayindex als Typ F (Gleitkommawert) an die oberste Position des Auswertungsstapels.

Ldelem_Ref

Lädt das Element mit Objektverweis an einem angegebenen Arrayindex als Typ O (Objektverweis) an die oberste Position des Auswertungsstapels.

Ldelem_U1

Lädt das Element mit dem Typ unsigned int8 an einem angegebenen Arrayindex als int32 an die oberste Position des Auswertungsstapels.

Ldelem_U2

Lädt das Element mit dem Typ unsigned int16 an einem angegebenen Arrayindex als int32 an die oberste Position des Auswertungsstapels.

Ldelem_U4

Lädt das Element mit dem Typ unsigned int32 an einem angegebenen Arrayindex als int32 an die oberste Position des Auswertungsstapels.

Ldelema

Lädt die Adresse des Arrayelements an einem angegebenen Arrayindex als Typ & (verwalteter Zeiger) an die oberste Position des Auswertungsstapels.

Ldfld

Sucht den Wert eines Felds in dem Objekt, für das sich derzeit ein Verweis auf dem Auswertungsstapel befindet.

Ldflda

Sucht die Adresse eines Felds in dem Objekt, für das sich derzeit ein Verweis auf dem Auswertungsstapel befindet.

Ldftn

Legt einen nicht verwalteten Zeiger (Typ native int) auf dem Auswertungsstapel ab. Dieser Zeiger zeigt auf den systemeigenen Code, der eine bestimmte Methode implementiert.

Ldind_I

Lädt einen Wert vom Typ native int indirekt als native int in den Auswertungsstapel.

Ldind_I1

Lädt einen Wert vom Typ int8 indirekt als int32 in den Auswertungsstapel.

Ldind_I2

Lädt einen Wert vom Typ int16 indirekt als int32 in den Auswertungsstapel.

Ldind_I4

Lädt einen Wert vom Typ int32 indirekt als int32 in den Auswertungsstapel.

Ldind_I8

Lädt einen Wert vom Typ int64 indirekt als int64 in den Auswertungsstapel.

Ldind_R4

Lädt einen Wert vom Typ float32 indirekt als Typ F (Gleitkommawert) in den Auswertungsstapel.

Ldind_R8

Lädt einen Wert vom Typ float64 indirekt als Typ F (Gleitkommawert) in den Auswertungsstapel.

Ldind_Ref

Lädt einen Objektverweis indirekt als Typ O (Objektverweis) in den Auswertungsstapel.

Ldind_U1

Lädt einen Wert vom Typ unsigned int8 indirekt als int32 in den Auswertungsstapel.

Ldind_U2

Lädt einen Wert vom Typ unsigned int16 indirekt als int32 in den Auswertungsstapel.

Ldind_U4

Lädt einen Wert vom Typ unsigned int32 indirekt als int32 in den Auswertungsstapel.

Ldlen

Legt die Anzahl der Elemente eines nullbasierten, eindimensionalen Arrays auf dem Auswertungsstapel ab.

Ldloc

Lädt die lokale Variable an einem bestimmten Index in den Auswertungsstapel.

Ldloc_0

Lädt die lokale Variable am Index 0 in den Auswertungsstapel.

Ldloc_1

Lädt die lokale Variable am Index 1 in den Auswertungsstapel.

Ldloc_2

Lädt die lokale Variable am Index 2 in den Auswertungsstapel.

Ldloc_3

Lädt die lokale Variable am Index 3 in den Auswertungsstapel.

Ldloc_S

Lädt die lokale Variable an einem bestimmten Index in den Auswertungsstapel, Kurzform.

Ldloca

Lädt die Adresse der lokalen Variablen am angegebenen Index in den Auswertungsstapel.

Ldloca_S

Lädt die Adresse der lokalen Variablen am angegebenen Index in den Auswertungsstapel, Kurzform.

Ldnull

Legt einen NULL-Verweis (Typ O) auf dem Auswertungsstapel ab.

Ldobj

Kopiert das Werttypobjekt, auf das eine Adresse zeigt, an die oberste Position des Auswertungsstapels.

Ldsfld

Legt den Wert eines statischen Felds auf dem Auswertungsstapel ab.

Ldsflda

Legt die Adresse eines statischen Felds auf dem Auswertungsstapel ab.

Ldstr

Legt einen neuen Objektverweis auf ein in den Metadaten gespeichertes Zeichenfolgenliteral mittels Push ab.

Ldtoken

Konvertiert ein Metadatentoken in seine Laufzeitdarstellung und legt es auf dem Auswertungsstapel ab.

Ldvirtftn

Legt einen nicht verwalteten Zeiger (Typ native int) auf systemeigenen Code auf dem Auswertungsstapel ab. Dieser Code implementiert eine bestimmte virtuelle Methode, die einem angegebenen Objekt zugeordnet ist.

Leave

Beendet einen geschützten Codebereich, wobei die Steuerung bedingungslos an eine bestimmte Zielanweisung übertragen wird.

Leave_S

Beendet einen geschützten Codebereich, wobei die Steuerung bedingungslos an eine bestimmte Zielanweisung übertragen wird, Kurzform.

Localloc

Belegt eine bestimmte Anzahl von Bytes aus dem lokalen dynamischen Speicherpool und legt die Adresse (einen flüchtigen Zeiger, Typ *) des ersten reservierten Bytes auf dem Auswertungsstapel ab.

Mkrefany

Legt einen typisierten Verweis auf eine Instanz eines bestimmten Typs auf dem Auswertungsstapel ab.

Mul

Multipliziert zwei Werte und legt das Ergebnis auf dem Auswertungsstapel ab.

Mul_Ovf

Multipliziert zwei Ganzzahlwerte, führt eine Überlaufprüfung durch und legt das Ergebnis auf dem Auswertungsstapel ab.

Mul_Ovf_Un

Multipliziert zwei Ganzzahlwerte ohne Vorzeichen, führt eine Überlaufprüfung durch und legt das Ergebnis auf dem Auswertungsstapel ab.

Neg

Negiert einen Wert und legt das Ergebnis auf dem Auswertungsstapel ab.

Newarr

Legt einen Objektverweis auf ein neues nullbasiertes, eindimensionales Array auf dem Auswertungsstapel ab, dessen Elemente einen bestimmten Typ aufweisen.

Newobj

Erstellt ein neues Objekt oder eine neue Instanz eines Werttyps, wobei ein Objektverweis (Typ O) auf dem Auswertungsstapel abgelegt wird.

Nop

Füllt Speicherplatz auf, wenn Opcodes gepatcht werden. Es wird keine sinnvolle Operation ausgeführt, obwohl ein Verarbeitungszyklus ausgeführt werden kann.

Not

Berechnet das bitweise Komplement des Ganzzahlwerts an oberster Position des Stapels und legt das Ergebnis als denselben Typ auf dem Auswertungsstapel ab.

Or

Berechnet das bitweise Komplement der beiden Ganzzahlwerte an oberster Position des Stapels und legt das Ergebnis auf dem Auswertungsstapel ab.

Pop

Entfernt den Wert, der sich derzeit an oberster Position des Auswertungsstapels befindet.

Prefix1

Dies ist eine reservierte Anweisung.

Prefix2

Dies ist eine reservierte Anweisung.

Prefix3

Dies ist eine reservierte Anweisung.

Prefix4

Dies ist eine reservierte Anweisung.

Prefix5

Dies ist eine reservierte Anweisung.

Prefix6

Dies ist eine reservierte Anweisung.

Prefix7

Dies ist eine reservierte Anweisung.

Prefixref

Dies ist eine reservierte Anweisung.

Readonly

Gibt an, dass beim nachfolgenden Vorgang zur Arrayadresse zur Laufzeit keine Typüberprüfung durchgeführt wird und dass ein verwalteter Zeiger zurückgegeben wird, der nur bedingt geändert werden kann.

Refanytype

Ruft das Typtoken ab, das in einen typisierten Verweis eingebettet ist.

Refanyval

Ruft die Adresse (Typ &) ab, die in einen typisierten Verweis eingebettet ist.

Rem

Dividiert zwei Werte und legt den Rest auf dem Auswertungsstapel ab.

Rem_Un

Dividiert zwei Werte ohne Vorzeichen und legt den Rest auf dem Auswertungsstapel ab.

Ret

Wird von der aktuellen Methode zurückgegeben und legt einen Rückgabewert (sofern vorhanden) vom Auswertungsstapel des Aufgerufenen auf dem Auswertungsstapel des Aufrufenden ab.

Rethrow

Löst erneut die aktuelle Ausnahme aus.

Shl

Verschiebt einen ganzzahligen Wert um eine angegebene Anzahl von Bits nach links, wobei die frei werdenden Stellen mit 0-Bits aufgefüllt werden, und legt das Ergebnis auf den Auswertungsstapel.

Shr

Verschiebt einen ganzzahligen Wert um eine angegebene Anzahl von Bits nach rechts, wobei das Vorzeichen mitgeführt wird, und legt das Ergebnis auf den Auswertungsstapel.

Shr_Un

Verschiebt einen ganzzahligen Wert ohne Vorzeichen um eine angegebene Anzahl von Bits nach rechts, wobei die frei werdenden Stellen mit 0-Bits aufgefüllt werden, und legt das Ergebnis auf den Auswertungsstapel.

Sizeof

Legt die Größe eines bereitgestellten Werttyps in Bytes auf dem Auswertungsstapel ab.

Starg

Speichert den an der obersten Position des Auswertungsstapels befindlichen Wert im Argumentslot an einem angegebenen Index.

Starg_S

Speichert den an der obersten Position des Auswertungsstapels befindlichen Wert im Argumentslot an einem angegebenen Index, Kurzform.

Stelem

Ersetzt das Arrayelement am angegebenen Index durch den Wert im Auswertungsstapel, dessen Typ in der Anweisung angegeben ist.

Stelem_I

Ersetzt das Arrayelement am angegebenen Index durch den native int-Wert im Auswertungsstapel.

Stelem_I1

Ersetzt das Arrayelement am angegebenen Index durch den int8-Wert im Auswertungsstapel.

Stelem_I2

Ersetzt das Arrayelement am angegebenen Index durch den int16-Wert im Auswertungsstapel.

Stelem_I4

Ersetzt das Arrayelement am angegebenen Index durch den int32-Wert im Auswertungsstapel.

Stelem_I8

Ersetzt das Arrayelement am angegebenen Index durch den int64-Wert im Auswertungsstapel.

Stelem_R4

Ersetzt das Arrayelement am angegebenen Index durch den float32-Wert im Auswertungsstapel.

Stelem_R8

Ersetzt das Arrayelement am angegebenen Index durch den float64-Wert im Auswertungsstapel.

Stelem_Ref

Ersetzt das Arrayelement am angegebenen Index durch den Wert des Objektverweises (Typ O) im Auswertungsstapel.

Stfld

Ersetzt den im Feld eines Objektsverweises oder Zeigers gespeicherten Wert durch einen neuen Wert.

Stind_I

Speichert einen Wert vom Typ native int an einer angegebenen Adresse.

Stind_I1

Speichert einen Wert vom Typ int8 an einer angegebenen Adresse.

Stind_I2

Speichert einen Wert vom Typ int16 an einer angegebenen Adresse.

Stind_I4

Speichert einen Wert vom Typ int32 an einer angegebenen Adresse.

Stind_I8

Speichert einen Wert vom Typ int64 an einer angegebenen Adresse.

Stind_R4

Speichert einen Wert vom Typ float32 an einer angegebenen Adresse.

Stind_R8

Speichert einen Wert vom Typ float64 an einer angegebenen Adresse.

Stind_Ref

Speichert einen Objektverweiswert an einer angegebenen Adresse.

Stloc

Pops the current value from the top of the evaluation stack and stores it in the local variable list at a specified index.

Stloc_0

Pops the current value from the top of the evaluation stack and stores it in the local variable list at index 0.

Stloc_1

Pops the current value from the top of the evaluation stack and stores it in the local variable list at index 1.

Stloc_2

Pops the current value from the top of the evaluation stack and stores it in the local variable list at index 2.

Stloc_3

Pops the current value from the top of the evaluation stack and stores it in the local variable list at index 3.

Stloc_S

Pops the current value from the top of the evaluation stack and stores it in the local variable list at index (short form).

Stobj

Kopiert einen Wert mit dem angegebenen Typ vom Auswertungsstapel in die angegebene Speicheradresse.

Stsfld

Ersetzt den Wert eines statischen Felds durch einen Wert vom Auswertungsstapel.

Sub

Subtrahiert einen Wert von einem anderen Wert und legt das Ergebnis auf dem Auswertungsstapel ab.

Sub_Ovf

Subtrahiert einen Ganzzahlwert von einem anderen Ganzzahlwert, führt eine Überlaufprüfung durch und legt das Ergebnis auf dem Auswertungsstapel ab.

Sub_Ovf_Un

Subtrahiert einen Ganzzahlwert ohne Vorzeichen von einem anderen Ganzzahlwert, führt eine Überlaufprüfung durch und legt das Ergebnis auf dem Auswertungsstapel ab.

Switch

Implementiert eine Sprungtabelle.

Tailcall

Führt eine Postfix-Methodenaufrufanweisung in der Weise aus, dass der Stapelrahmen der aktuellen Methode vor der Ausführung der eigentlichen Aufrufanweisung entfernt wird.

Throw

Löst das Ausnahmeobjekt aus, das sich momentan auf dem Auswertungsstapel befindet.

Unaligned

Gibt an, dass eine Adresse, die sich momentan oben auf dem Stapel befindet, möglicherweise nicht an der eigentlichen Größe der unmittelbar darauf folgenden ldind-Anweisung, stind-Anweisung, ldfld-Anweisung, stfld-Anweisung, ldobj-Anweisung, stobj-Anweisung, initblk-Anweisung oder cpblk-Anweisung ausgerichtet ist.

Unbox

Konvertiert die Darstellung eines mittels Boxing gepackten Werttyps in seine mittels Unboxing entpackte Entsprechung.

Unbox_Any

Konvertiert die geschachtelte Darstellung eines n der Anweisung angegebenen Typs in seine nicht geschachtelte Form.

Volatile

Gibt an, dass es sich bei einer Adresse, die sich momentan oben auf dem Auswertungsstapel befindet, möglicherweise um eine flüchtige Adresse handelt und daher die aus diesem Speicherort gelesenen Ergebnisse nicht zwischengespeichert werden können oder mehrere für diesen Speicherort ausgeführte Speichervorgänge nicht unterdrückt werden können.

Xor

Berechnet das bitweise XOR der beidem auf dem Stapel an oberster Position befindlichen Werte und legt das Ergebnis auf dem Auswertungsstapel ab.

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
TakesSingleByteArgument(OpCode)

Gibt TRUE oder FALSE zurück, wenn der bereitgestellte Opcode ein Einzelbyte-Argument akzeptiert.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Gilt für: