OpCodes Classe

Definizione

Spazio dei nomi:: System.Reflection.Emit

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

Assembly:: mscorlib.dll

Assembly:: System.Reflection.Primitives.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Fornisce rappresentazioni di campo delle istruzioni MSIL (Microsoft Intermediate Language) per l'emissione da parte dei membri della classe ILGenerator (ad esempio 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 oggetto MethodBuilder.


using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

class EmitWriteLineDemo {

   public static Type CreateDynamicType() {
       Type[] ctorParams = new Type[] {typeof(int),
                   typeof(int)};
    
       AppDomain myDomain = Thread.GetDomain();
       AssemblyName myAsmName = new AssemblyName();
       myAsmName.Name = "MyDynamicAssembly";

       AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
                      myAsmName,
                      AssemblyBuilderAccess.Run);

       ModuleBuilder pointModule = myAsmBuilder.DefineDynamicModule("PointModule",
                                    "Point.dll");

       TypeBuilder pointTypeBld = pointModule.DefineType("Point",
                                  TypeAttributes.Public);

       FieldBuilder xField = pointTypeBld.DefineField("x", typeof(int),
                                                      FieldAttributes.Public);
       FieldBuilder yField = pointTypeBld.DefineField("y", typeof(int),
                                                      FieldAttributes.Public);

       Type objType = Type.GetType("System.Object");
       ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);

       ConstructorBuilder pointCtor = pointTypeBld.DefineConstructor(
                                   MethodAttributes.Public,
                                   CallingConventions.Standard,
                                   ctorParams);
       ILGenerator ctorIL = pointCtor.GetILGenerator();

       // First, you build the constructor.
       ctorIL.Emit(OpCodes.Ldarg_0);
       ctorIL.Emit(OpCodes.Call, objCtor);
       ctorIL.Emit(OpCodes.Ldarg_0);
       ctorIL.Emit(OpCodes.Ldarg_1);
       ctorIL.Emit(OpCodes.Stfld, xField);
       ctorIL.Emit(OpCodes.Ldarg_0);
       ctorIL.Emit(OpCodes.Ldarg_2);
       ctorIL.Emit(OpCodes.Stfld, yField);
       ctorIL.Emit(OpCodes.Ret);

       //  Now, you'll build a method to output some information on the
       // inside your dynamic class. This method will have the following
       // definition in C#:
    //  public void WritePoint()

       MethodBuilder writeStrMthd = pointTypeBld.DefineMethod(
                                     "WritePoint",
                             MethodAttributes.Public,
                                             typeof(void),
                                             null);

       ILGenerator writeStrIL = writeStrMthd.GetILGenerator();

       // The below ILGenerator created demonstrates a few ways to create
       // string output through STDIN.

       // ILGenerator.EmitWriteLine(string) will generate a ldstr and a
       // call to WriteLine for you.

       writeStrIL.EmitWriteLine("The value of this current instance is:");

       // Here, you will do the hard work yourself. First, you need to create
       // the string we will be passing and obtain the correct WriteLine overload
       // for said string. In the below case, you are substituting in two values,
       // so the chosen overload is Console.WriteLine(string, object, object).

       String inStr = "({0}, {1})";
       Type[] wlParams = new Type[] {typeof(string),
                     typeof(object),
                     typeof(object)};

       // We need the MethodInfo to pass into EmitCall later.

       MethodInfo writeLineMI = typeof(Console).GetMethod(
                            "WriteLine",
                        wlParams);

       // Push the string with the substitutions onto the stack.
       // This is the first argument for WriteLine - the string one.

       writeStrIL.Emit(OpCodes.Ldstr, inStr);

       // Since the second argument is an object, and it corresponds to
       // to the substitution for the value of our integer field, you
       // need to box that field to an object. First, push a reference
       // to the current instance, and then push the value stored in
       // field 'x'. We need the reference to the current instance (stored
       // in local argument index 0) so Ldfld can load from the correct
       // instance (this one).

       writeStrIL.Emit(OpCodes.Ldarg_0);
       writeStrIL.Emit(OpCodes.Ldfld, xField);

       // Now, we execute the box opcode, which pops the value of field 'x',
       // returning a reference to the integer value boxed as an object.

       writeStrIL.Emit(OpCodes.Box, typeof(int));

       // Atop the stack, you'll find our string inStr, followed by a reference
       // to the boxed value of 'x'. Now, you need to likewise box field 'y'.

       writeStrIL.Emit(OpCodes.Ldarg_0);
       writeStrIL.Emit(OpCodes.Ldfld, yField);
       writeStrIL.Emit(OpCodes.Box, typeof(int));

       // Now, you have all of the arguments for your call to
       // Console.WriteLine(string, object, object) atop the stack:
       // the string InStr, a reference to the boxed value of 'x', and
       // a reference to the boxed value of 'y'.

       // Call Console.WriteLine(string, object, object) with EmitCall.

       writeStrIL.EmitCall(OpCodes.Call, writeLineMI, null);

       // Lastly, EmitWriteLine can also output the value of a field
       // using the overload EmitWriteLine(FieldInfo).

       writeStrIL.EmitWriteLine("The value of 'x' is:");
       writeStrIL.EmitWriteLine(xField);
       writeStrIL.EmitWriteLine("The value of 'y' is:");
       writeStrIL.EmitWriteLine(yField);

       // Since we return no value (void), the ret opcode will not
       // return the top stack value.

       writeStrIL.Emit(OpCodes.Ret);

       return pointTypeBld.CreateType();
   }

   public static void Main() {

      object[] ctorParams = new object[2];

      Console.Write("Enter a integer value for X: ");
      string myX = Console.ReadLine();
      Console.Write("Enter a integer value for Y: ");
      string myY = Console.ReadLine();

      Console.WriteLine("---");

      ctorParams[0] = Convert.ToInt32(myX);
      ctorParams[1] = Convert.ToInt32(myY);

      Type ptType = CreateDynamicType();

      object ptInstance = Activator.CreateInstance(ptType, ctorParams);
      ptType.InvokeMember("WritePoint",
              BindingFlags.InvokeMethod,
              null,
              ptInstance,
              new object[0]);
   }
}


Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

 _

Class EmitWriteLineDemo
   
   
   Public Shared Function CreateDynamicType() As Type

      Dim ctorParams() As Type = {GetType(Integer), GetType(Integer)}
      
      Dim myDomain As AppDomain = Thread.GetDomain()
      Dim myAsmName As New AssemblyName()
      myAsmName.Name = "MyDynamicAssembly"
      
      Dim myAsmBuilder As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
      
      Dim pointModule As ModuleBuilder = myAsmBuilder.DefineDynamicModule("PointModule", "Point.dll")
      
      Dim pointTypeBld As TypeBuilder = pointModule.DefineType("Point", _
                                   TypeAttributes.Public)
      
      Dim xField As FieldBuilder = pointTypeBld.DefineField("x", _
                                GetType(Integer), _
                                FieldAttributes.Public)
      Dim yField As FieldBuilder = pointTypeBld.DefineField("y", _
                                GetType(Integer), _
                                FieldAttributes.Public)
      
      
      Dim objType As Type = Type.GetType("System.Object")
      Dim objCtor As ConstructorInfo = objType.GetConstructor(New Type(){})
      
      Dim pointCtor As ConstructorBuilder = pointTypeBld.DefineConstructor( _
                             MethodAttributes.Public, _
                             CallingConventions.Standard, _
                             ctorParams)
      Dim ctorIL As ILGenerator = pointCtor.GetILGenerator()
      
      
      ' First, you build the constructor.

      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Call, objCtor)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_1)
      ctorIL.Emit(OpCodes.Stfld, xField)
      ctorIL.Emit(OpCodes.Ldarg_0)
      ctorIL.Emit(OpCodes.Ldarg_2)
      ctorIL.Emit(OpCodes.Stfld, yField)
      ctorIL.Emit(OpCodes.Ret)
      
      '  Now, you'll build a method to output some information on the
      ' inside your dynamic class. This method will have the following
      ' definition in C#:
      '  Public Sub WritePoint() 

      Dim writeStrMthd As MethodBuilder = pointTypeBld.DefineMethod("WritePoint", _
                                    MethodAttributes.Public, _
                                    Nothing, Nothing)
      
      Dim writeStrIL As ILGenerator = writeStrMthd.GetILGenerator()
      
      ' The below ILGenerator created demonstrates a few ways to create
      ' string output through STDIN. 
      ' ILGenerator.EmitWriteLine(string) will generate a ldstr and a 
      ' call to WriteLine for you.

      writeStrIL.EmitWriteLine("The value of this current instance is:")
      
      ' Here, you will do the hard work yourself. First, you need to create
      ' the string we will be passing and obtain the correct WriteLine overload
      ' for said string. In the below case, you are substituting in two values,
      ' so the chosen overload is Console.WriteLine(string, object, object).

      Dim inStr As [String] = "({0}, {1})"
      Dim wlParams() As Type = {GetType(String), GetType(Object), GetType(Object)}
      
      ' We need the MethodInfo to pass into EmitCall later.

      Dim writeLineMI As MethodInfo = GetType(Console).GetMethod("WriteLine", wlParams)
      
      ' Push the string with the substitutions onto the stack.
      ' This is the first argument for WriteLine - the string one. 

      writeStrIL.Emit(OpCodes.Ldstr, inStr)
      
      ' Since the second argument is an object, and it corresponds to
      ' to the substitution for the value of our integer field, you 
      ' need to box that field to an object. First, push a reference
      ' to the current instance, and then push the value stored in
      ' field 'x'. We need the reference to the current instance (stored
      ' in local argument index 0) so Ldfld can load from the correct
      ' instance (this one).

      writeStrIL.Emit(OpCodes.Ldarg_0)
      writeStrIL.Emit(OpCodes.Ldfld, xField)
      
      ' Now, we execute the box opcode, which pops the value of field 'x',
      ' returning a reference to the integer value boxed as an object.

      writeStrIL.Emit(OpCodes.Box, GetType(Integer))
      
      ' Atop the stack, you'll find our string inStr, followed by a reference
      ' to the boxed value of 'x'. Now, you need to likewise box field 'y'.

      writeStrIL.Emit(OpCodes.Ldarg_0)
      writeStrIL.Emit(OpCodes.Ldfld, yField)
      writeStrIL.Emit(OpCodes.Box, GetType(Integer))
      
      ' Now, you have all of the arguments for your call to
      ' Console.WriteLine(string, object, object) atop the stack:
      ' the string InStr, a reference to the boxed value of 'x', and
      ' a reference to the boxed value of 'y'.
      ' Call Console.WriteLine(string, object, object) with EmitCall.

      writeStrIL.EmitCall(OpCodes.Call, writeLineMI, Nothing)
      
      ' Lastly, EmitWriteLine can also output the value of a field
      ' using the overload EmitWriteLine(FieldInfo).

      writeStrIL.EmitWriteLine("The value of 'x' is:")
      writeStrIL.EmitWriteLine(xField)
      writeStrIL.EmitWriteLine("The value of 'y' is:")
      writeStrIL.EmitWriteLine(yField)
      
      ' Since we return no value (void), the ret opcode will not
      ' return the top stack value.

      writeStrIL.Emit(OpCodes.Ret)
      
      Return pointTypeBld.CreateType()

   End Function 'CreateDynamicType
    
   
   Public Shared Sub Main()
      
      Dim ctorParams(1) As Object
      
      Console.Write("Enter a integer value for X: ")
      Dim myX As String = Console.ReadLine()
      Console.Write("Enter a integer value for Y: ")
      Dim myY As String = Console.ReadLine()
      
      Console.WriteLine("---")
      
      ctorParams(0) = Convert.ToInt32(myX)
      ctorParams(1) = Convert.ToInt32(myY)
      
      Dim ptType As Type = CreateDynamicType()

      Dim ptInstance As Object = Activator.CreateInstance(ptType, ctorParams)

      ptType.InvokeMember("WritePoint", _
              BindingFlags.InvokeMethod, _
              Nothing, ptInstance, Nothing)

   End Sub

End Class

Commenti

Per una descrizione dettagliata dei codici operativo dei membri, 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).For more information, see ECMA 335 Common Language Infrastructure (CLI).

Campi

Nome	Descrizione
Add	Aggiunge due valori e inserisce il risultato nello stack di valutazione.
Add_Ovf	Aggiunge due numeri interi, esegue un controllo di overflow e inserisce il risultato nello stack di valutazione.
Add_Ovf_Un	Aggiunge due valori interi senza segno, esegue un controllo di overflow e inserisce il risultato nello stack di valutazione.
And	Calcola l'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 valore.
Bge_S	Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è maggiore o uguale al secondo valore.
Bge_Un	Trasferisce il controllo a un'istruzione di destinazione se il primo valore è maggiore del secondo valore, quando si confrontano valori integer 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, quando si confrontano valori integer senza segno o valori float non ordinati.
Bgt	Trasferisce il controllo a un'istruzione di destinazione se il primo valore è maggiore del secondo valore.
Bgt_S	Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è maggiore del secondo valore.
Bgt_Un	Trasferisce il controllo a un'istruzione di destinazione se il primo valore è maggiore del secondo valore, quando si confrontano valori integer 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, quando si confrontano valori integer 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 valore.
Ble_S	Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è minore o uguale al secondo valore.
Ble_Un	Trasferisce il controllo a un'istruzione di destinazione se il primo valore è minore o uguale al secondo valore, quando si confrontano valori integer 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 valore, quando si confrontano valori integer senza segno o valori float non ordinati.
Blt	Trasferisce il controllo a un'istruzione di destinazione se il primo valore è minore del secondo valore.
Blt_S	Trasferisce il controllo a un'istruzione di destinazione (forma breve) se il primo valore è minore del secondo valore.
Blt_Un	Trasferisce il controllo a un'istruzione di destinazione se il primo valore è minore del secondo valore, quando si confrontano valori integer 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, quando si confrontano valori integer senza segno o valori float non ordinati.
Bne_Un	Trasferisce il controllo a un'istruzione di destinazione quando due valori integer 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 integer senza segno o valori float non ordinati non sono uguali.
Box	Converte un tipo valore in un riferimento a un oggetto (tipo `O`).
Br	Trasferisce in modo incondizionato il controllo a un'istruzione di destinazione.
Br_S	Trasferisce in modo incondizionato il controllo a un'istruzione di destinazione (forma breve).
Break	Segnala a Common Language Infrastructure (CLI) di informare il debugger che è stato ritagliato un punto di interruzione.
Brfalse	Trasferisce il controllo a un'istruzione di destinazione se `value` è `false`, un riferimento Null (`Nothing` in Visual Basic) o zero.
Brfalse_S	Trasferisce il controllo a un'istruzione di destinazione se `value` è `false`, un riferimento Null o zero.
Brtrue	Trasferisce il controllo a un'istruzione di destinazione se `value` è `true`, non null o diverso da zero.
Brtrue_S	Trasferisce il controllo a un'istruzione di destinazione (forma breve) se `value` è `true`, non null o diverso da zero.
Call	Chiama il metodo indicato dal descrittore del metodo passato.
Calli	Chiama il metodo indicato nello stack di valutazione (come puntatore a un punto di ingresso) con argomenti descritti da una convenzione di chiamata.
Callvirt	Chiama un metodo ad associazione tardiva su un oggetto, spingendo 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 sono uguali, il valore intero 1 `(int32`) viene inserito nello stack di valutazione; in caso contrario, 0 (`int32`) viene inserito nello stack di valutazione.
Cgt	Confronta due valori. Se il primo valore è maggiore del secondo, il valore intero 1 `(int32`) viene inserito nello stack di valutazione; in caso contrario, 0 (`int32`) viene inserito nello stack di valutazione.
Cgt_Un	Confronta due valori senza segno o non ordinati. Se il primo valore è maggiore del secondo, il valore intero 1 `(int32`) viene inserito nello stack di valutazione; in caso contrario, 0 (`int32`) viene inserito nello stack di valutazione.
Ckfinite	Genera un'eccezione ArithmeticException se il valore non è un numero finito.
Clt	Confronta due valori. Se il primo valore è minore del secondo, il valore intero 1 `(int32`) viene inserito nello stack di valutazione; in caso contrario, 0 (`int32`) viene inserito nello stack di valutazione.
Clt_Un	Confronta i valori `value1` non firmati o non ordinati e `value2`. Se `value1` è minore di `value2`, il valore intero 1 `(int32`) viene inserito nello stack di valutazione; in caso contrario, 0 (`int32`) viene inserito nello stack di valutazione.
Constrained	Vincola il tipo su cui viene effettuata una chiamata al metodo virtuale.
Conv_I	Converte il valore sopra lo stack di valutazione in `native int`.
Conv_I1	Converte il valore sopra lo stack di valutazione in `int8`, quindi lo estende (riquadri) in `int32`.
Conv_I2	Converte il valore sopra lo stack di valutazione in `int16`, quindi lo estende (riquadri) in `int32`.
Conv_I4	Converte il valore sopra lo stack di valutazione in `int32`.
Conv_I8	Converte il valore sopra lo stack di valutazione in `int64`.
Conv_Ovf_I	Converte il valore con segno sopra lo stack di valutazione in con segno `native int`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_I_Un	Converte il valore senza segno sopra lo stack di valutazione in con segno `native int`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_I1	Converte il valore con segno sopra lo stack di valutazione in con segno `int8` e lo estende in `int32`, generando OverflowException un'eccezione sull'overflow.
Conv_Ovf_I1_Un	Converte il valore senza segno sopra lo stack di valutazione in con segno `int8` e lo estende in `int32`, generando OverflowException un'eccezione sull'overflow.
Conv_Ovf_I2	Converte il valore con segno sopra lo stack di valutazione in con segno `int16` ed estendendolo in `int32`, generando OverflowException un'eccezione sull'overflow.
Conv_Ovf_I2_Un	Converte il valore senza segno sopra lo stack di valutazione in con segno `int16` e lo estende in `int32`, generando OverflowException un'eccezione sull'overflow.
Conv_Ovf_I4	Converte il valore con segno sopra lo stack di valutazione in con segno `int32`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_I4_Un	Converte il valore senza segno sopra lo stack di valutazione in con segno `int32`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_I8	Converte il valore con segno sopra lo stack di valutazione in con segno `int64`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_I8_Un	Converte il valore senza segno sopra lo stack di valutazione in con segno `int64`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_U	Converte il valore con segno all'inizio dello stack di valutazione in `unsigned native int`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_U_Un	Converte il valore senza segno sopra lo stack di valutazione in `unsigned native int`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_U1	Converte il valore con segno sopra lo stack `unsigned int8` di valutazione in e lo estende in `int32`, generando OverflowException un'eccezione sull'overflow.
Conv_Ovf_U1_Un	Converte il valore senza segno sopra lo stack `unsigned int8` di valutazione in e lo estende in `int32`, generando OverflowException un'eccezione sull'overflow.
Conv_Ovf_U2	Converte il valore con segno sopra lo stack `unsigned int16` di valutazione in e lo estende in `int32`, generando OverflowException un'eccezione sull'overflow.
Conv_Ovf_U2_Un	Converte il valore senza segno sopra lo stack `unsigned int16` di valutazione in e lo estende in `int32`, generando OverflowException un'eccezione sull'overflow.
Conv_Ovf_U4	Converte il valore con segno all'inizio dello stack di valutazione in `unsigned int32`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_U4_Un	Converte il valore senza segno sopra lo stack di valutazione in `unsigned int32`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_U8	Converte il valore con segno all'inizio dello stack di valutazione in `unsigned int64`, generando un'eccezione OverflowException sull'overflow.
Conv_Ovf_U8_Un	Converte il valore senza segno sopra lo stack di valutazione in `unsigned int64`, generando un'eccezione OverflowException sull'overflow.
Conv_R_Un	Converte il valore intero senza segno sopra lo stack di valutazione in `float32`.
Conv_R4	Converte il valore sopra lo stack di valutazione in `float32`.
Conv_R8	Converte il valore sopra lo stack di valutazione in `float64`.
Conv_U	Converte il valore sopra lo stack di valutazione in `unsigned native int`e lo estende a `native int`.
Conv_U1	Converte il valore sopra lo stack di valutazione in `unsigned int8`e lo estende a `int32`.
Conv_U2	Converte il valore sopra lo stack di valutazione in `unsigned int16`e lo estende a `int32`.
Conv_U4	Converte il valore sopra lo stack di valutazione in `unsigned int32`e lo estende a `int32`.
Conv_U8	Converte il valore sopra lo 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 nell'indirizzo di un oggetto (tipo `&`o `native int`) nell'indirizzo dell'oggetto di destinazione (tipo `&`o `native int` ).
Div	Divide due valori e inserisce il risultato come virgola mobile (tipo `F`) o quoziente (tipo `int32`) nello stack di valutazione.
Div_Un	Divide due valori integer senza segno e inserisce il risultato (`int32`) nello stack di valutazione.
Dup	Copia il valore più alto corrente nello stack di valutazione e quindi esegue il push della copia nello stack di valutazione.
Endfilter	Trasferisce il controllo dalla `filter` clausola di un'eccezione al gestore eccezioni Common Language Infrastructure (CLI).
Endfinally	Trasferisce il controllo dalla `fault` clausola o `finally` di un blocco di eccezioni al gestore eccezioni Common Language Infrastructure (CLI).
Initblk	Inizializza un blocco di memoria specificato in corrispondenza di un indirizzo specifico a una determinata dimensione e valore iniziale.
Initobj	Inizializza ogni campo del tipo valore in corrispondenza di un indirizzo specificato a un riferimento Null o a un valore 0 del tipo primitivo appropriato.
Isinst	Verifica se un riferimento a un oggetto (tipo `O`) è un'istanza di una determinata classe.
Jmp	Esce dal metodo corrente e passa al metodo 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 di forma breve specificato) nello stack di valutazione.
Ldarga	Caricare un indirizzo di argomento nello stack di valutazione.
Ldarga_S	Caricare un indirizzo di 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 pari a 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 pari a 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 pari a 7 nello stack di valutazione come .`int32`
Ldc_I4_8	Inserisce il valore intero pari a 8 nello stack di valutazione come .`int32`
Ldc_I4_M1	Inserisce il valore intero di -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 di un indice di matrice specificato nella parte superiore dello stack di valutazione come tipo specificato nell'istruzione .
Ldelem_I	Carica l'elemento con tipo `native int` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come .`native int`
Ldelem_I1	Carica l'elemento con tipo `int8` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come `int32`.
Ldelem_I2	Carica l'elemento con tipo `int16` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come `int32`.
Ldelem_I4	Carica l'elemento con tipo `int32` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come `int32`.
Ldelem_I8	Carica l'elemento con tipo `int64` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come `int64`.
Ldelem_R4	Carica l'elemento con tipo `float32` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come tipo `F` (float).
Ldelem_R8	Carica l'elemento con tipo `float64` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come tipo `F` (float).
Ldelem_Ref	Carica l'elemento contenente un riferimento a un oggetto in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come tipo `O` (riferimento all'oggetto).
Ldelem_U1	Carica l'elemento con tipo `unsigned int8` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come `int32`.
Ldelem_U2	Carica l'elemento con tipo `unsigned int16` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come `int32`.
Ldelem_U4	Carica l'elemento con tipo `unsigned int32` in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come `int32`.
Ldelema	Carica l'indirizzo dell'elemento matrice in corrispondenza di un indice di matrice specificato nella parte superiore dello stack di valutazione come tipo `&` (puntatore gestito).
Ldfld	Trova il valore di un campo nell'oggetto il cui riferimento è attualmente nello stack di valutazione.
Ldflda	Trova l'indirizzo di un campo nell'oggetto il cui riferimento è attualmente nello stack di valutazione.
Ldftn	Esegue il push di un puntatore non gestito (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 oggetto `native int` nello stack di valutazione.
Ldind_I1	Carica indirettamente un valore di tipo `int8` come oggetto `int32` nello stack di valutazione.
Ldind_I2	Carica indirettamente un valore di tipo `int16` come oggetto `int32` nello stack di valutazione.
Ldind_I4	Carica indirettamente un valore di tipo `int32` come oggetto `int32` nello stack di valutazione.
Ldind_I8	Carica indirettamente un valore di tipo `int64` come oggetto `int64` nello stack di valutazione.
Ldind_R4	Carica indirettamente un `F` valore di tipo `float32` (float) nello stack di valutazione.
Ldind_R8	Carica indirettamente un `F` valore di tipo `float64` (float) nello stack di valutazione.
Ldind_Ref	Carica un riferimento a un oggetto come tipo `O` (riferimento all'oggetto) nello stack di valutazione indirettamente.
Ldind_U1	Carica indirettamente un valore di tipo `unsigned int8` come oggetto `int32` nello stack di valutazione.
Ldind_U2	Carica indirettamente un valore di tipo `unsigned int16` come oggetto `int32` nello stack di valutazione.
Ldind_U4	Carica indirettamente un valore di tipo `unsigned int32` come oggetto `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 (tipo `O`) nello stack di valutazione.
Ldobj	Copia l'oggetto tipo valore a cui punta un indirizzo nella parte superiore 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	Esegue il push di un nuovo riferimento a un nuovo oggetto in un valore letterale stringa archiviato nei metadati.
Ldtoken	Converte un token di metadati nella relativa rappresentazione di runtime, che lo inserisce nello stack di valutazione.
Ldvirtftn	Esegue il push di un puntatore non gestito (tipo `native int`) al codice nativo che implementa un metodo virtuale specifico associato a un oggetto specificato nello stack di valutazione.
Leave	Esce da un'area protetta di codice, trasferendo in modo incondizionato il controllo a un'istruzione di destinazione specifica.
Leave_S	Esce da un'area protetta di codice, trasferendo in modo incondizionato il controllo a un'istruzione di destinazione (forma breve).
Localloc	Alloca un determinato numero di byte dal pool di memoria dinamica locale e inserisce l'indirizzo (un puntatore temporaneo, 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 di overflow e inserisce il risultato nello stack di valutazione.
Mul_Ovf_Un	Moltiplica due valori interi senza segno, esegue un controllo di 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 a una nuova matrice unidimensionale basata su 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 valore, push di un riferimento a un oggetto (tipo `O`) nello stack di valutazione.
Nop	Riempie lo spazio se vengono applicate patch ai codici operativo. Non viene eseguita alcuna operazione significativa anche se è possibile utilizzare un ciclo di elaborazione.
Not	Calcola il complemento bit per bit del valore intero sopra lo stack e inserisce il risultato nello stack di valutazione dello stesso tipo.
Or	Calcolare il complemento bit per bit dei due valori integer sopra lo stack e inserisce il risultato nello stack di valutazione.
Pop	Rimuove il valore attualmente all'inizio dello stack di valutazione.
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 l'operazione di indirizzo di matrice successiva non esegue alcun controllo dei tipi in fase di esecuzione e che restituisce un puntatore gestito la cui mutabilità è limitata.
Refanytype	Recupera il token di tipo incorporato in un riferimento tipizzato.
Refanyval	Recupera l'indirizzo (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 dal metodo corrente, push di un valore restituito (se presente) dallo stack di valutazione del chiamato nello stack di valutazione del chiamante.
Rethrow	Rigenera l'eccezione corrente.
Shl	Sposta un valore intero a sinistra (in zeri) da un numero specificato di bit, eseguendo il push del risultato nello stack di valutazione.
Shr	Sposta un valore intero (nel segno) a destra da un numero specificato di bit, eseguendo il push del risultato nello stack di valutazione.
Shr_Un	Sposta un valore intero senza segno (in zeri) a destra da un numero specificato di bit, eseguendo il push del risultato nello stack di valutazione.
Sizeof	Inserisce le dimensioni, in byte, di un tipo valore fornito nello stack di valutazione.
Starg	Archivia il valore sopra lo stack di valutazione nello slot dell'argomento in corrispondenza di un indice specificato.
Starg_S	Archivia il valore sopra lo stack di valutazione nello slot dell'argomento in corrispondenza di un indice specificato, forma breve.
Stelem	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il valore nello stack di valutazione, il cui tipo è specificato nell'istruzione .
Stelem_I	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il `native int` valore nello stack di valutazione.
Stelem_I1	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il `int8` valore nello stack di valutazione.
Stelem_I2	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il `int16` valore nello stack di valutazione.
Stelem_I4	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il `int32` valore nello stack di valutazione.
Stelem_I8	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il `int64` valore nello stack di valutazione.
Stelem_R4	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il `float32` valore nello stack di valutazione.
Stelem_R8	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il `float64` valore nello stack di valutazione.
Stelem_Ref	Sostituisce l'elemento della matrice in corrispondenza di un determinato indice con il valore di riferimento dell'oggetto (tipo `O`) nello stack di valutazione.
Stfld	Sostituisce il valore archiviato nel campo di un riferimento a un oggetto o un puntatore con un nuovo valore.
Stind_I	Archivia un valore di tipo `native int` in corrispondenza di un indirizzo fornito.
Stind_I1	Archivia un valore di tipo `int8` in corrispondenza di un indirizzo fornito.
Stind_I2	Archivia un valore di tipo `int16` in corrispondenza di un indirizzo fornito.
Stind_I4	Archivia un valore di tipo `int32` in corrispondenza di un indirizzo fornito.
Stind_I8	Archivia un valore di tipo `int64` in corrispondenza di un indirizzo fornito.
Stind_R4	Archivia un valore di tipo `float32` in corrispondenza di un indirizzo fornito.
Stind_R8	Archivia un valore di tipo `float64` in corrispondenza di un indirizzo fornito.
Stind_Ref	Archivia un valore di riferimento all'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	Visualizza il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco delle variabili locali in corrispondenza dell'indice 0.
Stloc_1	Visualizza il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco delle variabili locali in corrispondenza dell'indice 1.
Stloc_2	Popula il valore corrente dall'inizio dello stack di valutazione e lo archivia nell'elenco delle variabili locali in corrispondenza dell'indice 2.
Stloc_3	Popula 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 dello 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 di 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 jump table.
Tailcall	Esegue un'istruzione di chiamata al metodo con prefisso in modo che lo stack frame del metodo corrente venga rimosso prima dell'esecuzione dell'istruzione di chiamata effettiva.
Throw	Genera l'oggetto eccezione attualmente nello stack di valutazione.
Unaligned	Indica che un indirizzo attualmente superiore allo stack di valutazione potrebbe non essere allineato alle dimensioni naturali dell'istruzione immediatamente seguente`ldind`, , `ldfldstind`, `stfldldobjstobj`, , `initblk`, o .`cpblk`
Unbox	Converte la rappresentazione boxed di un tipo valore nel formato unboxed.
Unbox_Any	Converte la rappresentazione boxed di un tipo specificato nell'istruzione nel formato unboxed.
Volatile	Specifica che un indirizzo attualmente superiore allo stack di valutazione potrebbe essere volatile e i risultati della lettura di tale posizione non possono essere memorizzati nella cache o che non è possibile eliminare più archivi in tale posizione.
Xor	Calcola l'XOR bit per bit dei primi due valori nello stack di valutazione, spingendo il risultato nello stack di valutazione.

Metodi

Nome	Descrizione
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 il Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
TakesSingleByteArgument(OpCode)	Restituisce true o false se il codice operativo fornito accetta un singolo argomento di byte.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Si applica a

Commenti e suggerimenti

Questa pagina è stata utile?