OpCodes Klasse
Definition
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 MSIL (Microsoft Intermediate Language)-Anweisungen für die Ausgabe durch die ILGenerator-Klassenmember bereit, beispielsweise Emit(OpCode).
public ref class OpCodespublic class OpCodes[System.Runtime.InteropServices.ComVisible(true)]
public class OpCodestype OpCodes = class[<System.Runtime.InteropServices.ComVisible(true)>]
type OpCodes = classPublic Class OpCodes- Vererbung
-
OpCodes
- Attribute
Beispiele
Im folgenden Beispiel wird die Konstruktion einer dynamischen Methode veranschaulicht, die zum Ausgeben OpCodes in eine MethodBuilderverwendet wirdILGenerator.
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 ausführliche 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
| 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 |
| 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 |
| Brfalse_S |
Überträgt die Steuerung an eine Zielanweisung, wenn |
| Brtrue |
Überträgt die Steuerung an eine Zielanweisung, wenn |
| Brtrue_S |
Überträgt die Steuerung an eine Zielanweisung (Kurzform), wenn |
| 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 |
| Cgt |
Vergleicht zwei Werte. Wenn der erste Wert größer als der zweite Wert ist, wird der Ganzzahlwert 1 |
| 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 |
| 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 |
| Clt_Un |
Vergleicht die Werte ohne Vorzeichen oder die ungeordneten Werte |
| 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 |
| Conv_I1 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_I2 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_I4 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_I8 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I_Un |
Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I1 |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I1_Un |
Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I2 |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I2_Un |
Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I4 |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I4_Un |
Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I8 |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_I8_Un |
Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U_Un |
Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U1 |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U1_Un |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U2 |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U2_Un |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U4 |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U4_Un |
Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U8 |
Konvertiert den Wert mit Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_Ovf_U8_Un |
Konvertiert den Wert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_R_Un |
Konvertiert den Ganzzahlwert ohne Vorzeichen an oberster Position des Auswertungsstapels in |
| Conv_R4 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_R8 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_U |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_U1 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_U2 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_U4 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Conv_U8 |
Konvertiert den Wert an oberster Position des Auswertungsstapels in |
| Cpblk |
Kopiert eine angegebene Anzahl von Bytes von einer Quelladresse an eine Zieladresse. |
| Cpobj |
Kopiert den Werttyp an der Adresse eines Objekts (Typ
|
| Div |
Dividiert zwei Werte und legt das Ergebnis als Gleitkommawert (Typ |
| Div_Un |
Dividiert zwei Ganzzahlwerte ohne Vorzeichen und legt das Ergebnis ( |
| Dup |
Kopiert den obersten Wert auf dem Auswertungsstapel und legt die Kopie dann auf dem Auswertungsstapel ab. |
| Endfilter |
Überträgt die Steuerung von der |
| Endfinally |
Überträgt die Steuerung aus der |
| 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 |
| 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 |
| Ldc_I4_0 |
Legt den Ganzzahlwert 0 als |
| Ldc_I4_1 |
Legt den Ganzzahlwert 1 als |
| Ldc_I4_2 |
Legt den Ganzzahlwert 2 als |
| Ldc_I4_3 |
Legt den Ganzzahlwert 3 als |
| Ldc_I4_4 |
Legt den Ganzzahlwert 4 als |
| Ldc_I4_5 |
Legt den Ganzzahlwert 5 als |
| Ldc_I4_6 |
Legt den Ganzzahlwert 6 als |
| Ldc_I4_7 |
Legt den Ganzzahlwert 7 als |
| Ldc_I4_8 |
Legt den Ganzzahlwert 8 als |
| Ldc_I4_M1 |
Legt den Ganzzahlwert -1 als |
| Ldc_I4_S |
Legt den bereitgestellten |
| Ldc_I8 |
Legt einen bereitgestellten Wert vom Typ |
| Ldc_R4 |
Legt einen bereitgestellten Wert vom Typ |
| Ldc_R8 |
Legt einen bereitgestellten Wert vom Typ |
| 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 |
| Ldelem_I1 |
Lädt das Element mit dem Typ |
| Ldelem_I2 |
Lädt das Element mit dem Typ |
| Ldelem_I4 |
Lädt das Element mit dem Typ |
| Ldelem_I8 |
Lädt das Element mit dem Typ |
| Ldelem_R4 |
Lädt das Element vom Typ |
| Ldelem_R8 |
Lädt das Element vom Typ |
| Ldelem_Ref |
Lädt das Element mit Objektverweis an einem angegebenen Arrayindex als Typ |
| Ldelem_U1 |
Lädt das Element mit dem Typ |
| Ldelem_U2 |
Lädt das Element mit dem Typ |
| Ldelem_U4 |
Lädt das Element mit dem Typ |
| Ldelema |
Lädt die Adresse des Arrayelements an einem angegebenen Arrayindex als Typ |
| 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 |
| Ldind_I |
Lädt einen Wert vom Typ |
| Ldind_I1 |
Lädt einen Wert vom Typ |
| Ldind_I2 |
Lädt einen Wert vom Typ |
| Ldind_I4 |
Lädt einen Wert vom Typ |
| Ldind_I8 |
Lädt einen Wert vom Typ |
| Ldind_R4 |
Lädt einen Wert vom Typ |
| Ldind_R8 |
Lädt einen Wert vom Typ |
| Ldind_Ref |
Lädt einen Objektverweis indirekt als Typ |
| Ldind_U1 |
Lädt einen Wert vom Typ |
| Ldind_U2 |
Lädt einen Wert vom Typ |
| Ldind_U4 |
Lädt einen Wert vom Typ |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| Stelem_I1 |
Ersetzt das Arrayelement am angegebenen Index durch den |
| Stelem_I2 |
Ersetzt das Arrayelement am angegebenen Index durch den |
| Stelem_I4 |
Ersetzt das Arrayelement am angegebenen Index durch den |
| Stelem_I8 |
Ersetzt das Arrayelement am angegebenen Index durch den |
| Stelem_R4 |
Ersetzt das Arrayelement am angegebenen Index durch den |
| Stelem_R8 |
Ersetzt das Arrayelement am angegebenen Index durch den |
| Stelem_Ref |
Ersetzt das Arrayelement am angegebenen Index durch den Wert des Objektverweises (Typ |
| Stfld |
Ersetzt den im Feld eines Objektsverweises oder Zeigers gespeicherten Wert durch einen neuen Wert. |
| Stind_I |
Speichert einen Wert vom Typ |
| Stind_I1 |
Speichert einen Wert vom Typ |
| Stind_I2 |
Speichert einen Wert vom Typ |
| Stind_I4 |
Speichert einen Wert vom Typ |
| Stind_I8 |
Speichert einen Wert vom Typ |
| Stind_R4 |
Speichert einen Wert vom Typ |
| Stind_R8 |
Speichert einen Wert vom Typ |
| Stind_Ref |
Speichert einen Objektverweiswert an einer angegebenen Adresse. |
| Stloc |
Füllt den aktuellen Wert vom oberen Rand des Auswertungsstapels auf und speichert ihn in der Liste der lokalen Variablen an einem angegebenen Index. |
| Stloc_0 |
Füllt den aktuellen Wert vom oberen Rand des Auswertungsstapels auf und speichert ihn in der Liste der lokalen Variablen bei Index 0. |
| Stloc_1 |
Füllt den aktuellen Wert vom oberen Rand des Auswertungsstapels auf und speichert ihn in der Liste der lokalen Variablen bei Index 1. |
| Stloc_2 |
Füllt den aktuellen Wert vom oberen Rand des Auswertungsstapels auf und speichert ihn in der Liste der lokalen Variablen bei Index 2. |
| Stloc_3 |
Füllt den aktuellen Wert vom oberen Rand des Auswertungsstapels auf und speichert ihn in der Liste der lokalen Variablen bei Index 3. |
| Stloc_S |
Füllt den aktuellen Wert vom oberen Rand des Auswertungsstapels auf und speichert ihn in der Liste der lokalen Variablen unter |
| 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 |
| 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) |
