OpCodes Třída
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Poskytuje reprezentaci polí instrukcí jazyka MSIL (Microsoft Intermediate Language) pro emise členy ILGenerator třídy (například 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- Dědičnost
-
OpCodes
- Atributy
Příklady
Následující příklad ukazuje konstrukci dynamické metody pomocí ILGenerator k vygenerování OpCodes do 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
Poznámky
Podrobný popis opcode členů najdete v dokumentaci k common language infrastructure (CLI), zejména v části Oddíl III: Sada instrukcí CIL a Oddíl II: Definice metadat a sémantika. Další informace najdete v tématu ECMA 335 Common Language Infrastructure (CLI).
Pole
| Add |
Sečte dvě hodnoty a nasdílí výsledek do zásobníku vyhodnocení. |
| Add_Ovf |
Přidá dvě celá čísla, provede kontrolu přetečení a nasdílí výsledek do zásobníku vyhodnocení. |
| Add_Ovf_Un |
Přidá dvě celočíselné hodnoty bez znaménka, provede kontrolu přetečení a nasdílí výsledek do zkušebního zásobníku. |
| And |
Vypočítá bitový operátor AND dvou hodnot a nasdílí výsledek do zásobníku vyhodnocení. |
| Arglist |
Vrátí nespravovaný ukazatel na seznam argumentů aktuální metody. |
| Beq |
Pokud jsou dvě hodnoty rovny, přenese ovládací prvek na cílovou instrukci. |
| Beq_S |
Přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud jsou dvě hodnoty stejné. |
| Bge |
Přenese ovládací prvek na cílovou instrukci, pokud je první hodnota větší nebo rovna druhé hodnotě. |
| Bge_S |
Přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota větší nebo rovna druhé hodnotě. |
| Bge_Un |
Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci, pokud je první hodnota větší než druhá hodnota. |
| Bge_Un_S |
Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota. |
| Bgt |
Pokud je první hodnota větší než druhá hodnota, přenese řízení na cílovou instrukci. |
| Bgt_S |
Pokud je první hodnota větší než druhá hodnota, přenese řízení na cílovou instrukci (krátký formulář). |
| Bgt_Un |
Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci, pokud je první hodnota větší než druhá hodnota. |
| Bgt_Un_S |
Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota větší než druhá hodnota. |
| Ble |
Pokud je první hodnota menší nebo rovna druhé hodnotě, přenese ovládací prvek na cílovou instrukci. |
| Ble_S |
Přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší nebo rovna druhé hodnotě. |
| Ble_Un |
Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci, pokud je první hodnota menší nebo rovna druhé hodnotě. |
| Ble_Un_S |
Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší nebo rovna druhé hodnotě. |
| Blt |
Pokud je první hodnota menší než druhá hodnota, přenese řízení na cílovou instrukci. |
| Blt_S |
Pokud je první hodnota menší než druhá hodnota, přenese ovládací prvek na cílovou instrukci (krátký formulář). |
| Blt_Un |
Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci, pokud je první hodnota menší než druhá hodnota. |
| Blt_Un_S |
Při porovnávání celočíselných hodnot bez znaménka nebo neuspořádaných plovoucích hodnot přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud je první hodnota menší než druhá hodnota. |
| Bne_Un |
Přenese ovládací prvek na cílovou instrukci, pokud se nerovnají dvě celočíselné hodnoty bez znaménka nebo neuspořádané plovoucí hodnoty. |
| Bne_Un_S |
Přenese ovládací prvek na cílovou instrukci (krátký formulář), pokud se dvě celočíselné hodnoty bez znaménka nebo neuspořádané plovoucí hodnoty nerovnají. |
| Box |
Převede typ hodnoty na odkaz na objekt (typ |
| Br |
Bezpodmínečně přenese řízení na cílovou instrukci. |
| Br_S |
Bezpodmínečně přenese řízení na cílovou instrukci (krátký formulář). |
| Break |
Signalizuje rozhraní příkazového řádku (Common Language Infrastructure) a informuje ladicí program, že došlo k zarážce. |
| Brfalse |
Přenese ovládací prvek na cílovou instrukci, pokud |
| Brfalse_S |
Přenese ovládací prvek na cílovou instrukce, pokud |
| Brtrue |
Přenese ovládací prvek do cílové instrukce, pokud |
| Brtrue_S |
Přenese řízení na cílovou instrukci (krátký formulář), pokud |
| Call |
Zavolá metodu označenou předaným popisovačem metody. |
| Calli |
Zavolá metodu uvedenou ve zkušebním zásobníku (jako ukazatel na vstupní bod) s argumenty popsanými konvencí volání. |
| Callvirt |
Zavolá metodu s pozdní vazbou na objekt a nasdílí návratovou hodnotu do zásobníku vyhodnocení. |
| Castclass |
Pokusí se přetypovat objekt předaný odkazem na zadanou třídu. |
| Ceq |
Porovná dvě hodnoty. Pokud jsou stejné, celočíselná hodnota 1 |
| Cgt |
Porovná dvě hodnoty. Pokud je první hodnota větší než druhá, celočíselná hodnota 1 |
| Cgt_Un |
Porovná dvě hodnoty bez znaménka nebo neuspořádané hodnoty. Pokud je první hodnota větší než druhá, celočíselná hodnota 1 |
| Ckfinite |
ArithmeticException Vyvolá, pokud hodnota není konečné číslo. |
| Clt |
Porovná dvě hodnoty. Pokud je první hodnota menší než druhá, celočíselná hodnota 1 |
| Clt_Un |
Porovná hodnoty bez znaménka nebo neuspořádané hodnoty |
| Constrained |
Omezuje typ, pro který se provádí volání virtuální metody. |
| Conv_I |
Převede hodnotu nad zkušební zásobník na |
| Conv_I1 |
Převede hodnotu nad zásobníkem vyhodnocení na |
| Conv_I2 |
Převede hodnotu nad zásobníkem vyhodnocení na |
| Conv_I4 |
Převede hodnotu nad zkušební zásobník na |
| Conv_I8 |
Převede hodnotu nad zkušební zásobník na |
| Conv_Ovf_I |
Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou |
| Conv_Ovf_I_Un |
Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou |
| Conv_Ovf_I1 |
Převede podepsanou hodnotu nad zkušební zásobník na podepsanou |
| Conv_Ovf_I1_Un |
Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou |
| Conv_Ovf_I2 |
Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou |
| Conv_Ovf_I2_Un |
Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou |
| Conv_Ovf_I4 |
Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou |
| Conv_Ovf_I4_Un |
Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou |
| Conv_Ovf_I8 |
Převede podepsanou hodnotu nad zásobníkem vyhodnocení na podepsanou |
| Conv_Ovf_I8_Un |
Převede hodnotu bez znaménka v horní části zkušebního zásobníku na podepsanou |
| Conv_Ovf_U |
Převede hodnotu se signou hodnotou nad zásobníkem vyhodnocení na |
| Conv_Ovf_U_Un |
Převede hodnotu bez znaménka v horní části zkušebního zásobníku na |
| Conv_Ovf_U1 |
Převede podepsanou hodnotu nad zásobníkem |
| Conv_Ovf_U1_Un |
Převede hodnotu bez znaménka nad zásobníkem vyhodnocení na |
| Conv_Ovf_U2 |
Převede podepsanou hodnotu nad zásobníkem |
| Conv_Ovf_U2_Un |
Převede hodnotu bez znaménka nad zásobníkem vyhodnocení na |
| Conv_Ovf_U4 |
Převede hodnotu se signou hodnotou nad zásobníkem vyhodnocení na |
| Conv_Ovf_U4_Un |
Převede hodnotu bez znaménka v horní části zkušebního zásobníku na |
| Conv_Ovf_U8 |
Převede hodnotu se signou hodnotou nad zásobníkem vyhodnocení na |
| Conv_Ovf_U8_Un |
Převede hodnotu bez znaménka v horní části zkušebního zásobníku na |
| Conv_R_Un |
Převede celočíselnou hodnotu bez znaménka nad zkušební zásobník na |
| Conv_R4 |
Převede hodnotu nad zkušební zásobník na |
| Conv_R8 |
Převede hodnotu nad zkušební zásobník na |
| Conv_U |
Převede hodnotu nad zásobník vyhodnocení na |
| Conv_U1 |
Převede hodnotu nad zásobník vyhodnocení na |
| Conv_U2 |
Převede hodnotu nad zásobník vyhodnocení na |
| Conv_U4 |
Převede hodnotu nad zásobník vyhodnocení na |
| Conv_U8 |
Převede hodnotu nad zásobník vyhodnocení na |
| Cpblk |
Zkopíruje zadaný počet bajtů ze zdrojové adresy na cílovou adresu. |
| Cpobj |
Zkopíruje typ hodnoty umístěný na adrese objektu (typ |
| Div |
Rozdělí dvě hodnoty a nasdílí výsledek jako hodnotu s plovoucí desetinou čárkou (typ |
| Div_Un |
Rozdělí dvě celočíselné hodnoty bez znaménka a nasdílí výsledek ( |
| Dup |
Zkopíruje aktuální nejvyšší hodnotu ve zkušebním zásobníku a potom nasdílí kopii do zkušebního zásobníku. |
| Endfilter |
Přenese řízení z |
| Endfinally |
Přenese řízení z |
| Initblk |
Inicializuje zadaný blok paměti na konkrétní adrese pro danou velikost a počáteční hodnotu. |
| Initobj |
Inicializuje každé pole typu hodnoty na zadané adrese na odkaz null nebo 0 příslušného primitivního typu. |
| Isinst |
Testuje, zda je odkaz na objekt (typ |
| Jmp |
Ukončí aktuální metodu a přeskočí na zadanou metodu. |
| Ldarg |
Načte do zásobníku argument (odkazovaný zadanou hodnotou indexu). |
| Ldarg_0 |
Načte argument v indexu 0 do zásobníku vyhodnocení. |
| Ldarg_1 |
Načte argument v indexu 1 do zásobníku vyhodnocení. |
| Ldarg_2 |
Načte argument v indexu 2 do zásobníku vyhodnocení. |
| Ldarg_3 |
Načte argument v indexu 3 do zásobníku vyhodnocení. |
| Ldarg_S |
Načte argument (odkazovaný zadaným indexem krátkého formuláře) do zásobníku vyhodnocení. |
| Ldarga |
Načtěte adresu argumentu do zkušebního zásobníku. |
| Ldarga_S |
Načtěte adresu argumentu ve stručné podobě do zkušebního zásobníku. |
| Ldc_I4 |
Nasdílí zadanou hodnotu typu |
| Ldc_I4_0 |
Nasdílí celočíselnou hodnotu 0 do zkušebního zásobníku |
| Ldc_I4_1 |
Nasdílí celočíselnou hodnotu 1 do zásobníku vyhodnocení jako |
| Ldc_I4_2 |
Nasdílí celočíselnou hodnotu 2 do zásobníku vyhodnocení jako |
| Ldc_I4_3 |
Nasdílí celočíselnou hodnotu 3 do vyhodnocovacího zásobníku |
| Ldc_I4_4 |
Nasdílí celočíselnou hodnotu 4 do zásobníku vyhodnocení jako |
| Ldc_I4_5 |
Nasdílí celočíselnou hodnotu 5 do vyhodnocovacího zásobníku |
| Ldc_I4_6 |
Nasdílí celočíselnou hodnotu 6 do vyhodnocovacího zásobníku |
| Ldc_I4_7 |
Nasdílí celočíselnou hodnotu 7 do vyhodnocovacího zásobníku |
| Ldc_I4_8 |
Nasdílí celočíselnou hodnotu 8 do zásobníku vyhodnocení jako |
| Ldc_I4_M1 |
Nasdílí celočíselnou hodnotu -1 do zkušebního zásobníku |
| Ldc_I4_S |
Nasdílí zadanou |
| Ldc_I8 |
Nasdílí zadanou hodnotu typu |
| Ldc_R4 |
Nasdílí zadanou hodnotu typu |
| Ldc_R8 |
Nasdílí zadanou hodnotu typu |
| Ldelem |
Načte prvek v zadaném indexu pole do horní části zkušebního zásobníku jako typ zadaný v pokynech. |
| Ldelem_I |
Načte prvek s typem |
| Ldelem_I1 |
Načte element s typem |
| Ldelem_I2 |
Načte element s typem |
| Ldelem_I4 |
Načte element s typem |
| Ldelem_I8 |
Načte element s typem |
| Ldelem_R4 |
Načte prvek s typem |
| Ldelem_R8 |
Načte prvek s typem |
| Ldelem_Ref |
Načte element obsahující odkaz na objekt v zadaném indexu pole do horní části zásobníku vyhodnocení jako typ |
| Ldelem_U1 |
Načte element s typem |
| Ldelem_U2 |
Načte element s typem |
| Ldelem_U4 |
Načte element s typem |
| Ldelema |
Načte adresu prvku pole v zadaném indexu pole do horní části zásobníku vyhodnocení jako typ |
| Ldfld |
Vyhledá hodnotu pole v objektu, jehož odkaz je aktuálně ve zkušebním zásobníku. |
| Ldflda |
Vyhledá adresu pole v objektu, jehož odkaz je aktuálně ve zkušebním zásobníku. |
| Ldftn |
Odešle nespravovaný ukazatel (typ |
| Ldind_I |
Nepřímo načte hodnotu typu |
| Ldind_I1 |
Načte hodnotu typu |
| Ldind_I2 |
Načte hodnotu typu |
| Ldind_I4 |
Načte hodnotu typu |
| Ldind_I8 |
Načte hodnotu typu |
| Ldind_R4 |
Načte hodnotu typu |
| Ldind_R8 |
Načte hodnotu typu |
| Ldind_Ref |
Nepřímo načte odkaz na objekt jako typ |
| Ldind_U1 |
Načte hodnotu typu |
| Ldind_U2 |
Načte hodnotu typu |
| Ldind_U4 |
Načte hodnotu typu |
| Ldlen |
Nasdílí počet prvků jednorozměrného pole založeného na nule do vyhodnocovací sady. |
| Ldloc |
Načte místní proměnnou v určitém indexu do zásobníku vyhodnocení. |
| Ldloc_0 |
Načte místní proměnnou v indexu 0 do zásobníku vyhodnocení. |
| Ldloc_1 |
Načte místní proměnnou v indexu 1 do zásobníku vyhodnocení. |
| Ldloc_2 |
Načte místní proměnnou v indexu 2 do zásobníku vyhodnocení. |
| Ldloc_3 |
Načte místní proměnnou v indexu 3 do zásobníku vyhodnocení. |
| Ldloc_S |
Načte místní proměnnou v určitém indexu do zásobníku vyhodnocení v krátké formě. |
| Ldloca |
Načte adresu místní proměnné na konkrétním indexu do zásobníku vyhodnocení. |
| Ldloca_S |
Načte adresu místní proměnné v určitém indexu do zásobníku vyhodnocení v krátké podobě. |
| Ldnull |
Nasdílí do zásobníku vyhodnocení odkaz s hodnotou null (typ |
| Ldobj |
Zkopíruje objekt typu hodnoty, na který odkazuje adresa, do horní části zkušebního zásobníku. |
| Ldsfld |
Nasdílí hodnotu statického pole do zásobníku vyhodnocení. |
| Ldsflda |
Nasdílí adresu statického pole do zásobníku vyhodnocení. |
| Ldstr |
Nasdílí odkaz na nový objekt do řetězcového literálu uloženého v metadatech. |
| Ldtoken |
Převede token metadat na jeho reprezentaci za běhu a nasdílí ho do zkušebního zásobníku. |
| Ldvirtftn |
Odešle nespravovaný ukazatel (typ |
| Leave |
Ukončí chráněnou oblast kódu a bezpodmínečně přenese řízení na konkrétní cílovou instrukci. |
| Leave_S |
Ukončí chráněnou oblast kódu a bezpodmínečně přenese řízení na cílovou instrukci (krátký formulář). |
| Localloc |
Přidělí určitý počet bajtů z místního dynamického fondu paměti a nasdílí adresu (přechodný ukazatel, typ |
| Mkrefany |
Nasdílí typový odkaz na instanci určitého typu do zkušebního zásobníku. |
| Mul |
Vynásobí dvě hodnoty a nasdílí výsledek do zásobníku vyhodnocení. |
| Mul_Ovf |
Vynásobí dvě celočíselné hodnoty, provede kontrolu přetečení a nasdílí výsledek do zásobníku vyhodnocení. |
| Mul_Ovf_Un |
Vynásobí dvě celočíselné hodnoty bez znaménka, provede kontrolu přetečení a nasdílí výsledek do zásobníku vyhodnocení. |
| Neg |
Neguje hodnotu a nasdílí výsledek do zásobníku vyhodnocení. |
| Newarr |
Nasdílí odkaz na objekt do nového jednorozměrného pole založeného na nule, jehož prvky jsou určitého typu, do zásobníku vyhodnocení. |
| Newobj |
Vytvoří nový objekt nebo novou instanci hodnotového typu a nasdílí odkaz na objekt (typ |
| Nop |
Pokud jsou opcode opravené, vyplní místo. Neprovádí se žádná smysluplná operace, i když je možné využívat cyklus zpracování. |
| Not |
Vypočítá bitový doplněk celočíselné hodnoty nad zásobníkem a nasdílí výsledek do zkušebního zásobníku jako stejný typ. |
| Or |
Vypočítá bitový doplněk dvou celočíselných hodnot nad zásobníkem a nasdílí výsledek do zkušebního zásobníku. |
| Pop |
Odebere hodnotu, která je aktuálně nad zásobníkem vyhodnocení. |
| Prefix1 |
Toto je rezervovaná instrukce. |
| Prefix2 |
Toto je rezervovaná instrukce. |
| Prefix3 |
Toto je rezervovaná instrukce. |
| Prefix4 |
Toto je rezervovaná instrukce. |
| Prefix5 |
Toto je rezervovaná instrukce. |
| Prefix6 |
Toto je rezervovaná instrukce. |
| Prefix7 |
Toto je rezervovaná instrukce. |
| Prefixref |
Toto je rezervovaná instrukce. |
| Readonly |
Určuje, že následná operace adresy pole neprovádí za běhu žádnou kontrolu typu a že vrátí spravovaný ukazatel, jehož proměnlivost je omezená. |
| Refanytype |
Načte token typu vložený do zadaného odkazu. |
| Refanyval |
Načte adresu (typ |
| Rem |
Rozdělí dvě hodnoty a zbytek nasdílí do zkušebního zásobníku. |
| Rem_Un |
Rozdělí dvě nepodepsané hodnoty a zbytek nasdílí do zkušebního zásobníku. |
| Ret |
Vrátí hodnotu z aktuální metody a nasdílí návratovou hodnotu (pokud je k dispozici) z vyhodnocovacího zásobníku volané do testovacího zásobníku volajícího. |
| Rethrow |
Znovu vyvolá aktuální výjimku. |
| Shl |
Posune celočíselnou hodnotu doleva (v nulách) o zadaný počet bitů a výsledek se přesune do zásobníku vyhodnocení. |
| Shr |
Posune celočíselnou hodnotu (v znaménku) doprava o zadaný počet bitů a nasdílí výsledek do zásobníku vyhodnocení. |
| Shr_Un |
Posune celočíselnou hodnotu bez znaménka (v nulech) doprava o zadaný počet bitů a výsledek se přepíše do zásobníku vyhodnocení. |
| Sizeof |
Vloží velikost zadaného typu hodnoty v bajtech do zásobníku vyhodnocení. |
| Starg |
Uloží hodnotu nad zásobník vyhodnocení ve slotu argumentu v zadaném indexu. |
| Starg_S |
Uloží hodnotu nad zásobník vyhodnocení ve slotu argumentů v zadaném krátkém formátu indexu. |
| Stelem |
Nahradí prvek pole v daném indexu hodnotou ve zkušebním zásobníku, jejíž typ je určen v instrukci. |
| Stelem_I |
Nahradí prvek pole v daném indexu |
| Stelem_I1 |
Nahradí prvek pole v daném indexu |
| Stelem_I2 |
Nahradí prvek pole v daném indexu |
| Stelem_I4 |
Nahradí prvek pole v daném indexu |
| Stelem_I8 |
Nahradí prvek pole v daném indexu |
| Stelem_R4 |
Nahradí prvek pole v daném indexu |
| Stelem_R8 |
Nahradí prvek pole v daném indexu |
| Stelem_Ref |
Nahradí prvek pole v daném indexu hodnotou odkaz objektu (typ |
| Stfld |
Nahradí hodnotu uloženou v poli odkazu na objekt nebo ukazatel novou hodnotou. |
| Stind_I |
Uloží hodnotu typu |
| Stind_I1 |
Uloží hodnotu typu |
| Stind_I2 |
Uloží hodnotu typu |
| Stind_I4 |
Uloží hodnotu typu |
| Stind_I8 |
Uloží hodnotu typu |
| Stind_R4 |
Uloží hodnotu typu |
| Stind_R8 |
Uloží hodnotu typu |
| Stind_Ref |
Uloží hodnotu odkazu na objekt na zadanou adresu. |
| Stloc |
Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v zadaném indexu. |
| Stloc_0 |
Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v indexu 0. |
| Stloc_1 |
Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v indexu 1. |
| Stloc_2 |
Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v indexu 2. |
| Stloc_3 |
Otevře aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v indexu 3. |
| Stloc_S |
Přemísťuje aktuální hodnotu z horní části zásobníku vyhodnocení a uloží ji do seznamu místních proměnných v |
| Stobj |
Zkopíruje hodnotu zadaného typu ze zkušebního zásobníku do zadané adresy paměti. |
| Stsfld |
Nahradí hodnotu statického pole hodnotou ze sady vyhodnocení. |
| Sub |
Odečte jednu hodnotu od druhé a výsledek se nasdílí do zásobníku vyhodnocení. |
| Sub_Ovf |
Odečte jednu celočíselnou hodnotu od druhé, provede kontrolu přetečení a výsledek nasdílí do vyhodnocovacího zásobníku. |
| Sub_Ovf_Un |
Odečte jednu celočíselnou hodnotu bez znaménka od druhé, provede kontrolu přetečení a výsledek nasdílí do zásobníku vyhodnocení. |
| Switch |
Implementuje tabulku odkazů. |
| Tailcall |
Provádí příponu metody volání instrukce tak, že aktuální metoda zásobníku rámec je odstraněna před provedením skutečného volání instrukce. |
| Throw |
Vyvolá objekt výjimky, který je aktuálně ve zkušebním zásobníku. |
| Unaligned |
Označuje, že adresa, která je aktuálně na vrcholu zásobníku hodnocení, nemusí být zarovnaná s přirozenou velikostí bezprostředně následující |
| Unbox |
Převede reprezentaci typu hodnoty v rámečku do jeho nezasílané podoby. |
| Unbox_Any |
Převede zadanou reprezentaci typu zadaného v instrukcích do jeho unboxed podoby. |
| Volatile |
Určuje, že adresa, která je aktuálně na vrcholu zásobníku hodnocení, může být nestálou a výsledky čtení tohoto umístění nelze uložit do mezipaměti nebo že více úložišť do tohoto umístění nelze potlačit. |
| Xor |
Vypočítá bitový XOR prvních dvou hodnot v zásobníku vyhodnocení a nasdílí výsledek do zásobníku vyhodnocení. |
Metody
| Equals(Object) |
Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object) |
| GetHashCode() |
Slouží jako výchozí hashovací funkce. (Zděděno od Object) |
| GetType() |
Získá aktuální Type instanci. (Zděděno od Object) |
| MemberwiseClone() |
Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object) |
| TakesSingleByteArgument(OpCode) |
Vrátí hodnotu true nebo false, pokud zadaný opcode přebírá jeden bajt argument. |
| ToString() |
Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object) |
Platí pro
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro