OpCodes Classe

Referência

Definição

Namespace:: System.Reflection.Emit

Assembly:: System.Reflection.Primitives.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: OpCodes.cs

Origem:: OpCodes.cs

Origem:: OpCodes.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Fornece representações de campo das instruções da MSIL (Microsoft intermediate language) para emissão por membros da classe ILGenerator (como 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

Herança: Object
OpCodes

Atributos: ComVisibleAttribute

Exemplos

O exemplo a seguir demonstra a construção de um método dinâmico usando ILGenerator para emitir OpCodes em um 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

Comentários

Para obter uma descrição detalhada dos opcodes de membro, consulte a documentação da CLI (Common Language Infrastructure), especialmente "Partição III: Conjunto de Instruções CIL" e "Partição II: Definição de Metadados e Semântica". Para obter mais informações, consulte CLI (Common Language Infrastructure) do ECMA 335.

Campos

Add	Adiciona dois valores e envia o resultado para a pilha de avaliação.
Add_Ovf	Adiciona dois números inteiros, executa uma verificação de estouro e efetua o push do resultado para a pilha de avaliação.
Add_Ovf_Un	Adiciona dois valores de inteiro sem sinal, executa uma verificação de estouro e efetua o push do resultado para a pilha de avaliação.
And	Calcula o AND bit a bit de dois valores e efetua o push do resultado para a pilha de avaliação.
Arglist	Retorna um ponteiro não gerenciado para a lista de argumentos do método atual.
Beq	Transfere o controle para uma instrução de destino se dois valores são iguais.
Beq_S	Transferirá o controle para uma instrução de destino (forma abreviada) se dois valores forem iguais.
Bge	Transferirá controle para uma instrução de destino se o primeiro valor for maior ou igual ao segundo valor.
Bge_S	Transferirá controle para uma instrução de destino (forma abreviada) se o primeiro valor for maior ou igual ao segundo valor.
Bge_Un	Transferirá o controle para uma instrução de destino se o primeiro valor for maior que o segundo valor ao comparar valores de inteiro sem sinal ou valores float não ordenados.
Bge_Un_S	Transferirá o controle para uma instrução de destino (forma abreviada) se o primeiro valor for maior que o segundo valor ao comparar valores de inteiro sem sinal ou valores float não ordenados.
Bgt	Transferirá controle para uma instrução de destino se o primeiro valor for maior que o segundo valor.
Bgt_S	Transferirá controle para uma instrução de destino (forma abreviada) se o primeiro valor for maior que o segundo valor.
Bgt_Un	Transferirá o controle para uma instrução de destino se o primeiro valor for maior que o segundo valor ao comparar valores de inteiro sem sinal ou valores float não ordenados.
Bgt_Un_S	Transferirá o controle para uma instrução de destino (forma abreviada) se o primeiro valor for maior que o segundo valor ao comparar valores de inteiro sem sinal ou valores float não ordenados.
Ble	Transferirá controle para uma instrução de destino se o primeiro valor for menor ou igual ao segundo valor.
Ble_S	Transferirá controle para uma instrução de destino (forma abreviada) se o primeiro valor for menor ou igual ao segundo valor.
Ble_Un	Transferirá o controle para uma instrução de destino se o primeiro valor for menor ou igual ao segundo valor ao comparar valores de inteiro sem sinal ou valores float não ordenados.
Ble_Un_S	Transferirá o controle para uma instrução de destino (forma abreviada) se o primeiro valor for menor ou igual ao segundo valor ao comparar valores de inteiro sem sinal ou valores float não ordenados.
Blt	Transferirá controle para uma instrução de destino se o primeiro valor for menor que o segundo valor.
Blt_S	Transferirá controle para uma instrução de destino (forma abreviada) se o primeiro valor for menor que o segundo valor.
Blt_Un	Transferirá o controle para uma instrução de destino se o primeiro valor for menor que o segundo valor ao comparar valores de inteiro sem sinal ou valores float não ordenados.
Blt_Un_S	Transferirá o controle para uma instrução de destino (forma abreviada) se o primeiro valor for menor que o segundo valor ao comparar valores de inteiro sem sinal ou valores float não ordenados.
Bne_Un	Transfere o controle para uma instrução de destino quando dois valores de inteiro sem sinal ou valores de float não ordenados não são iguais.
Bne_Un_S	Transfere o controle para uma instrução de destino (forma abreviada) quando dois valores inteiros sem sinal ou valores de float não ordenados não são iguais.
Box	Converte um tipo de valor em uma referência de objeto (tipo `O`).
Br	Transfere o controle incondicionalmente para uma instrução de destino.
Br_S	Transfere o controle de forma incondicional para uma instrução de destino (forma abreviada).
Break	Sinaliza a CLI (Common Language Infrastructure) para informar o depurador de que um ponto de interrupção foi ultrapassado.
Brfalse	Transferirá o controle para uma instrução de destino se `value` for `false`, uma referência nula (`Nothing` no Visual Basic) ou zero.
Brfalse_S	Transferirá o controle para uma instrução de destino se `value` for `false`, uma referência nula ou zero.
Brtrue	Transfere o controle para uma instrução de destino se `value` for `true`, não nulo ou diferente de zero.
Brtrue_S	Transfere o controle para uma instrução de destino (forma abreviada) se `value` for `true`, não nulo ou diferente de zero.
Call	Chama o método indicado pelo descritor de método passado.
Calli	Chama o método indicado na pilha de avaliação (como um ponteiro para um ponto de entrada) com argumentos descritos por uma convenção de chamada.
Callvirt	Chama um método de associação tardia em um objeto, enviando o valor retornado por push para a pilha de avaliação.
Castclass	Tenta converter um objeto passado por referência à classe especificada.
Ceq	Compara dois valores. Se eles forem iguais, o valor inteiro 1 `(int32`) será enviado para a pilha de avaliação; caso contrário, 0 (`int32`) será enviado para a pilha de avaliação.
Cgt	Compara dois valores. Se o primeiro valor for maior que o segundo, o valor inteiro 1 `(int32`) será enviado para a pilha de avaliação; caso contrário, 0 (`int32`) será enviada para a pilha de avaliação.
Cgt_Un	Compara dois sem sinal ou não ordenados. Se o primeiro valor for maior que o segundo, o valor inteiro 1 `(int32`) será enviado para a pilha de avaliação; caso contrário, 0 (`int32`) será enviada para a pilha de avaliação.
Ckfinite	Gera ArithmeticException se o valor não for um número finito.
Clt	Compara dois valores. Se o primeiro valor for menor que o segundo, o valor inteiro 1 (`(int32`) será enviado para a pilha de avaliação; caso contrário, 0 (`int32`) será enviada para a pilha de avaliação.
Clt_Un	Compara os valores sem sinal ou não ordenados `value1` e `value2`. Se `value1` for menor que `value2`, o valor de inteiro 1 (`(int32`) será enviado para a pilha de avaliação; caso contrário, 0 (`int32`) será enviado para a pilha de avaliação.
Constrained	Restringe o tipo no qual uma chamada de método virtual é feita.
Conv_I	Converte o valor na parte superior da pilha de avaliação em `native int`.
Conv_I1	Converte o valor na parte superior da pilha de avaliação em `int8` e então estende-o (preenche) para `int32`.
Conv_I2	Converte o valor na parte superior da pilha de avaliação em `int16` e então estende-o (preenche) para `int32`.
Conv_I4	Converte o valor na parte superior da pilha de avaliação em `int32`.
Conv_I8	Converte o valor na parte superior da pilha de avaliação em `int64`.
Conv_Ovf_I	Converte o valor com sinal no topo da pilha de avaliação em `native int` com sinal, gerando OverflowException no estouro.
Conv_Ovf_I_Un	Converte o valor sem sinal no topo da pilha de avaliação em `native int` com sinal, gerando OverflowException no estouro.
Conv_Ovf_I1	Converte o valor com sinal no topo da pilha de avaliação em `int8` com sinal e estende-o para `int32`, gerando OverflowException no estouro.
Conv_Ovf_I1_Un	Converte o valor sem sinal no topo da pilha de avaliação em `int8` com sinal e estende-o para `int32`, gerando OverflowException no estouro.
Conv_Ovf_I2	Converte o valor com sinal no topo da pilha de avaliação em `int16` com sinal e estendendo-o para `int32`, gerando OverflowException no estouro.
Conv_Ovf_I2_Un	Converte o valor sem sinal no topo da pilha de avaliação em `int16` com sinal e estende-o para `int32`, gerando OverflowException no estouro.
Conv_Ovf_I4	Converte o valor com sinal no topo da pilha de avaliação em `int32` com sinal, gerando OverflowException no estouro.
Conv_Ovf_I4_Un	Converte o valor sem sinal no topo da pilha de avaliação em `int32` com sinal, gerando OverflowException no estouro.
Conv_Ovf_I8	Converte o valor com sinal no topo da pilha de avaliação em `int64` com sinal, gerando OverflowException no estouro.
Conv_Ovf_I8_Un	Converte o valor sem sinal no topo da pilha de avaliação em `int64` com sinal, gerando OverflowException no estouro.
Conv_Ovf_U	Converte o valor com sinal no topo da pilha de avaliação em `unsigned native int`, gerando OverflowException no estouro.
Conv_Ovf_U_Un	Converte o valor sem sinal no topo da pilha de avaliação em `unsigned native int`, gerando OverflowException no estouro.
Conv_Ovf_U1	Converte o valor com sinal no topo da pilha de avaliação em `unsigned int8` e estende-o para `int32`, gerando OverflowException no estouro.
Conv_Ovf_U1_Un	Converte o valor sem sinal no topo da pilha de avaliação em `unsigned int8` e estende-o para `int32`, gerando OverflowException no estouro.
Conv_Ovf_U2	Converte o valor com sinal no topo da pilha de avaliação em `unsigned int16` e estende-o para `int32`, gerando OverflowException no estouro.
Conv_Ovf_U2_Un	Converte o valor sem sinal no topo da pilha de avaliação em `unsigned int16` e estende-o para `int32`, gerando OverflowException no estouro.
Conv_Ovf_U4	Converte o valor com sinal no topo da pilha de avaliação em `unsigned int32`, gerando OverflowException no estouro.
Conv_Ovf_U4_Un	Converte o valor sem sinal no topo da pilha de avaliação em `unsigned int32`, gerando OverflowException no estouro.
Conv_Ovf_U8	Converte o valor com sinal no topo da pilha de avaliação em `unsigned int64`, gerando OverflowException no estouro.
Conv_Ovf_U8_Un	Converte o valor sem sinal no topo da pilha de avaliação em `unsigned int64`, gerando OverflowException no estouro.
Conv_R_Un	Converte o valor de inteiro sem sinal na parte superior da pilha de avaliação em `float32`.
Conv_R4	Converte o valor na parte superior da pilha de avaliação em `float32`.
Conv_R8	Converte o valor na parte superior da pilha de avaliação em `float64`.
Conv_U	Converte o valor na parte superior da pilha de avaliação em `unsigned native int` e estende-o para `native int`.
Conv_U1	Converte o valor na parte superior da pilha de avaliação em `unsigned int8` e estende-o para `int32`.
Conv_U2	Converte o valor na parte superior da pilha de avaliação em `unsigned int16` e estende-o para `int32`.
Conv_U4	Converte o valor na parte superior da pilha de avaliação em `unsigned int32` e estende-o para `int32`.
Conv_U8	Converte o valor na parte superior da pilha de avaliação em `unsigned int64` e estende-o para `int64`.
Cpblk	Copia bytes de número especificados de um endereço de origem para um endereço de destino.
Cpobj	Copia o tipo de valor localizado no endereço de um objeto (tipo `&`ou `native int` ) para o endereço do objeto de destino (tipo `&`ou `native int` ).
Div	Divide dois valores e efetua o push do resultado como um ponto flutuante (tipo `F`) ou quociente (tipo `int32`) para a pilha de avaliação.
Div_Un	Divide dois valores de inteiro sem sinal e envia o resultado (`int32`) para a pilha de avaliação.
Dup	Copia o valor atual mais alto na pilha de avaliação e, em seguida, envia a cópia para a pilha de avaliação.
Endfilter	Transfere o controle da cláusula `filter` de uma exceção para o manipulador de exceção da CLI (Common Language Infrastructure).
Endfinally	Transfere o controle da cláusula `fault` ou `finally` de um bloco de exceção de volta para o manipulador de exceção da CLI (Common Language Infrastructure).
Initblk	Inicializa um bloco de memória especificado em um endereço específico e em um tamanho e valor inicial especificados.
Initobj	Inicializa cada campo do tipo de valor em um endereço especificado como uma referência nula ou 0 do tipo primitivo apropriado.
Isinst	Testa se uma referência de objeto (tipo `O`) é uma instância de uma classe específica.
Jmp	Sai do método atual e vai para o método especificado.
Ldarg	Carrega um argumento (referenciado por um valor de índice especificado) na pilha.
Ldarg_0	Carrega o argumento no índice 0 na pilha de avaliação.
Ldarg_1	Carrega o argumento no índice 1 na pilha de avaliação.
Ldarg_2	Carrega o argumento no índice 2 na pilha de avaliação.
Ldarg_3	Carrega o argumento no índice 3 na pilha de avaliação.
Ldarg_S	Carrega o argumento (referenciado por um índice de forma curta especificado) para a pilha de avaliação.
Ldarga	Carregar um endereço de argumento para a pilha de avaliação.
Ldarga_S	Carregar um endereço de argumento, na forma abreviada, para a pilha de avaliação.
Ldc_I4	Envia por push um valor do tipo `int32` fornecido para a pilha de avaliação como um `int32`.
Ldc_I4_0	Envia o valor inteiro de 0 para a pilha de avaliação como um `int32`.
Ldc_I4_1	Envia o valor inteiro 1 por push para a pilha de avaliação como um `int32`.
Ldc_I4_2	Efetua o push do valor inteiro de 2 para a pilha de avaliação como um `int32`.
Ldc_I4_3	Efetua o push do valor inteiro de 3 para a pilha de avaliação como um `int32`.
Ldc_I4_4	Efetua o push do valor inteiro de 4 para a pilha de avaliação como um `int32`.
Ldc_I4_5	Efetua o push do valor inteiro de 5 para a pilha de avaliação como um `int32`.
Ldc_I4_6	Efetua o push do valor inteiro de 6 para a pilha de avaliação como um `int32`.
Ldc_I4_7	Efetua o push do valor inteiro de 7 para a pilha de avaliação como um `int32`.
Ldc_I4_8	Efetua o push do valor inteiro de 8 para a pilha de avaliação como um `int32`.
Ldc_I4_M1	Efetua o push do valor de inteiro de -1 para a pilha de avaliação como um `int32`.
Ldc_I4_S	Envia o valor de `int8` fornecido para a pilha de avaliação como um `int32`, na forma abreviada.
Ldc_I8	Envia por push um valor do tipo `int64` fornecido para a pilha de avaliação como um `int64`.
Ldc_R4	Efetua o push de um valor fornecido do tipo `float32` para a pilha de avaliação como tipo `F` (float).
Ldc_R8	Efetua o push de um valor fornecido do tipo `float64` para a pilha de avaliação como tipo `F` (float).
Ldelem	Carrega o elemento a um índice de matriz especificado na parte superior da pilha de avaliação como o tipo especificado na instrução.
Ldelem_I	Carrega o elemento com o tipo `native int` em um índice de matriz especificado para o topo da pilha de avaliação como um `native int`.
Ldelem_I1	Carrega o elemento com o tipo `int8` em um índice de matriz especificado para o topo da pilha de avaliação como um `int32`.
Ldelem_I2	Carrega o elemento com o tipo `int16` em um índice de matriz especificado para o topo da pilha de avaliação como um `int32`.
Ldelem_I4	Carrega o elemento com o tipo `int32` em um índice de matriz especificado para o topo da pilha de avaliação como um `int32`.
Ldelem_I8	Carrega o elemento com o tipo `int64` em um índice de matriz especificado para o topo da pilha de avaliação como um `int64`.
Ldelem_R4	Carrega o elemento com o tipo `float32` em um índice de matriz especificado para o topo da pilha de avaliação como um tipo `F` (float).
Ldelem_R8	Carrega o elemento com o tipo `float64` em um índice de matriz especificado para o topo da pilha de avaliação como um tipo `F` (float).
Ldelem_Ref	Carrega o elemento que contém uma referência de objeto em um índice de matriz especificado para o topo da pilha de avaliação como tipo `O` (referência de objeto).
Ldelem_U1	Carrega o elemento com o tipo `unsigned int8` em um índice de matriz especificado para o topo da pilha de avaliação como um `int32`.
Ldelem_U2	Carrega o elemento com o tipo `unsigned int16` em um índice de matriz especificado para o topo da pilha de avaliação como um `int32`.
Ldelem_U4	Carrega o elemento com o tipo `unsigned int32` em um índice de matriz especificado para o topo da pilha de avaliação como um `int32`.
Ldelema	Carrega o endereço do elemento da matriz em um índice de matriz especificado no topo da pilha de avaliação como o tipo `&` (ponteiro gerenciado).
Ldfld	Localiza o valor de um campo no objeto cuja referência está na pilha de avaliação no momento.
Ldflda	Localiza o endereço de um campo no objeto cuja referência está na pilha de avaliação no momento.
Ldftn	Envia um ponteiro não gerenciado (tipo `native int`) para o código nativo implementando um método específico na pilha de avaliação.
Ldind_I	Carrega um valor do tipo `native int` como um `native int` na pilha de avaliação indiretamente.
Ldind_I1	Carrega um valor do tipo `int8` como um `int32` na pilha de avaliação indiretamente.
Ldind_I2	Carrega um valor do tipo `int16` como um `int32` na pilha de avaliação indiretamente.
Ldind_I4	Carrega um valor do tipo `int32` como um `int32` na pilha de avaliação indiretamente.
Ldind_I8	Carrega um valor do tipo `int64` como um `int64` na pilha de avaliação indiretamente.
Ldind_R4	Carrega um valor do tipo `float32` como um tipo `F` (float) para a pilha de avaliação indiretamente.
Ldind_R8	Carrega um valor do tipo `float64` como um tipo `F` (float) para a pilha de avaliação indiretamente.
Ldind_Ref	Carrega uma referência de objeto como um tipo `O` (referência de objeto) para a pilha de avaliação indiretamente.
Ldind_U1	Carrega um valor do tipo `unsigned int8` como um `int32` na pilha de avaliação indiretamente.
Ldind_U2	Carrega um valor do tipo `unsigned int16` como um `int32` na pilha de avaliação indiretamente.
Ldind_U4	Carrega um valor do tipo `unsigned int32` como um `int32` na pilha de avaliação indiretamente.
Ldlen	Efetua o push do número de elementos de uma matriz unidimensional de base zero para a pilha de avaliação.
Ldloc	Carrega a variável local em um índice específico na pilha de avaliação.
Ldloc_0	Carrega a variável local no índice 0 na pilha de avaliação.
Ldloc_1	Carrega a variável local no índice 1 para a pilha de avaliação.
Ldloc_2	Carrega a variável local no índice 2 para a pilha de avaliação.
Ldloc_3	Carrega a variável local no índice 3 para a pilha de avaliação.
Ldloc_S	Carrega a variável local em um índice específico na pilha de avaliação, de forma abreviada.
Ldloca	Carrega o endereço da variável local em um índice específico para a pilha de avaliação.
Ldloca_S	Carrega o endereço da variável local em um índice específico para a pilha de avaliação, em forma abreviada.
Ldnull	Envia uma referência nula (tipo `O`) para a pilha de avaliação.
Ldobj	Copia o objeto de tipo de valor apontado por um endereço na parte superior da pilha de avaliação.
Ldsfld	Envia por push o valor de um campo estático para a pilha de avaliação.
Ldsflda	Efetua o push do endereço de um campo estático para a pilha de avaliação.
Ldstr	Envia por push uma nova referência de objeto para uma literal de cadeia de caracteres armazenada nos metadados.
Ldtoken	Converte um token de metadados em sua representação de runtime, enviando-o por push para a pilha de avaliação.
Ldvirtftn	Efetua o push de um ponteiro não gerenciado (tipo `native int`) para o código nativo implementando um método virtual específico associado ao objeto especificado para a pilha de avaliação.
Leave	Sai de uma região protegida de código, transferindo o controle incondicionalmente para uma instrução de destino específica.
Leave_S	Sai de uma região protegida de código, transferindo o controle incondicionalmente para uma instrução de destino (forma abreviada).
Localloc	Aloca um determinado número de bytes do pool de memória dinâmica local e envia o endereço (um ponteiro transitório, tipo `*`) do primeiro byte alocado à pilha de avaliação.
Mkrefany	Envia uma referência tipada a uma instância de um tipo específico para a pilha de avaliação.
Mul	Multiplica dois valores e efetua o push do resultado na pilha de avaliação.
Mul_Ovf	Multiplica dois valores inteiros, executa uma verificação de estouro e envia por push o resultado na pilha de avaliação.
Mul_Ovf_Un	Multiplica dois valores de inteiro sem sinal, executa uma verificação de estouro e efetua o push do resultado para a pilha de avaliação.
Neg	Nega um valor e efetua o push do resultado para a pilha de avaliação.
Newarr	Envia por push uma referência de objeto para uma nova matriz unidimensional baseada em zero, cujos elementos são de um tipo específico na pilha de avaliação.
Newobj	Cria um novo objeto ou uma nova instância de um tipo de valor, enviando por push uma referência de objeto (tipo `O`) para a pilha de avaliação.
Nop	Preencherá o espaço se os opcodes forem corrigidos. Nenhuma operação significativa será executada, embora um ciclo de processamento possa ser consumido.
Not	Calcula o complemento bit a bit do valor de inteiro na parte superior da pilha e efetua o push o resultado para a pilha de avaliação como o mesmo tipo.
Or	Computa o complemento bit a bit dos dois valores de inteiro na parte superior da pilha e efetua o push do resultado para a pilha de avaliação.
Pop	Remove o valor atualmente no topo da pilha de avaliação.
Prefix1	Esta é uma instrução reservada.
Prefix2	Esta é uma instrução reservada.
Prefix3	Esta é uma instrução reservada.
Prefix4	Esta é uma instrução reservada.
Prefix5	Esta é uma instrução reservada.
Prefix6	Esta é uma instrução reservada.
Prefix7	Esta é uma instrução reservada.
Prefixref	Esta é uma instrução reservada.
Readonly	Especifica que a operação de endereço da matriz subsequente não executa nenhuma verificação de tipo no tempo de execução e que ela retorna um ponteiro gerenciado cuja mutabilidade é restrita.
Refanytype	Recupera o token de tipo inserido em uma referência tipada.
Refanyval	Recupera o endereço (tipo `&`) inserido em uma referência tipada.
Rem	Divide dois valores e efetua o push do restante para a pilha de avaliação.
Rem_Un	Divide dois valores sem sinal e efetua o push do restante para a pilha de avaliação.
Ret	Retorna do método atual, enviando um valor retornado (se houver) da pilha de avaliação do computador chamado para a pilha de avaliação do chamador.
Rethrow	Gera novamente a exceção atual.
Shl	Desloca um valor de inteiro para a esquerda (em zeros) por um número especificado de bits, efetuando o push do resultado para a pilha de avaliação.
Shr	Desloca um valor de inteiro (no logon) para a direita em um número especificado de bits, efetuando o push do resultado para a pilha de avaliação.
Shr_Un	Desloca um valor inteiro sem sinal (em zeros) para a direita em um número especificado de bits, efetuando o push do resultado para a pilha de avaliação.
Sizeof	Envia o tamanho, em bytes, de um tipo de valor fornecido para a pilha de avaliação.
Starg	Armazena o valor localizado no topo da pilha de avaliação no slot de argumento em um índice especificado.
Starg_S	Armazena o valor localizado no topo da pilha de avaliação no slot de argumento em um índice especificado, de forma abreviada.
Stelem	Substitui o elemento de matriz de um índice especificado pelo valor na pilha de avaliação, cujo tipo é especificado na instrução.
Stelem_I	Substitui o elemento de matriz em um determinado índice pelo valor `native int` na pilha de avaliação.
Stelem_I1	Substitui o elemento de matriz em um determinado índice pelo valor `int8` na pilha de avaliação.
Stelem_I2	Substitui o elemento de matriz em um determinado índice pelo valor `int16` na pilha de avaliação.
Stelem_I4	Substitui o elemento de matriz em um determinado índice pelo valor `int32` na pilha de avaliação.
Stelem_I8	Substitui o elemento de matriz em um determinado índice pelo valor `int64` na pilha de avaliação.
Stelem_R4	Substitui o elemento de matriz em um determinado índice pelo valor `float32` na pilha de avaliação.
Stelem_R8	Substitui o elemento de matriz em um determinado índice pelo valor `float64` na pilha de avaliação.
Stelem_Ref	Substitui o elemento da matriz de um determinado índice com o valor de referência de objeto (tipo `O`) na pilha de avaliação.
Stfld	Substitui o valor armazenado no campo de uma referência de objeto ou de um ponteiro por um novo valor.
Stind_I	Armazena um valor do tipo `native int` em um endereço fornecido.
Stind_I1	Armazena um valor do tipo `int8` em um endereço fornecido.
Stind_I2	Armazena um valor do tipo `int16` em um endereço fornecido.
Stind_I4	Armazena um valor do tipo `int32` em um endereço fornecido.
Stind_I8	Armazena um valor do tipo `int64` em um endereço fornecido.
Stind_R4	Armazena um valor do tipo `float32` em um endereço fornecido.
Stind_R8	Armazena um valor do tipo `float64` em um endereço fornecido.
Stind_Ref	Armazena um valor de referência de objeto em um endereço fornecido.
Stloc	Exibe o valor atual na parte superior da pilha de avaliação e o armazena na lista de variáveis locais em um índice especificado.
Stloc_0	Exibe o valor atual da parte superior da pilha de avaliação e o armazena na lista de variáveis locais no índice 0.
Stloc_1	Exibe o valor atual da parte superior da pilha de avaliação e o armazena na lista de variáveis locais no índice 1.
Stloc_2	Exibe o valor atual da parte superior da pilha de avaliação e o armazena na lista de variáveis locais no índice 2.
Stloc_3	Exibe o valor atual da parte superior da pilha de avaliação e o armazena na lista de variáveis locais no índice 3.
Stloc_S	Exibe o valor atual da parte superior da pilha de avaliação e o armazena na lista de variáveis locais em `index` (forma curta).
Stobj	Copia um valor do tipo especificado da pilha de avaliação para um endereço de memória fornecido.
Stsfld	Substitui o valor de um campo estático por um valor da pilha de avaliação.
Sub	Subtrai um valor de outro e efetua o push do resultado para a pilha de avaliação.
Sub_Ovf	Subtrai um valor de inteiro de outro, executa uma verificação de estouro e efetua o push do resultado para a pilha de avaliação.
Sub_Ovf_Un	Subtrai um valor de inteiro sem sinal de outro, executa uma verificação de estouro e efetua o push do resultado para a pilha de avaliação.
Switch	Implementa uma tabela de atalhos.
Tailcall	Executa uma instrução de chamada de método pós-fixada, de modo que o registro de ativação do método atual é removido antes da execução da instrução de chamada real.
Throw	Gera o objeto de exceção atualmente na pilha de avaliação.
Unaligned	Indica que um endereço atualmente sobre a pilha de avaliação pode não estar alinhado ao tamanho natural da instrução imediatamente após `ldind`, `stind`, `ldfld`, `stfld`, `ldobj`, `stobj`, `initblk` ou `cpblk`.
Unbox	Converte a representação demarcada de um tipo de valor em sua forma não marcada.
Unbox_Any	Converte a representação demarcada de um tipo especificado na instrução em sua forma não demarcada.
Volatile	Especifica que um endereço atualmente sobre a pilha de avaliação pode ser volátil e os resultados da leitura daquele local não podem ser armazenados em cache ou não é possível suprimir vários repositórios para esse local.
Xor	Calcula o XOR bit a bit dos dois valores superiores na pilha de avaliação, efetuando o push do resultado para a pilha de avaliação.

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
TakesSingleByteArgument(OpCode)	Retornará true ou false se o código de operação fornecido tiver um argumento de byte único.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Aplica-se a

Partilhar via