OpCodes Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.Reflection.Emit
Assembly:
System.Reflection.Primitives.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Origine:
OpCodes.cs
Origine:
OpCodes.cs
Origine:
OpCodes.cs

Fornisce le rappresentazioni dei campi delle istruzioni MSIL (Microsoft Intermediate Language) per la creazione da parte dei membri della classe ILGenerator, ad esempio il metodo Emit(OpCode).

public ref class OpCodes
public class OpCodes
[System.Runtime.InteropServices.ComVisible(true)]
public class OpCodes
type OpCodes = class
[<System.Runtime.InteropServices.ComVisible(true)>]
type OpCodes = class
Public Class OpCodes
Ereditarietà
Object
OpCodes
Attributi
ComVisibleAttribute

Esempio

Nell'esempio seguente viene illustrata la costruzione di un metodo dinamico usando ILGenerator per generare OpCodes in un MethodBuilderoggetto .

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

Commenti

Per una descrizione dettagliata dei codici operativi membro, vedere la documentazione di Common Language Infrastructure (CLI), in particolare "Partition III: CIL Instruction Set" e "Partition II: Metadata Definition and Semantics". Per altre informazioni, vedere ECMA 335 Common Language Infrastructure (CLI).

Campi

Add

Somma due valori e inserisce il risultato nello stack di valutazione.
Add_Ovf

Somma due valori interi, esegue un controllo dell'overflow e inserisce il risultato nello stack di valutazione.
Add_Ovf_Un

Somma due valori interi senza segno, esegue un controllo dell'overflow e inserisce il risultato nello stack di valutazione.
And

Calcola l'operatore AND bit per bit di due valori e inserisce il risultato nello stack di valutazione.
Arglist

Restituisce un puntatore non gestito all'elenco di argomenti del metodo corrente.
Beq

Trasferisce il controllo a un'istruzione di destinazione se due valori sono uguali.
Beq_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se due valori sono uguali.
Bge

Trasferisce il controllo a un'istruzione di destinazione se il primo valore è maggiore o uguale al secondo.
Bge_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è maggiore o uguale al secondo.
Bge_Un

Trasferisce il controllo a un'istruzione di destinazione se il primo valore è maggiore del secondo, durante il confronto di valori interi senza segno o valori float non ordinati.
Bge_Un_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è maggiore del secondo, durante il confronto di valori interi senza segno o valori float non ordinati.
Bgt

Trasferisce il controllo a un'istruzione di destinazione se il primo valore è maggiore del secondo.
Bgt_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è maggiore del secondo.
Bgt_Un

Trasferisce il controllo a un'istruzione di destinazione se il primo valore è maggiore del secondo, durante il confronto di valori interi senza segno o valori float non ordinati.
Bgt_Un_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è maggiore del secondo, durante il confronto di valori interi senza segno o valori float non ordinati.
Ble

Trasferisce il controllo a un'istruzione di destinazione se il primo valore è minore o uguale al secondo.
Ble_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è minore o uguale al secondo.
Ble_Un

Trasferisce il controllo a un'istruzione di destinazione se il primo valore è minore o uguale al secondo, durante il confronto di valori interi senza segno o valori float non ordinati.
Ble_Un_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è minore o uguale al secondo, durante il confronto di valori interi senza segno o valori float non ordinati.
Blt

Trasferisce il controllo a un'istruzione di destinazione se il primo valore è minore del secondo.
Blt_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è minore del secondo.
Blt_Un

Trasferisce il controllo a un'istruzione di destinazione se il primo valore è minore del secondo, durante il confronto di valori interi senza segno o valori float non ordinati.
Blt_Un_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è minore del secondo, durante il confronto di valori interi senza segno o valori float non ordinati.
Bne_Un

Trasferisce il controllo a un'istruzione di destinazione quando due valori interi senza segno o valori float non ordinati non sono uguali.
Bne_Un_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve) quando due valori interi senza segno o valori float non ordinati non sono uguali.
Box

Converte un tipo di valore in un riferimento a un oggetto di tipo O.
Br

Trasferisce il controllo a un'istruzione di destinazione in modo incondizionato.
Br_S

Trasferisce il controllo a un'istruzione di destinazione in modo incondizionato (forma breve).
Break

Segnala a Common Language Infrastructure (CLI) di indicare al debugger che è stato raggiunto un punto di interruzione.
Brfalse

Trasferisce il controllo a un'istruzione di destinazione se value è false, un riferimento null (Nothing in Visual Basic) oppure zero.
Brfalse_S

Trasferisce il controllo a un'istruzione di destinazione se value è false, un riferimento null oppure zero.
Brtrue

Trasferisce il controllo a un'istruzione di destinazione se value è true, diverso da null o da zero.
Brtrue_S

Trasferisce il controllo a un'istruzione di destinazione (forma breve), se value è true, diverso da null oppure diverso da zero.
Call

Chiama il metodo indicato dal descrittore di metodo passato.
Calli

Chiama il metodo indicato nello stack di valutazione, come un puntatore a un punto di ingresso, con gli argomenti descritti da una convenzione di chiamata.
Callvirt

Chiama un metodo ad associazione tardiva su un oggetto, inserendo il valore restituito nello stack di valutazione.
Castclass

Tenta di eseguire il cast di un oggetto passato per riferimento alla classe specificata.
Ceq

Confronta due valori. Se tali valori sono uguali, nello stack di valutazione viene inserito il valore intero 1 (int32); in caso contrario, viene inserito 0 (int32).
Cgt

Confronta due valori. Se il primo valore è maggiore del secondo, nello stack di valutazione viene inserito il valore intero 1 (int32); in caso contrario, viene inserito 0 (int32).
Cgt_Un

Confronta due valori senza segno o non ordinati. Se il primo valore è maggiore del secondo, nello stack di valutazione viene inserito il valore intero 1 (int32); in caso contrario, viene inserito 0 (int32).
Ckfinite

Genera un'eccezione ArithmeticException se il valore non è un numero finito.
Clt

Confronta due valori. Se il primo valore è inferiore al secondo, nello stack di valutazione viene inserito il valore intero 1 (int32); in caso contrario, viene inserito 0 (int32).
Clt_Un

Confronta i due valori senza segno o non ordinati value1 e value2. Se value1 è minore di value2, nello stack di valutazione viene inserito il valore intero 1 (int32); in caso contrario, viene inserito 0 (int32).
Constrained

Vincola il tipo su cui viene eseguita una chiamata al metodo virtuale.
Conv_I

Converte il valore all'inizio dello stack di valutazione in native int.
Conv_I1

Converte il valore all'inizio dello stack di valutazione in int8, quindi lo estende, aggiungendo spazi, a int32.
Conv_I2

Converte il valore all'inizio dello stack di valutazione in int16, quindi lo estende, aggiungendo spazi, a int32.
Conv_I4

Converte il valore all'inizio dello stack di valutazione in int32.
Conv_I8

Converte il valore all'inizio dello stack di valutazione in int64.
Conv_Ovf_I

Converte il valore con segno all'inizio dello stack di valutazione in native int, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I_Un

Converte il valore senza segno all'inizio dello stack di valutazione in native int con segno, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I1

Converte il valore con segno all'inizio dello stack di valutazione in int8 con segno e lo estende a int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I1_Un

Converte il valore senza segno all'inizio dello stack di valutazione in int8 con segno e lo estende a int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I2

Converte il valore con segno all'inizio dello stack di valutazione in int16 con segno e lo estende a int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I2_Un

Converte il valore senza segno all'inizio dello stack di valutazione in int16 con segno e lo estende a int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I4

Converte il valore con segno all'inizio dello stack di valutazione in int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I4_Un

Converte il valore senza segno all'inizio dello stack di valutazione in int32 con segno, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I8

Converte il valore con segno all'inizio dello stack di valutazione in int64, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_I8_Un

Converte il valore senza segno all'inizio dello stack di valutazione in int64 con segno, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U

Converte il valore con segno all'inizio dello stack di valutazione in unsigned native int, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U_Un

Converte il valore senza segno all'inizio dello stack di valutazione in unsigned native int, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U1

Converte il valore con segno all'inizio dello stack di valutazione in unsigned int8 e lo estende a int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U1_Un

Converte il valore senza segno all'inizio dello stack di valutazione in unsigned int8 e lo estende a int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U2

Converte il valore con segno all'inizio dello stack di valutazione in unsigned int16 e lo estende a int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U2_Un

Converte il valore senza segno all'inizio dello stack di valutazione in unsigned int16 e lo estende a int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U4

Converte il valore con segno all'inizio dello stack di valutazione in unsigned int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U4_Un

Converte il valore senza segno all'inizio dello stack di valutazione in unsigned int32, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U8

Converte il valore con segno all'inizio dello stack di valutazione in unsigned int64, generando un'eccezione OverflowException in caso di overflow.
Conv_Ovf_U8_Un

Converte il valore senza segno all'inizio dello stack di valutazione in unsigned int64, generando un'eccezione OverflowException in caso di overflow.
Conv_R_Un

Converte il valore intero senza segno all'inizio dello stack di valutazione in float32.
Conv_R4

Converte il valore all'inizio dello stack di valutazione in float32.
Conv_R8

Converte il valore all'inizio dello stack di valutazione in float64.
Conv_U

Converte il valore all'inizio dello stack di valutazione in unsigned native int e lo estende a native int.
Conv_U1

Converte il valore all'inizio dello stack di valutazione in unsigned int8 e lo estende a int32.
Conv_U2

Converte il valore all'inizio dello stack di valutazione in unsigned int16 e lo estende a int32.
Conv_U4

Converte il valore all'inizio dello stack di valutazione in unsigned int32 e lo estende a int32.
Conv_U8

Converte il valore all'inizio dello stack di valutazione in unsigned int64 e lo estende a int64.
Cpblk

Copia un numero specificato di byte da un indirizzo di origine a un indirizzo di destinazione.
Cpobj

Copia il tipo di valore che si trova all'indirizzo di un oggetto (tipo &o ) nell'indirizzo dell'oggetto di destinazione (tipo &o ).native intnative int
Div

Divide due valori e inserisce il risultato come valore in virgola mobile (di tipo F) o quoziente (di tipo int32) nello stack di valutazione.
Div_Un

Divide due valori interi senza segno e inserisce il risultato (int32) nello stack di valutazione.
Dup

Copia il valore corrente più in alto nello stack di valutazione e inserisce la copia nello stack di valutazione.
Endfilter

Trasferisce il controllo dalla clausola filter di un'eccezione nuovamente al gestore di eccezioni di Common Language Infrastructure (CLI).
Endfinally

Trasferisce il controllo dalla clausola fault o finally di un blocco di eccezioni al gestore di eccezioni di Common Language Infrastructure (CLI).
Initblk

Inizializza un blocco specificato di memoria in corrispondenza di un indirizzo specifico su una dimensione e un valore iniziale dati.
Initobj

Inizializza ciascun campo del tipo di valore in corrispondenza di un indirizzo specifico su un riferimento Null o uno 0 di tipo primitivo appropriato.
Isinst

Verifica se un riferimento a un oggetto di tipo O è un'istanza di una classe particolare.
Jmp

Esce dal metodo corrente e passa a quello specificato.
Ldarg

Carica un argomento (a cui fa riferimento un valore di indice specificato) nello stack.
Ldarg_0

Carica l'argomento in corrispondenza dell'indice 0 nello stack di valutazione.
Ldarg_1

Carica l'argomento in corrispondenza dell'indice 1 nello stack di valutazione.
Ldarg_2

Carica l'argomento in corrispondenza dell'indice 2 nello stack di valutazione.
Ldarg_3

Carica l'argomento in corrispondenza dell'indice 3 nello stack di valutazione.
Ldarg_S

Carica l'argomento (a cui fa riferimento un indice specificato in forma breve) nello stack di valutazione.
Ldarga

Carica l'indirizzo di un argomento nello stack di valutazione.
Ldarga_S

Carica l'indirizzo di un argomento, in forma breve, nello stack di valutazione.
Ldc_I4

Inserisce un valore fornito di tipo int32 nello stack di valutazione come int32.
Ldc_I4_0

Inserisce il valore intero 0 nello stack di valutazione come int32.
Ldc_I4_1

Inserisce il valore intero 1 nello stack di valutazione come int32.
Ldc_I4_2

Inserisce il valore intero 2 nello stack di valutazione come int32.
Ldc_I4_3

Inserisce il valore intero 3 nello stack di valutazione come int32.
Ldc_I4_4

Inserisce il valore intero 4 nello stack di valutazione come int32.
Ldc_I4_5

Inserisce il valore intero 5 nello stack di valutazione come int32.
Ldc_I4_6

Inserisce il valore intero 6 nello stack di valutazione come int32.
Ldc_I4_7

Inserisce il valore intero 7 nello stack di valutazione come int32.
Ldc_I4_8

Inserisce il valore intero 8 nello stack di valutazione come int32.
Ldc_I4_M1

Inserisce il valore intero -1 nello stack di valutazione come int32.
Ldc_I4_S

Inserisce il valore fornito int8 nello stack di valutazione come int32 (forma breve).
Ldc_I8

Inserisce un valore fornito di tipo int64 nello stack di valutazione come int64.
Ldc_R4

Inserisce un valore fornito di tipo float32 nello stack di valutazione come tipo F (float).
Ldc_R8

Inserisce un valore fornito di tipo float64 nello stack di valutazione come tipo F (float).
Ldelem

Carica l'elemento in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come tipo specificato nell'istruzione.
Ldelem_I

Carica l'elemento con tipo native int in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come native int.
Ldelem_I1

Carica l'elemento con tipo int8 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come int32.
Ldelem_I2

Carica l'elemento con tipo int16 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come int32.
Ldelem_I4

Carica l'elemento con tipo int32 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come int32.
Ldelem_I8

Carica l'elemento con tipo int64 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come int64.
Ldelem_R4

Carica l'elemento con tipo float32 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come tipo F (float).
Ldelem_R8

Carica l'elemento con tipo float64 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come tipo F (float).
Ldelem_Ref

Carica l'elemento contenente un riferimento a un oggetto in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come tipo O (riferimento a un oggetto).
Ldelem_U1

Carica l'elemento con tipo unsigned int8 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come int32.
Ldelem_U2

Carica l'elemento con tipo unsigned int16 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come int32.
Ldelem_U4

Carica l'elemento con tipo unsigned int32 in corrispondenza dell'indice di matrice specificato all'inizio dello stack di valutazione come int32.
Ldelema

Carica l'indirizzo dell'elemento di matrice in corrispondenza di un indice di matrice specificato all'inizio dello stack di valutazione come tipo & (puntatore gestito).
Ldfld

Trova il valore di un campo nell'oggetto il cui riferimento si trova attualmente nello stack di valutazione.
Ldflda

Trova l'indirizzo di un campo nell'oggetto il cui riferimento si trova attualmente nello stack di valutazione.
Ldftn

Inserisce un puntatore non gestito di tipo native int al codice nativo che implementa un metodo specifico nello stack di valutazione.
Ldind_I

Carica indirettamente un valore di tipo native int come native int nello stack di valutazione.
Ldind_I1

Carica indirettamente un valore di tipo int8 come int32 nello stack di valutazione.
Ldind_I2

Carica indirettamente un valore di tipo int16 come int32 nello stack di valutazione.
Ldind_I4

Carica indirettamente un valore di tipo int32 come int32 nello stack di valutazione.
Ldind_I8

Carica indirettamente un valore di tipo int64 come int64 nello stack di valutazione.
Ldind_R4

Carica indirettamente un valore di tipo float32 come un tipo F (float) nello stack di valutazione.
Ldind_R8

Carica indirettamente un valore di tipo float64 come un tipo F (float) nello stack di valutazione.
Ldind_Ref

Carica indirettamente un riferimento a un oggetto come un tipo O (riferimento a un oggetto) nello stack di valutazione.
Ldind_U1

Carica indirettamente un valore di tipo unsigned int8 come int32 nello stack di valutazione.
Ldind_U2

Carica indirettamente un valore di tipo unsigned int16 come int32 nello stack di valutazione.
Ldind_U4

Carica indirettamente un valore di tipo unsigned int32 come int32 nello stack di valutazione.
Ldlen

Inserisce il numero di elementi di una matrice unidimensionale in base zero nello stack di valutazione.
Ldloc

Carica la variabile locale in corrispondenza di un indice specifico nello stack di valutazione.
Ldloc_0

Carica la variabile locale in corrispondenza dell'indice 0 nello stack di valutazione.
Ldloc_1

Carica la variabile locale in corrispondenza dell'indice 1 nello stack di valutazione.
Ldloc_2

Carica la variabile locale in corrispondenza dell'indice 2 nello stack di valutazione.
Ldloc_3

Carica la variabile locale in corrispondenza dell'indice 3 nello stack di valutazione.
Ldloc_S

Carica la variabile locale in corrispondenza di un indice specifico nello stack di valutazione, forma breve.
Ldloca

Carica l'indirizzo della variabile locale in corrispondenza di un indice specifico nello stack di valutazione.
Ldloca_S

Carica l'indirizzo della variabile locale in corrispondenza di un indice specifico nello stack di valutazione, forma breve.
Ldnull

Inserisce un riferimento null di tipo O nello stack di valutazione.
Ldobj

Copia l'oggetto tipo di valore a cui punta un indirizzo all'inizio dello stack di valutazione.
Ldsfld

Inserisce il valore di un campo statico nello stack di valutazione.
Ldsflda

Inserisce l'indirizzo di un campo statico nello stack di valutazione.
Ldstr

Inserisce un nuovo riferimento a un oggetto in un valore letterale stringa archiviato nei metadati.
Ldtoken

Converte un token di metadati nella relativa rappresentazione di runtime, inserendolo nello stack di valutazione.
Ldvirtftn

Inserisce un puntatore non gestito di tipo (native int) al codice nativo che implementa un particolare metodo virtual con un oggetto specificato nello stack di valutazione.
Leave

Esce da un'area protetta di codice, trasferendo il controllo in modo incondizionato a un'istruzione di destinazione specifica.
Leave_S

Esce da un'area protetta di codice, trasferendo il controllo in modo incondizionato a un'istruzione di destinazione (forma breve).
Localloc

Esegue l'allocazione di un numero di byte dal pool di memoria dinamica locale e inserisce l'indirizzo (un puntatore transitorio di tipo *) del primo byte allocato nello stack di valutazione.
Mkrefany

Inserisce un riferimento tipizzato a un'istanza di un tipo specifico nello stack di valutazione.
Mul

Moltiplica due valori e inserisce il risultato nello stack di valutazione.
Mul_Ovf

Moltiplica due valori interi, esegue un controllo dell'overflow e inserisce il risultato nello stack di valutazione.
Mul_Ovf_Un

Moltiplica due valori interi senza segno, esegue un controllo dell'overflow e inserisce il risultato nello stack di valutazione.
Neg

Nega un valore e inserisce il risultato nello stack di valutazione.
Newarr

Inserisce un riferimento a un oggetto in una matrice unidimensionale in base zero i cui elementi sono di un tipo specifico nello stack di valutazione.
Newobj

Crea un nuovo oggetto o una nuova istanza di un tipo di valore, inserendo un riferimento a un oggetto (di tipo O) nello stack di valutazione.
Nop

Riempie lo spazio se i codici operativi sono corretti. Non viene eseguita alcuna operazione significativa sebbene possa essere usato un ciclo di elaborazione.
Not

Calcola il complemento bit per bit del valore intero all'inizio dello stack e inserisce il risultato nello stack di valutazione come lo stesso tipo.
Or

Calcola il complemento bit per bit dei due valori interi all'inizio dello stack e inserisce il risultato nello stack di valutazione.
Pop

Rimuove il valore attualmente all'inizio dello stack.
Prefix1

Si tratta di un'istruzione riservata.
Prefix2

Si tratta di un'istruzione riservata.
Prefix3

Si tratta di un'istruzione riservata.
Prefix4

Si tratta di un'istruzione riservata.
Prefix5

Si tratta di un'istruzione riservata.
Prefix6

Si tratta di un'istruzione riservata.
Prefix7

Si tratta di un'istruzione riservata.
Prefixref

Si tratta di un'istruzione riservata.
Readonly

Specifica che la successiva operazione sull'indirizzo di matrice non comporta l'esecuzione di alcun controllo del tipo in fase di esecuzione e che viene restituito un puntatore gestito la cui modificabilità è limitata.
Refanytype

Recupera il token di tipo incorporato in un riferimento tipizzato.
Refanyval

Recupera l'indirizzo (di tipo &) incorporato in un riferimento tipizzato.
Rem

Divide due valori e inserisce il resto nello stack di valutazione.
Rem_Un

Divide due valori senza segno e inserisce il resto nello stack di valutazione.
Ret

Restituisce il risultato del metodo corrente, inserendo il valore restituito (se presente) dallo stack di valutazione del chiamato nello stack di valutazione del chiamante.
Rethrow

Genera nuovamente l'eccezione corrente.
Shl

Sposta un valore intero verso sinistra (spostando gli zeri) di un numero specificato di bit, inserendo il risultato nello stack di valutazione.
Shr

Sposta un valore intero verso destra (spostando il segno) di un numero specificato di bit, inserendo il risultato nello stack di valutazione.
Shr_Un

Sposta un valore intero senza segno verso destra (spostando gli zeri) di un numero specificato di bit, inserendo il risultato nello stack di valutazione.
Sizeof

Inserisce la dimensione in byte del tipo di valore fornito nello stack di valutazione.
Starg

Archivia il valore all'inizio dello stack di valutazione nello slot di argomento in corrispondenza di un indice specificato.
Starg_S

Archivia il valore all'inizio dello stack di valutazione nello slot di argomento in corrispondenza di un indice specificato, forma breve.
Stelem

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore presente nello stack di valutazione, il cui tipo è specificato nell'istruzione.
Stelem_I

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore native int sullo stack di valutazione.
Stelem_I1

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore int8 sullo stack di valutazione.
Stelem_I2

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore int16 sullo stack di valutazione.
Stelem_I4

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore int32 sullo stack di valutazione.
Stelem_I8

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore int64 sullo stack di valutazione.
Stelem_R4

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore float32 sullo stack di valutazione.
Stelem_R8

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore float64 sullo stack di valutazione.
Stelem_Ref

Sostituisce l'elemento di matrice in corrispondenza di un indice specificato con il valore di un riferimento a un oggetto (di tipo O) sullo stack di valutazione.
Stfld

Sostituisce il valore archiviato nel campo di un riferimento a un oggetto o puntatore con un nuovo valore.
Stind_I

Memorizza un valore di tipo native int in corrispondenza di un indirizzo fornito.
Stind_I1

Memorizza un valore di tipo int8 in corrispondenza di un indirizzo fornito.
Stind_I2

Memorizza un valore di tipo int16 in corrispondenza di un indirizzo fornito.
Stind_I4

Memorizza un valore di tipo int32 in corrispondenza di un indirizzo fornito.
Stind_I8

Memorizza un valore di tipo int64 in corrispondenza di un indirizzo fornito.
Stind_R4

Memorizza un valore di tipo float32 in corrispondenza di un indirizzo fornito.
Stind_R8

Memorizza un valore di tipo float64 in corrispondenza di un indirizzo fornito.
Stind_Ref

Archivia il valore di un riferimento a un oggetto in corrispondenza di un indirizzo fornito.
Stloc

Popa il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco di variabili locali in corrispondenza di un indice specificato.
Stloc_0

Popa il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco delle variabili locali in corrispondenza dell'indice 0.
Stloc_1

Popa il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco delle variabili locali in corrispondenza dell'indice 1.
Stloc_2

Popa il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco delle variabili locali in corrispondenza dell'indice 2.
Stloc_3

Popa il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco delle variabili locali in corrispondenza dell'indice 3.
Stloc_S

Popa il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco delle variabili locali in index (forma breve).
Stobj

Copia un valore di un tipo specificato dallo stack di valutazione in un indirizzo di memoria fornito.
Stsfld

Sostituisce il valore di un campo statico con un valore dallo stack di valutazione.
Sub

Sottrae un valore da un altro e inserisce il risultato nello stack di valutazione.
Sub_Ovf

Sottrae un valore intero da un altro, esegue un controllo dell'overflow e inserisce il risultato nello stack di valutazione.
Sub_Ovf_Un

Sottrae un valore intero senza segno da un altro, esegue un controllo dell'overflow e inserisce il risultato nello stack di valutazione.
Switch

Implementa una tabella di collegamento.
Tailcall

Esegue un'istruzione di chiamata al metodo con suffisso tale da rimuovere lo stack frame del metodo corrente prima dell'esecuzione dell'istruzione di chiamata effettiva.
Throw

Genera l'oggetto eccezione attualmente nello stack di valutazione.
Unaligned

Indica che un indirizzo attualmente all'inizio dello stack di valutazione potrebbe non essere allineato rispetto alla dimensione standard dell'istruzione ldind, stind, ldfld, stfld, ldobj, stobj, initblk o cpblk immediatamente successiva.
Unbox

Converte la rappresentazione boxed di un tipo di valore nel relativo formato unboxed.
Unbox_Any

Converte la rappresentazione boxed di un tipo specificato nell'istruzione nel relativo formato unboxed.
Volatile

Specifica che un indirizzo attualmente all'inizio dello stack di valutazione potrebbe essere volatile e che i risultati della lettura del percorso non possono essere memorizzati nella cache o che non è possibile eliminare archivi multipli in tale percorso.
Xor

Calcola l'operazione XOR bit per bit dei primi due valori dello stack di valutazione, inserendo il risultato nello stack di valutazione.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
TakesSingleByteArgument(OpCode)

Restituisce true o false se il codice operativo fornito accetta un argomento a byte singolo.
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Si applica a