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

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