OpCodes Klasse

Definition

Namespace:: System.Reflection.Emit

Assemblys:: mscorlib.dll, System.Reflection.Primitives.dll

Assemblys:: netstandard.dll, System.Reflection.Primitives.dll

Assembly:: System.Reflection.Primitives.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Quelle:: OpCodes.cs

Quelle:: OpCodes.cs

Quelle:: OpCodes.cs

Quelle:: OpCodes.cs

Quelle:: OpCodes.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt Felddarstellungen der Microsoft Intermediate Language (MSIL)-Anweisungen für die Emission durch die ILGenerator Klassenmber (z. B. Emit(OpCode)) bereit.

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: Object
OpCodes

Attribute: ComVisibleAttribute

Beispiele

Das folgende Beispiel veranschaulicht die Konstruktion einer dynamischen Methode, die ILGenerator verwendet wird, um OpCodes in eine MethodBuilder.


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 Instruction Set" und "Partition II: Metadata Definition and Semantics". Weitere Informationen finden Sie unter ECMA 335 Common Language Infrastructure (CLI).

Felder

Name	Beschreibung
Add	Fügt zwei Werte hinzu und verschiebt das Ergebnis auf den Auswertungsstapel.
Add_Ovf	Fügt zwei ganze Zahlen hinzu, führt eine Überlaufüberprüfung durch und verschiebt das Ergebnis auf den Auswertungsstapel.
Add_Ovf_Un	Fügt zwei ganzzahlige Werte ohne Vorzeichen hinzu, führt eine Überlaufüberprüfung durch und verschiebt das Ergebnis auf den Auswertungsstapel.
And	Berechnet das bitweise UND von zwei Werten und verschiebt das Ergebnis auf den Auswertungsstapel.
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 gleich sind.
Beq_S	Überträgt die Steuerung an eine Zielanweisung (kurze Form), wenn zwei Werte gleich sind.
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 (kurze Form), wenn der erste Wert größer oder gleich dem zweiten Wert ist.
Bge_Un	Überträgt die Steuerung an eine Zielanweisung, wenn der erste Wert größer als der zweite Wert ist, wenn nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte verglichen werden.
Bge_Un_S	Überträgt die Steuerung an eine Zielanweisung (kurze Form), wenn der erste Wert größer als der zweite Wert ist, wenn nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte verglichen werden.
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 (kurze Form), wenn der erste Wert größer als der zweite Wert ist.
Bgt_Un	Überträgt die Steuerung an eine Zielanweisung, wenn der erste Wert größer als der zweite Wert ist, wenn nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte verglichen werden.
Bgt_Un_S	Überträgt die Steuerung an eine Zielanweisung (kurze Form), wenn der erste Wert größer als der zweite Wert ist, wenn nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte verglichen werden.
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 (kurze Form), wenn der erste Wert kleiner oder gleich dem zweiten Wert ist.
Ble_Un	Überträgt die Steuerung an eine Zielanweisung, wenn der erste Wert kleiner oder gleich dem zweiten Wert ist, wenn nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte verglichen werden.
Ble_Un_S	Überträgt die Steuerung an eine Zielanweisung (kurze Form), wenn der erste Wert kleiner oder gleich dem zweiten Wert ist, wenn nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte verglichen werden.
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 (kurze Form), wenn der erste Wert kleiner als der zweite Wert ist.
Blt_Un	Überträgt die Steuerung an eine Zielanweisung, wenn der erste Wert kleiner als der zweite Wert ist, wenn nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte verglichen werden.
Blt_Un_S	Überträgt die Steuerung an eine Zielanweisung (kurze Form), wenn der erste Wert kleiner als der zweite Wert ist, wenn nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte verglichen werden.
Bne_Un	Überträgt die Steuerung an eine Zielanweisung, wenn zwei nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte nicht gleich sind.
Bne_Un_S	Überträgt die Steuerung an eine Zielanweisung (kurzes Formular), wenn zwei nicht signierte ganzzahlige Werte oder ungeordnete Float-Werte nicht gleich sind.
Box	Konvertiert einen Werttyp in einen Objektverweis (Typ `O`).
Br	Überträgt die Kontrolle bedingungslos an eine Zielanweisung.
Br_S	Die Kontrolle wird bedingungslos an eine Zielanweisung (kurze Form) übertragen.
Break	Signalisiert die Common Language Infrastructure (CLI), um den Debugger darüber zu informieren, dass ein Haltepunkt übersprungen wurde.
Brfalse	Überträgt die Steuerung an eine Zielanweisung, wenn `valuefalse`, einen Nullverweis (`Nothing` in Visual Basic) oder Null ist.
Brfalse_S	Überträgt die Steuerung an eine Zielanweisung, wenn es sich um `value` einen Nullverweis oder null handelt `false`.
Brtrue	Überträgt die Steuerung an eine Zielanweisung, wenn `value` es sich nicht um null oder nicht um Null handelt `true`.
Brtrue_S	Überträgt die Steuerung an eine Zielanweisung (kurze Form), wenn `value` es sich nicht um NULL oder nicht um Null handelt `true`.
Call	Ruft die vom übergebenen Methodendeskriptor angegebene Methode auf.
Calli	Ruft die im Auswertungsstapel angegebene Methode (als Zeiger auf einen Einstiegspunkt) mit Argumenten auf, die durch eine Aufrufkonvention beschrieben werden.
Callvirt	Ruft eine spät gebundene Methode für ein Objekt auf, wobei der Rückgabewert auf den Auswertungsstapel verschoben wird.
Castclass	Versucht, ein Objekt zu umwandeln, das durch Verweis auf die angegebene Klasse übergeben wird.
Ceq	Vergleicht zwei Werte. Wenn sie gleich sind, wird der ganzzahlige Wert 1 `(int32`) auf den Auswertungsstapel verschoben. andernfalls wird 0 (`int32`) auf den Auswertungsstapel verschoben.
Cgt	Vergleicht zwei Werte. Wenn der erste Wert größer als der zweite ist, wird der ganzzahlige Wert 1 `(int32`) auf den Auswertungsstapel verschoben. andernfalls wird 0 (`int32`) auf den Auswertungsstapel verschoben.
Cgt_Un	Vergleicht zwei nicht signierte oder ungeordnete Werte. Wenn der erste Wert größer als der zweite ist, wird der ganzzahlige Wert 1 `(int32`) auf den Auswertungsstapel verschoben. andernfalls wird 0 (`int32`) auf den Auswertungsstapel verschoben.
Ckfinite	Löst aus ArithmeticException , wenn der Wert keine endliche Zahl ist.
Clt	Vergleicht zwei Werte. Wenn der erste Wert kleiner als der zweite ist, wird der ganzzahlige Wert 1 `(int32`) auf den Auswertungsstapel verschoben. andernfalls wird 0 (`int32`) auf den Auswertungsstapel verschoben.
Clt_Un	Vergleicht die nicht signierten oder ungeordneten Werte `value1` und `value2`. Ist `value1` dieser Wert kleiner als `value2`, wird der ganzzahlige Wert 1 `(int32`) auf den Auswertungsstapel verschoben. Andernfalls wird 0 (`int32`) auf den Auswertungsstapel verschoben.
Constrained	Beschränkt den Typ, für den ein virtueller Methodenaufruf ausgeführt wird.
Conv_I	Konvertiert den Wert über dem Auswertungsstapel in `native int`.
Conv_I1	Wandelt den Wert über dem Auswertungsstapel in `int8`und erweitert ihn dann (Pads) in `int32`.
Conv_I2	Wandelt den Wert über dem Auswertungsstapel in `int16`und erweitert ihn dann (Pads) in `int32`.
Conv_I4	Konvertiert den Wert über dem Auswertungsstapel in `int32`.
Conv_I8	Konvertiert den Wert über dem Auswertungsstapel in `int64`.
Conv_Ovf_I	Wandelt den signierten Wert über dem Auswertungsstapel in signiert `native int`um, wobei der Überlauf ausgelöst wird OverflowException .
Conv_Ovf_I_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in einen signierten `native int`Wert um, der beim Überlauf ausgelöst wird OverflowException .
Conv_Ovf_I1	Wandelt den signierten Wert über dem Auswertungsstapel in signiert `int8` um und erweitert ihn auf `int32`den Überlauf.OverflowException
Conv_Ovf_I1_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in signiert `int8` um und erweitert ihn auf `int32`den Überlauf OverflowException .
Conv_Ovf_I2	Wandelt den signierten Wert über dem Auswertungsstapel in signierte `int16` und erweiternde Wert in `int32`einen Überlauf OverflowException .
Conv_Ovf_I2_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in signiert `int16` um und erweitert ihn auf `int32`den Überlauf OverflowException .
Conv_Ovf_I4	Wandelt den signierten Wert über dem Auswertungsstapel in signiert `int32`um, wobei der Überlauf ausgelöst wird OverflowException .
Conv_Ovf_I4_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in einen signierten `int32`Wert um, der beim Überlauf ausgelöst wird OverflowException .
Conv_Ovf_I8	Wandelt den signierten Wert über dem Auswertungsstapel in signiert `int64`um, wobei der Überlauf ausgelöst wird OverflowException .
Conv_Ovf_I8_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in einen signierten `int64`Wert um, der beim Überlauf ausgelöst wird OverflowException .
Conv_Ovf_U	Wandelt den signierten Wert über dem Auswertungsstapel in "`unsigned native int`Überlauf" umOverflowException.
Conv_Ovf_U_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in `unsigned native int`" OverflowException Überlauf" um.
Conv_Ovf_U1	Wandelt den signierten Wert über dem Auswertungsstapel in `unsigned int8` den Überlauf um und erweitert ihn in `int32`den Überlauf OverflowException .
Conv_Ovf_U1_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in `unsigned int8` und erweitert ihn in `int32`den Überlauf, der beim Überlauf ausgelöst wird OverflowException .
Conv_Ovf_U2	Wandelt den signierten Wert über dem Auswertungsstapel in `unsigned int16` den Überlauf um und erweitert ihn in `int32`den Überlauf OverflowException .
Conv_Ovf_U2_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in `unsigned int16` und erweitert ihn in `int32`den Überlauf, der beim Überlauf ausgelöst wird OverflowException .
Conv_Ovf_U4	Wandelt den signierten Wert über dem Auswertungsstapel in "`unsigned int32`Überlauf" umOverflowException.
Conv_Ovf_U4_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in `unsigned int32`" OverflowException Überlauf" um.
Conv_Ovf_U8	Wandelt den signierten Wert über dem Auswertungsstapel in "`unsigned int64`Überlauf" umOverflowException.
Conv_Ovf_U8_Un	Wandelt den nicht signierten Wert über dem Auswertungsstapel in `unsigned int64`" OverflowException Überlauf" um.
Conv_R_Un	Konvertiert den Ganzzahlwert ohne Vorzeichen oben im Auswertungsstapel in `float32`.
Conv_R4	Konvertiert den Wert über dem Auswertungsstapel in `float32`.
Conv_R8	Konvertiert den Wert über dem Auswertungsstapel in `float64`.
Conv_U	Konvertiert den Wert über dem Auswertungsstapel in `unsigned native int`, und erweitert ihn auf `native int`.
Conv_U1	Konvertiert den Wert über dem Auswertungsstapel in `unsigned int8`, und erweitert ihn auf `int32`.
Conv_U2	Konvertiert den Wert über dem Auswertungsstapel in `unsigned int16`, und erweitert ihn auf `int32`.
Conv_U4	Konvertiert den Wert über dem Auswertungsstapel in `unsigned int32`, und erweitert ihn auf `int32`.
Conv_U8	Konvertiert den Wert über dem Auswertungsstapel in `unsigned int64`, und erweitert ihn auf `int64`.
Cpblk	Kopiert eine angegebene Anzahl bytes von einer Quelladresse an eine Zieladresse.
Cpobj	Kopiert den Werttyp an der Adresse eines Objekts (Typ `&`oder ) an die Adresse des Zielobjekts (Typ oder `native int&``).native int`
Div	Dividiert zwei Werte und verschiebt das Ergebnis als Gleitkomma (Typ `F`) oder Quotient (Typ `int32`) auf den Auswertungsstapel.
Div_Un	Dividiert zwei ganzzahlige Werte ohne Vorzeichen und verschiebt das Ergebnis (`int32`) auf den Auswertungsstapel.
Dup	Kopiert den aktuellen obersten Wert im Auswertungsstapel und verschiebt dann die Kopie auf den Auswertungsstapel.
Endfilter	Überträgt die Steuerung aus der `filter` Klausel einer Ausnahme zurück an den CLI-Ausnahmehandler (Common Language Infrastructure).
Endfinally	Überträgt die Steuerung von der Ausnahme `fault` oder Klausel `finally` eines Ausnahmeblocks zurück an den CLI-Ausnahmehandler (Common Language Infrastructure).
Initblk	Initialisiert einen angegebenen Speicherblock an einer bestimmten Adresse auf eine bestimmte Größe und einen bestimmten Anfangswert.
Initobj	Initialisiert jedes Feld des Werttyps bei einer angegebenen Adresse auf einen Nullverweis oder einen 0 des entsprechenden Grundtyps.
Isinst	Überprüft, ob ein Objektverweis (Typ `O`) eine Instanz einer bestimmten Klasse ist.
Jmp	Beendet die aktuelle Methode und springt zu der angegebenen Methode.
Ldarg	Lädt ein Argument (auf das durch einen angegebenen Indexwert verwiesen wird) in den Stapel.
Ldarg_0	Lädt das Argument bei Index 0 in den Auswertungsstapel.
Ldarg_1	Lädt das Argument bei Index 1 in den Auswertungsstapel.
Ldarg_2	Lädt das Argument bei Index 2 in den Auswertungsstapel.
Ldarg_3	Lädt das Argument bei Index 3 in den Auswertungsstapel.
Ldarg_S	Lädt das Argument (auf das durch einen angegebenen Kurzformularindex verwiesen wird) in den Auswertungsstapel.
Ldarga	Laden Sie eine Argumentadresse in den Auswertungsstapel.
Ldarga_S	Laden Sie eine Argumentadresse in kurzer Form in den Auswertungsstapel.
Ldc_I4	Verschiebt einen angegebenen Wert vom Typ `int32` in den Auswertungsstapel als .`int32`
Ldc_I4_0	Verschiebt den ganzzahligen Wert von 0 in den Auswertungsstapel als .`int32`
Ldc_I4_1	Verschiebt den ganzzahligen Wert 1 auf den Auswertungsstapel als .`int32`
Ldc_I4_2	Verschiebt den ganzzahligen Wert 2 auf den Auswertungsstapel als .`int32`
Ldc_I4_3	Verschiebt den ganzzahligen Wert 3 auf den Auswertungsstapel als .`int32`
Ldc_I4_4	Verschiebt den ganzzahligen Wert von 4 auf den Auswertungsstapel als ein `int32`.
Ldc_I4_5	Verschiebt den ganzzahligen Wert von 5 auf den Auswertungsstapel als .`int32`
Ldc_I4_6	Verschiebt den ganzzahligen Wert von 6 auf den Auswertungsstapel als ein `int32`.
Ldc_I4_7	Verschiebt den ganzzahligen Wert von 7 auf den Auswertungsstapel als ein `int32`.
Ldc_I4_8	Verschiebt den ganzzahligen Wert von 8 auf den Auswertungsstapel als .`int32`
Ldc_I4_M1	Verschiebt den ganzzahligen Wert von -1 in den Auswertungsstapel als .`int32`
Ldc_I4_S	Verschiebt den angegebenen `int8` Wert als `int32`kurzes Formular auf den Auswertungsstapel.
Ldc_I8	Verschiebt einen angegebenen Wert vom Typ `int64` in den Auswertungsstapel als .`int64`
Ldc_R4	Verschiebt einen angegebenen Wert vom Typ `float32` als Typ `F` (Float) auf den Auswertungsstapel.
Ldc_R8	Verschiebt einen angegebenen Wert vom Typ `float64` als Typ `F` (Float) auf den Auswertungsstapel.
Ldelem	Lädt das Element in einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels, wie der in der Anweisung angegebene Typ.
Ldelem_I	Lädt das Element mit Typ `native int` bei einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels als ein `native int`.
Ldelem_I1	Lädt das Element mit Typ `int8` bei einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels als .`int32`
Ldelem_I2	Lädt das Element mit Typ `int16` bei einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels als .`int32`
Ldelem_I4	Lädt das Element mit Typ `int32` bei einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels als .`int32`
Ldelem_I8	Lädt das Element mit Typ `int64` bei einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels als .`int64`
Ldelem_R4	Lädt das Element mit Typ `float32` bei einem angegebenen Arrayindex am Anfang des Auswertungsstapels als Typ `F` (float).
Ldelem_R8	Lädt das Element mit Typ `float64` bei einem angegebenen Arrayindex am Anfang des Auswertungsstapels als Typ `F` (float).
Ldelem_Ref	Lädt das Element, das einen Objektverweis an einem angegebenen Arrayindex enthält, auf den Oberen des Auswertungsstapels als Typ `O` (Objektverweis).
Ldelem_U1	Lädt das Element mit Typ `unsigned int8` bei einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels als .`int32`
Ldelem_U2	Lädt das Element mit Typ `unsigned int16` bei einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels als .`int32`
Ldelem_U4	Lädt das Element mit Typ `unsigned int32` bei einem angegebenen Arrayindex auf den oberen Rand des Auswertungsstapels als .`int32`
Ldelema	Lädt die Adresse des Arrayelements in einem angegebenen Arrayindex am Anfang des Auswertungsstapels als Typ `&` (verwalteter Zeiger).
Ldfld	Sucht den Wert eines Felds im Objekt, dessen Verweis sich derzeit im Auswertungsstapel befindet.
Ldflda	Sucht die Adresse eines Felds im Objekt, dessen Verweis sich derzeit im Auswertungsstapel befindet.
Ldftn	Verschiebt einen nicht verwalteten Zeiger (Typ `native int`) an den systemeigenen Code, der eine bestimmte Methode auf den Auswertungsstapel implementiert.
Ldind_I	Lädt einen Wert vom Typ `native int` als `native int` einen indirekten Auswertungsstapel auf den Auswertungsstapel.
Ldind_I1	Lädt einen Wert vom Typ `int8` als `int32` einen indirekten Auswertungsstapel auf den Auswertungsstapel.
Ldind_I2	Lädt einen Wert vom Typ `int16` als `int32` einen indirekten Auswertungsstapel auf den Auswertungsstapel.
Ldind_I4	Lädt einen Wert vom Typ `int32` als `int32` einen indirekten Auswertungsstapel auf den Auswertungsstapel.
Ldind_I8	Lädt einen Wert vom Typ `int64` als `int64` einen indirekten Auswertungsstapel auf den Auswertungsstapel.
Ldind_R4	Lädt einen Wert vom Typ `float32` als Typ `F` (Float) indirekt in den Auswertungsstapel.
Ldind_R8	Lädt einen Wert vom Typ `float64` als Typ `F` (Float) indirekt in den Auswertungsstapel.
Ldind_Ref	Lädt einen Objektverweis als Typ `O` (Objektverweis) indirekt in den Auswertungsstapel.
Ldind_U1	Lädt einen Wert vom Typ `unsigned int8` als `int32` einen indirekten Auswertungsstapel auf den Auswertungsstapel.
Ldind_U2	Lädt einen Wert vom Typ `unsigned int16` als `int32` einen indirekten Auswertungsstapel auf den Auswertungsstapel.
Ldind_U4	Lädt einen Wert vom Typ `unsigned int32` als `int32` einen indirekten Auswertungsstapel auf den Auswertungsstapel.
Ldlen	Verschiebt die Anzahl der Elemente eines nullbasierten eindimensionalen Arrays auf den Auswertungsstapel.
Ldloc	Lädt die lokale Variable an einem bestimmten Index in den Auswertungsstapel.
Ldloc_0	Lädt die lokale Variable bei Index 0 in den Auswertungsstapel.
Ldloc_1	Lädt die lokale Variable bei Index 1 in den Auswertungsstapel.
Ldloc_2	Lädt die lokale Variable bei Index 2 in den Auswertungsstapel.
Ldloc_3	Lädt die lokale Variable bei Index 3 in den Auswertungsstapel.
Ldloc_S	Lädt die lokale Variable in einem bestimmten Index in den Auswertungsstapel, kurzform.
Ldloca	Lädt die Adresse der lokalen Variablen in einem bestimmten Index in den Auswertungsstapel.
Ldloca_S	Lädt die Adresse der lokalen Variablen bei einem bestimmten Index in den Auswertungsstapel, kurzform.
Ldnull	Verschiebt einen Nullverweis (Typ `O`) auf den Auswertungsstapel.
Ldobj	Kopiert das Werttypobjekt, auf das von einer Adresse oben im Auswertungsstapel verwiesen wird.
Ldsfld	Verschiebt den Wert eines statischen Felds auf den Auswertungsstapel.
Ldsflda	Verschiebt die Adresse eines statischen Felds auf den Auswertungsstapel.
Ldstr	Verschiebt einen neuen Objektverweis auf ein in den Metadaten gespeichertes Zeichenfolgenliteral.
Ldtoken	Wandelt ein Metadatentoken in seine Laufzeitdarstellung um und überträgt es auf den Auswertungsstapel.
Ldvirtftn	Verschiebt einen nicht verwalteten Zeiger (Typ `native int`) an den systemeigenen Code, der eine bestimmte virtuelle Methode implementiert, die einem angegebenen Objekt zugeordnet ist, auf den Auswertungsstapel.
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 Zielanweisung (kurze Form) übertragen wird.
Localloc	Weist eine bestimmte Anzahl von Bytes aus dem lokalen dynamischen Speicherpool zu und verschiebt die Adresse (einen vorübergehenden Zeiger, Typ `*`) des ersten zugewiesenen Byte auf den Auswertungsstapel.
Mkrefany	Verschiebt einen typierten Verweis auf eine Instanz eines bestimmten Typs auf den Auswertungsstapel.
Mul	Multipliziert zwei Werte und verschiebt das Ergebnis im Auswertungsstapel.
Mul_Ovf	Multipliziert zwei ganzzahlige Werte, führt eine Überlaufüberprüfung durch und verschiebt das Ergebnis auf den Auswertungsstapel.
Mul_Ovf_Un	Multipliziert zwei ganzzahlige Werte ohne Vorzeichen, führt eine Überlaufüberprüfung durch und verschiebt das Ergebnis auf den Auswertungsstapel.
Neg	Hebt einen Wert ab und verschiebt das Ergebnis auf den Auswertungsstapel.
Newarr	Verschiebt einen Objektverweis auf ein neues nullbasiertes eindimensionales Array, dessen Elemente einen bestimmten Typ aufweisen, auf den Auswertungsstapel.
Newobj	Erstellt ein neues Objekt oder eine neue Instanz eines Werttyps, wobei ein Objektverweis (Typ `O`) auf den Auswertungsstapel verschoben wird.
Nop	Füllt Platz, wenn Opcodes gepatcht werden. Es wird kein sinnvoller Vorgang ausgeführt, obwohl ein Verarbeitungszyklus verbraucht werden kann.
Not	Berechnet die bitweise Ergänzung des ganzzahligen Werts über dem Stapel und verschiebt das Ergebnis auf den Auswertungsstapel wie denselben Typ.
Or	Berechnen Sie die bitweise Ergänzung der beiden ganzzahligen Werte über dem Stapel und verschiebt das Ergebnis auf den Auswertungsstapel.
Pop	Entfernt den Wert, der sich derzeit im Auswertungsstapel 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 der nachfolgende Arrayadressenvorgang zur Laufzeit keine Typüberprüfung durchführt und einen verwalteten Zeiger zurückgibt, dessen Veränderbarkeit eingeschränkt ist.
Refanytype	Ruft das Typtoken ab, das in einen typierten Verweis eingebettet ist.
Refanyval	Ruft die Adresse (Typ `&`) ab, die in einen typierten Verweis eingebettet ist.
Rem	Dividiert zwei Werte und verschiebt den Rest auf den Auswertungsstapel.
Rem_Un	Dividiert zwei nicht signierte Werte und verschiebt den Rest auf den Auswertungsstapel.
Ret	Gibt aus der aktuellen Methode zurück, wobei ein Rückgabewert (sofern vorhanden) aus dem Auswertungsstapel des Angerufenen auf den Auswertungsstapel des Aufrufers verschoben wird.
Rethrow	Beschreibt die aktuelle Ausnahme.
Shl	Verschiebt einen ganzzahligen Wert nach links (in Nullen) um eine angegebene Anzahl von Bits, wodurch das Ergebnis auf den Auswertungsstapel verschoben wird.
Shr	Verschiebt einen ganzzahligen Wert (im Vorzeichen) um eine angegebene Anzahl von Bits nach rechts, wodurch das Ergebnis auf den Auswertungsstapel verschoben wird.
Shr_Un	Verschiebt einen nicht signierten ganzzahligen Wert (in Nullen) um eine angegebene Anzahl von Bits nach rechts, wodurch das Ergebnis auf den Auswertungsstapel verschoben wird.
Sizeof	Verschiebt die Größe eines angegebenen Werttyps in Bytes auf den Auswertungsstapel.
Starg	Speichert den Wert über dem Auswertungsstapel im Argumentplatz an einem angegebenen Index.
Starg_S	Speichert den Wert über dem Auswertungsstapel im Argumentplatz an einem angegebenen Index, kurzform.
Stelem	Ersetzt das Arrayelement in einem bestimmten Index durch den Wert im Auswertungsstapel, dessen Typ in der Anweisung angegeben ist.
Stelem_I	Ersetzt das Arrayelement in einem bestimmten Index durch den `native int` Wert im Auswertungsstapel.
Stelem_I1	Ersetzt das Arrayelement in einem bestimmten Index durch den `int8` Wert im Auswertungsstapel.
Stelem_I2	Ersetzt das Arrayelement in einem bestimmten Index durch den `int16` Wert im Auswertungsstapel.
Stelem_I4	Ersetzt das Arrayelement in einem bestimmten Index durch den `int32` Wert im Auswertungsstapel.
Stelem_I8	Ersetzt das Arrayelement in einem bestimmten Index durch den `int64` Wert im Auswertungsstapel.
Stelem_R4	Ersetzt das Arrayelement in einem bestimmten Index durch den `float32` Wert im Auswertungsstapel.
Stelem_R8	Ersetzt das Arrayelement in einem bestimmten Index durch den `float64` Wert im Auswertungsstapel.
Stelem_Ref	Ersetzt das Arrayelement in einem bestimmten Index durch den Objekt ref-Wert (Typ `O`) im Auswertungsstapel.
Stfld	Ersetzt den im Feld eines Objektbezugs 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 eines angegebenen Typs aus dem Auswertungsstapel in eine angegebene Speicheradresse.
Stsfld	Ersetzt den Wert eines statischen Felds durch einen Wert aus dem Auswertungsstapel.
Sub	Subtrahiert einen Wert von einem anderen und verschiebt das Ergebnis auf den Auswertungsstapel.
Sub_Ovf	Subtrahiert einen ganzzahligen Wert von einem anderen, führt eine Überlaufüberprüfung durch und verschiebt das Ergebnis auf den Auswertungsstapel.
Sub_Ovf_Un	Subtrahiert einen ganzzahligen Wert ohne Vorzeichen von einem anderen, führt eine Überlaufüberprüfung durch und verschiebt das Ergebnis auf den Auswertungsstapel.
Switch	Implementiert eine Sprungtabelle.
Tailcall	Führt eine Postfixed-Methodenaufrufanweisung aus, sodass der Stapelframe der aktuellen Methode entfernt wird, bevor die tatsächliche Aufrufanweisung ausgeführt wird.
Throw	Löst das Ausnahmeobjekt aus, das sich derzeit im Auswertungsstapel befindet.
Unaligned	Gibt an, dass eine Adresse auf dem Auswertungsstapel möglicherweise nicht an der natürlichen Größe der unmittelbar folgenden , , , , , , `ldind`oder `stindldfld` Anweisung ausgerichtet ist. `stfldldobjstobjinitblkcpblk`
Unbox	Konvertiert die Boxdarstellung eines Werttyps in das unboxierte Formular.
Unbox_Any	Konvertiert die boxierte Darstellung eines Typs, der in der Anweisung angegeben ist, in das unboxierte Formular.
Volatile	Gibt an, dass eine Adresse, die derzeit auf dem Auswertungsstapel steht, veränderlich ist und die Ergebnisse des Lesens dieses Speicherorts nicht zwischengespeichert werden können oder dass mehrere Speicher an diesem Speicherort nicht unterdrückt werden können.
Xor	Berechnet den bitweisen XOR der beiden obersten Werte im Auswertungsstapel, wodurch das Ergebnis auf den Auswertungsstapel verschoben wird.

Methoden

Name	Beschreibung
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
TakesSingleByteArgument(OpCode)	Gibt true oder false zurück, wenn der angegebene Opcode ein einzelnes Byte-Argument akzeptiert.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Gilt für:

Feedback

War diese Seite hilfreich?