OpCodes Sınıf

Başvuru

Tanım

Ad Alanı:: System.Reflection.Emit

Bütünleştirilmiş Kod:: System.Reflection.Primitives.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Kaynak:: OpCodes.cs

Kaynak:: OpCodes.cs

Kaynak:: OpCodes.cs

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Sınıf üyeleri (gibiEmit(OpCode)) tarafından emisyon için Microsoft Ara Dil (MSIL) yönergelerinin ILGenerator alan temsillerini sağlar.

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

Devralma: Object
OpCodes

Öznitelikler: ComVisibleAttribute

Örnekler

Aşağıdaki örnekte, içine yaymak için kullanan ILGenerator dinamik bir yöntemin oluşturulması gösterilmektedirMethodBuilder.OpCodes

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

Açıklamalar

Üye opcode'larının ayrıntılı bir açıklaması için Ortak Dil Altyapısı (CLI) belgelerine, özellikle de "Bölüm III: CIL Yönerge Kümesi" ve "Bölüm II: Meta Veri Tanımı ve Semantiği" belgelerine bakın. Daha fazla bilgi için bkz. ECMA 335 Ortak Dil Altyapısı (CLI).

Alanlar

Add	İki değer ekler ve sonucu değerlendirme yığınına iletir.
Add_Ovf	İki tamsayı ekler, taşma denetimi gerçekleştirir ve sonucu değerlendirme yığınına iletir.
Add_Ovf_Un	İki işaretsiz tamsayı değeri ekler, taşma denetimi gerçekleştirir ve sonucu değerlendirme yığınına iletir.
And	İki değerin bit tabanlı AND değerini hesaplar ve sonucu değerlendirme yığınına iletir.
Arglist	Geçerli yöntemin bağımsız değişken listesine yönetilmeyen bir işaretçi döndürür.
Beq	İki değer eşitse aktarımlar bir hedef yönergeye denetim sağlar.
Beq_S	İki değer eşitse denetimi bir hedef yönergeye (kısa form) aktarır.
Bge	İlk değer ikinci değerden büyük veya buna eşitse denetimi hedef yönergeye aktarır.
Bge_S	İlk değer ikinci değerden büyük veya buna eşitse denetimi bir hedef yönergeye (kısa form) aktarır.
Bge_Un	İlk değer ikinci değerden büyükse, işaretsiz tamsayı değerlerini veya sıralanmamış kayan değerleri karşılaştırırken denetimi hedef yönergeye aktarır.
Bge_Un_S	İmzasız tamsayı değerleri veya sıralanmamış kayan değerler karşılaştırılırken, ilk değer ikinci değerden büyükse denetimi hedef yönergeye (kısa form) aktarır.
Bgt	İlk değer ikinci değerden büyükse denetimi hedef yönergeye aktarır.
Bgt_S	İlk değer ikinci değerden büyükse denetimi bir hedef yönergeye (kısa form) aktarır.
Bgt_Un	İlk değer ikinci değerden büyükse, işaretsiz tamsayı değerlerini veya sıralanmamış kayan değerleri karşılaştırırken denetimi hedef yönergeye aktarır.
Bgt_Un_S	İmzasız tamsayı değerleri veya sıralanmamış kayan değerler karşılaştırılırken, ilk değer ikinci değerden büyükse denetimi hedef yönergeye (kısa form) aktarır.
Ble	İlk değer ikinci değerden küçük veya buna eşitse denetimi hedef yönergeye aktarır.
Ble_S	İlk değer ikinci değerden küçük veya buna eşitse denetimi bir hedef yönergeye (kısa form) aktarır.
Ble_Un	İmzasız tamsayı değerleri veya sıralanmamış float değerleri karşılaştırılırken, ilk değer ikinci değerden küçük veya buna eşitse denetimi hedef yönergeye aktarır.
Ble_Un_S	İmzasız tamsayı değerlerini veya sıralanmamış float değerlerini karşılaştırırken, ilk değer ikinci değerden küçük veya buna eşitse denetimi hedef yönergeye (kısa form) aktarır.
Blt	İlk değer ikinci değerden küçükse denetimi hedef yönergeye aktarır.
Blt_S	İlk değer ikinci değerden küçükse denetimi bir hedef yönergeye (kısa form) aktarır.
Blt_Un	İşaretsiz tamsayı değerleri veya sıralanmamış float değerleri karşılaştırılırken, ilk değer ikinci değerden küçükse denetimi hedef yönergeye aktarır.
Blt_Un_S	İmzasız tamsayı değerleri veya sıralanmamış float değerleri karşılaştırılırken, ilk değer ikinci değerden küçükse denetimi hedef yönergeye (kısa form) aktarır.
Bne_Un	İki işaretsiz tamsayı değeri veya sıralanmamış kayan değer eşit olmadığında denetimi hedef yönergeye aktarır.
Bne_Un_S	İki işaretsiz tamsayı değeri veya sıralanmamış kayan değer eşit olmadığında denetimi bir hedef yönergeye (kısa form) aktarır.
Box	Bir değer türünü nesne başvurusuna dönüştürür (tür `O`).
Br	Denetimi koşulsuz olarak bir hedef yönergeye aktarır.
Br_S	Denetimi koşulsuz olarak bir hedef yönergeye (kısa form) aktarır.
Break	Hata ayıklayıcıya bir kesme noktasının atlandığını bildirmek için Ortak Dil Altyapısı'na (CLI) sinyal gönderir.
Brfalse	Denetimi, null başvuru (`Nothing`Visual Basic'te) veya sıfır olduğunda `valuefalse`hedef yönergeye aktarır.
Brfalse_S	Denetimi, null başvuru veya sıfır ise `valuefalse`hedef yönergeye aktarır.
Brtrue	Denetimi null veya sıfır olmayan bir hedef yönergeye `valuetrue`aktarır.
Brtrue_S	Denetimi null veya sıfır olmayan bir hedef yönergeye (kısa form) `valuetrue`aktarır.
Call	Geçirilen yöntem tanımlayıcısı tarafından belirtilen yöntemini çağırır.
Calli	Bir çağırma kuralı tarafından açıklanan bağımsız değişkenlerle değerlendirme yığınında belirtilen yöntemini (bir giriş noktasının işaretçisi olarak) çağırır.
Callvirt	Dönüş değerini değerlendirme yığınına göndererek bir nesnede geç bağlanan bir yöntemi çağırır.
Castclass	Belirtilen sınıfa başvuruyla geçirilen bir nesneyi atamaya çalışır.
Ceq	İki değeri karşılaştırır. Eşitse, 1 `(int32`) tamsayı değeri değerlendirme yığınına gönderilir; aksi takdirde değerlendirme yığınına 0 (`int32`) gönderilir.
Cgt	İki değeri karşılaştırır. İlk değer ikinciden büyükse, 1 `(int32`) tamsayı değeri değerlendirme yığınına gönderilir; aksi takdirde değerlendirme yığınına 0 (`int32`) gönderilir.
Cgt_Un	İmzalanmamış veya sıralanmamış iki değeri karşılaştırır. İlk değer ikinciden büyükse, 1 `(int32`) tamsayı değeri değerlendirme yığınına gönderilir; aksi takdirde değerlendirme yığınına 0 (`int32`) gönderilir.
Ckfinite	ArithmeticException Değer sınırlı bir sayı değilse oluşturur.
Clt	İki değeri karşılaştırır. İlk değer ikinciden küçükse, 1 `(int32`) tamsayı değeri değerlendirme yığınına gönderilir; aksi takdirde değerlendirme yığınına 0 (`int32`) gönderilir.
Clt_Un	ve işaretsiz veya sıralanmamış değerleri karşılaştırır `value1value2`. değerinden küçükse`value1`, 1 `(int32`) tamsayı değeri değerlendirme yığınına gönderilir; aksi takdirde değerlendirme yığınına 0 (`int32`) `value2`gönderilir.
Constrained	Sanal yöntem çağrısının yapıldığı türü kısıtlar.
Conv_I	Değerlendirme yığınının üstündeki değeri değerine `native int`dönüştürür.
Conv_I1	Değerlendirme yığınının üstündeki değeri değerine `int8`dönüştürür, sonra da değerine `int32`genişletir (tuş takımı) .
Conv_I2	Değerlendirme yığınının üstündeki değeri değerine `int16`dönüştürür, sonra da değerine `int32`genişletir (tuş takımı) .
Conv_I4	Değerlendirme yığınının üstündeki değeri değerine `int32`dönüştürür.
Conv_I8	Değerlendirme yığınının üstündeki değeri değerine `int64`dönüştürür.
Conv_Ovf_I	Değerlendirme yığınının üstündeki imzalı değeri, taşmada OverflowException oluşturan imzalı `native int`değerine dönüştürür.
Conv_Ovf_I_Un	Değerlendirme yığınının üstündeki imzasız değeri, taşma üzerine atarak OverflowException imzalı `native int`değerine dönüştürür.
Conv_Ovf_I1	Değerlendirme yığınının üstündeki imzalı değeri imzalı `int8` değerine dönüştürür ve taşma üzerine atarak OverflowException değerine genişletir`int32`.
Conv_Ovf_I1_Un	Değerlendirme yığınının üstündeki imzasız değeri imzalı `int8` değerine dönüştürür ve taşma üzerine atarak OverflowException değerine `int32`genişletir.
Conv_Ovf_I2	Değerlendirme yığınının üstündeki imzalı değeri imzalı `int16` değerine dönüştürür ve taşmaya neden olarak OverflowException değerine `int32`genişletir.
Conv_Ovf_I2_Un	Değerlendirme yığınının üstündeki imzasız değeri imzalı `int16` değerine dönüştürür ve taşma üzerine atarak OverflowException değerine `int32`genişletir.
Conv_Ovf_I4	Değerlendirme yığınının üstündeki imzalı değeri, taşmada OverflowException oluşturan imzalı `int32`değerine dönüştürür.
Conv_Ovf_I4_Un	Değerlendirme yığınının üstündeki imzasız değeri, taşma üzerine atarak OverflowException imzalı `int32`değerine dönüştürür.
Conv_Ovf_I8	Değerlendirme yığınının üstündeki imzalı değeri, taşmada OverflowException oluşturan imzalı `int64`değerine dönüştürür.
Conv_Ovf_I8_Un	Değerlendirme yığınının üstündeki imzasız değeri, taşma üzerine atarak OverflowException imzalı `int64`değerine dönüştürür.
Conv_Ovf_U	Değerlendirme yığınının `unsigned native int`üstündeki imzalı değeri taşma OverflowException üzerine oluşturan değerine dönüştürür.
Conv_Ovf_U_Un	Değerlendirme yığınının `unsigned native int`üstündeki imzasız değeri taşma üzerine atarak OverflowException değerine dönüştürür.
Conv_Ovf_U1	Değerlendirme yığınının üstündeki imzalı değeri değerine `unsigned int8` dönüştürür ve taşma üzerine atarak OverflowException değerine `int32`genişletir.
Conv_Ovf_U1_Un	Değerlendirme yığınının `unsigned int8` üstündeki imzasız değeri değerine dönüştürür ve taşmaya neden olarak OverflowException değerine genişletir`int32`.
Conv_Ovf_U2	Değerlendirme yığınının üstündeki imzalı değeri değerine `unsigned int16` dönüştürür ve taşma üzerine atarak OverflowException değerine `int32`genişletir.
Conv_Ovf_U2_Un	Değerlendirme yığınının `unsigned int16` üstündeki imzasız değeri değerine dönüştürür ve taşmaya neden olarak OverflowException değerine genişletir`int32`.
Conv_Ovf_U4	Değerlendirme yığınının `unsigned int32`üstündeki imzalı değeri taşma OverflowException üzerine oluşturan değerine dönüştürür.
Conv_Ovf_U4_Un	Değerlendirme yığınının `unsigned int32`üstündeki imzasız değeri taşma üzerine atarak OverflowException değerine dönüştürür.
Conv_Ovf_U8	Değerlendirme yığınının `unsigned int64`üstündeki imzalı değeri taşma OverflowException üzerine oluşturan değerine dönüştürür.
Conv_Ovf_U8_Un	Değerlendirme yığınının `unsigned int64`üstündeki imzasız değeri taşma üzerine atarak OverflowException değerine dönüştürür.
Conv_R_Un	Değerlendirme yığınının üstündeki işaretsiz tamsayı değerini değerine `float32`dönüştürür.
Conv_R4	Değerlendirme yığınının üstündeki değeri değerine `float32`dönüştürür.
Conv_R8	Değerlendirme yığınının üstündeki değeri değerine `float64`dönüştürür.
Conv_U	Değerlendirme yığınının üstündeki değeri değerine `unsigned native int`dönüştürür ve değerine `native int`genişletir.
Conv_U1	Değerlendirme yığınının üstündeki değeri değerine `unsigned int8`dönüştürür ve değerine `int32`genişletir.
Conv_U2	Değerlendirme yığınının üstündeki değeri değerine `unsigned int16`dönüştürür ve değerine `int32`genişletir.
Conv_U4	Değerlendirme yığınının üstündeki değeri değerine `unsigned int32`dönüştürür ve değerine `int32`genişletir.
Conv_U8	Değerlendirme yığınının üstündeki değeri değerine `unsigned int64`dönüştürür ve değerine `int64`genişletir.
Cpblk	Belirtilen sayı baytlarını bir kaynak adresten hedef adrese kopyalar.
Cpobj	Bir nesnenin adresinde (, `&`veya ) bulunan değer türünü hedef nesnenin adresine (, veya `native intnative int`) `&`kopyalar.
Div	İki değeri böler ve sonucu değerlendirme yığınına kayan nokta (tür `F`) veya bölüm (tür `int32`) olarak iter.
Div_Un	İki işaretsiz tamsayı değerini böler ve sonucu (`int32`) değerlendirme yığınına iter.
Dup	Değerlendirme yığınındaki en üstteki geçerli değeri kopyalar ve sonra kopyayı değerlendirme yığınına iletir.
Endfilter	Denetimi bir özel durumun yan tümcesinden `filter` Common Language Infrastructure (CLI) özel durum işleyicisine geri aktarır.
Endfinally	Denetimi bir özel durum bloğunun `fault` veya `finally` yan tümcesinden Common Language Infrastructure (CLI) özel durum işleyicisine geri aktarır.
Initblk	Belirli bir adreste belirtilen bellek bloğunu belirli bir boyuta ve başlangıç değerine başlatır.
Initobj	Belirtilen adreste değer türünün her alanını null başvuruya veya uygun ilkel türden 0'a başlatır.
Isinst	Nesne başvurusunun (tür `O`) belirli bir sınıfın örneği olup olmadığını sınar.
Jmp	Geçerli yöntemden çıkar ve belirtilen yönteme atlar.
Ldarg	Bir bağımsız değişkeni (belirtilen dizin değeri tarafından başvurulur) yığına yükler.
Ldarg_0	0 dizinindeki bağımsız değişkeni değerlendirme yığınına yükler.
Ldarg_1	1. dizindeki bağımsız değişkeni değerlendirme yığınına yükler.
Ldarg_2	2. dizindeki bağımsız değişkeni değerlendirme yığınına yükler.
Ldarg_3	3. dizindeki bağımsız değişkeni değerlendirme yığınına yükler.
Ldarg_S	Bağımsız değişkeni (belirtilen kısa form dizini tarafından başvurulur) değerlendirme yığınına yükler.
Ldarga	Değerlendirme yığınına bir bağımsız değişken adresi yükleyin.
Ldarga_S	Değerlendirme yığınına kısa biçimde bir bağımsız değişken adresi yükleyin.
Ldc_I4	Değerlendirme yığınına türüyle `int32` sağlanan bir değeri olarak `int32`iter.
Ldc_I4_0	0 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_1	1 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_2	2 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_3	3 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_4	4 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_5	5 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_6	6 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_7	7 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_8	8 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_M1	-1 tamsayı değerini değerlendirme yığınına olarak `int32`iter.
Ldc_I4_S	Sağlanan `int8` değeri değerlendirme yığınına bir `int32`, kısa biçimi olarak iter.
Ldc_I8	Değerlendirme yığınına türüyle `int64` sağlanan bir değeri olarak `int64`iter.
Ldc_R4	Sağlanan tür değerini değerlendirme `float32` yığınına tür `F` (float) olarak iter.
Ldc_R8	Sağlanan tür değerini değerlendirme `float64` yığınına tür `F` (float) olarak iter.
Ldelem	Belirtilen dizi dizinindeki öğesini, yönergede belirtilen tür olarak değerlendirme yığınının en üstüne yükler.
Ldelem_I	Belirtilen dizi dizinindeki türüne `native int` sahip öğesini değerlendirme yığınının en üstüne olarak `native int`yükler.
Ldelem_I1	Belirtilen dizi dizinindeki türüne `int8` sahip öğesini değerlendirme yığınının en üstüne olarak `int32`yükler.
Ldelem_I2	Belirtilen dizi dizinindeki türüne `int16` sahip öğesini değerlendirme yığınının en üstüne olarak `int32`yükler.
Ldelem_I4	Belirtilen dizi dizinindeki türüne `int32` sahip öğesini değerlendirme yığınının en üstüne olarak `int32`yükler.
Ldelem_I8	Belirtilen dizi dizinindeki türüne `int64` sahip öğesini değerlendirme yığınının en üstüne olarak `int64`yükler.
Ldelem_R4	Belirtilen dizi dizinindeki türe `float32` sahip öğesini değerlendirme yığınının en üstüne tür `F` (float) olarak yükler.
Ldelem_R8	Belirtilen dizi dizinindeki türe `float64` sahip öğesini değerlendirme yığınının en üstüne tür `F` (float) olarak yükler.
Ldelem_Ref	Belirtilen dizi dizininde nesne başvurusu içeren öğeyi değerlendirme yığınının üst kısmına tür `O` (nesne başvurusu) yükler.
Ldelem_U1	Belirtilen dizi dizinindeki türüne `unsigned int8` sahip öğesini değerlendirme yığınının en üstüne olarak `int32`yükler.
Ldelem_U2	Belirtilen dizi dizinindeki türüne `unsigned int16` sahip öğesini değerlendirme yığınının en üstüne olarak `int32`yükler.
Ldelem_U4	Belirtilen dizi dizinindeki türüne `unsigned int32` sahip öğesini değerlendirme yığınının en üstüne olarak `int32`yükler.
Ldelema	Belirtilen dizi dizinindeki dizi öğesinin adresini değerlendirme yığınının üst kısmına tür `&` (yönetilen işaretçi) olarak yükler.
Ldfld	Başvurusu şu anda değerlendirme yığınında olan nesnedeki bir alanın değerini bulur.
Ldflda	Başvurusu şu anda değerlendirme yığınında olan nesnedeki bir alanın adresini bulur.
Ldftn	Değerlendirme yığınına belirli bir yöntem uygulayan yerel koda yönetilmeyen bir işaretçi (tür `native int`) iter.
Ldind_I	Değerlendirme yığınına türündeki `native int` bir `native int` değeri dolaylı olarak yükler.
Ldind_I1	Değerlendirme yığınına türündeki `int8` bir `int32` değeri dolaylı olarak yükler.
Ldind_I2	Değerlendirme yığınına türündeki `int16` bir `int32` değeri dolaylı olarak yükler.
Ldind_I4	Değerlendirme yığınına türündeki `int32` bir `int32` değeri dolaylı olarak yükler.
Ldind_I8	Değerlendirme yığınına türündeki `int64` bir `int64` değeri dolaylı olarak yükler.
Ldind_R4	Tür (float) türünde bir `F` değeri `float32` dolaylı olarak değerlendirme yığınına yükler.
Ldind_R8	Tür (float) türünde bir `F` değeri `float64` dolaylı olarak değerlendirme yığınına yükler.
Ldind_Ref	Bir nesne başvuruyu tür `O` (nesne başvurusu) olarak değerlendirme yığınına dolaylı olarak yükler.
Ldind_U1	Değerlendirme yığınına türündeki `unsigned int8` bir `int32` değeri dolaylı olarak yükler.
Ldind_U2	Değerlendirme yığınına türündeki `unsigned int16` bir `int32` değeri dolaylı olarak yükler.
Ldind_U4	Değerlendirme yığınına türündeki `unsigned int32` bir `int32` değeri dolaylı olarak yükler.
Ldlen	Sıfır tabanlı, tek boyutlu bir dizinin öğe sayısını değerlendirme yığınına iter.
Ldloc	Belirli bir dizindeki yerel değişkeni değerlendirme yığınına yükler.
Ldloc_0	0 dizinindeki yerel değişkeni değerlendirme yığınına yükler.
Ldloc_1	1. dizindeki yerel değişkeni değerlendirme yığınına yükler.
Ldloc_2	2. dizindeki yerel değişkeni değerlendirme yığınına yükler.
Ldloc_3	3. dizindeki yerel değişkeni değerlendirme yığınına yükler.
Ldloc_S	Belirli bir dizindeki yerel değişkeni kısa biçimde değerlendirme yığınına yükler.
Ldloca	Belirli bir dizindeki yerel değişkenin adresini değerlendirme yığınına yükler.
Ldloca_S	Belirli bir dizindeki yerel değişkenin adresini değerlendirme yığınına (kısa biçimde) yükler.
Ldnull	Değerlendirme yığınına null başvuru (tür `O`) iter.
Ldobj	Bir adres tarafından işaret edilen değer türü nesnesini değerlendirme yığınının en üstüne kopyalar.
Ldsfld	Statik alanın değerini değerlendirme yığınına iletir.
Ldsflda	Statik alanın adresini değerlendirme yığınına iletir.
Ldstr	Meta verilerde depolanan bir dize değişmez değerine yeni bir nesne başvurusu gönderir.
Ldtoken	Meta veri belirtecini çalışma zamanı gösterimine dönüştürerek değerlendirme yığınına gönderir.
Ldvirtftn	Belirli bir nesneyle ilişkili belirli bir sanal yöntemi uygulayan yerel koda, değerlendirme yığınına yönetilmeyen bir işaretçi (tür `native int`) iter.
Leave	Korumalı bir kod bölgesinden çıkar ve denetimi koşulsuz olarak belirli bir hedef yönergeye aktarır.
Leave_S	Korumalı bir kod bölgesinden çıkar ve denetimi koşulsuz olarak bir hedef yönergeye (kısa form) aktarır.
Localloc	Yerel dinamik bellek havuzundan belirli sayıda bayt ayırır ve ilk ayrılan bayt değerinin adresini (geçici bir işaretçi, tür `*`) değerlendirme yığınına yönlendirir.
Mkrefany	Belirli bir türün örneğine yazılan başvuruyu değerlendirme yığınına iletir.
Mul	İki değeri çarpar ve sonucu değerlendirme yığınına iletir.
Mul_Ovf	İki tamsayı değerini çarpar, taşma denetimi gerçekleştirir ve sonucu değerlendirme yığınına iter.
Mul_Ovf_Un	İki işaretsiz tamsayı değerini çarpar, taşma denetimi gerçekleştirir ve sonucu değerlendirme yığınına iter.
Neg	Bir değeri olumsuzlar ve sonucu değerlendirme yığınına iter.
Newarr	Öğeleri belirli bir türdeki yeni sıfır tabanlı, tek boyutlu bir diziye nesne başvurularını değerlendirme yığınına iletir.
Newobj	Değerlendirme yığınına bir nesne başvurusu (tür `O`) göndererek yeni bir nesne veya değer türünün yeni bir örneğini oluşturur.
Nop	İşlem kodlarına düzeltme eki ekliyse alanı doldurur. İşleme döngüsü kullanılabilir olsa da anlamlı bir işlem gerçekleştirilmez.
Not	Yığının üstündeki tamsayı değerinin bit düzeyinde tamamlayıcısını hesaplar ve sonucu aynı türdeki değerlendirme yığınına iletir.
Or	Yığının üstündeki iki tamsayı değerinin bit düzeyinde tamamlayıcısını hesaplayıp sonucu değerlendirme yığınına iletir.
Pop	Değerlendirme yığınının üzerinde bulunan değeri kaldırır.
Prefix1	Bu ayrılmış bir yönergedir.
Prefix2	Bu ayrılmış bir yönergedir.
Prefix3	Bu ayrılmış bir yönergedir.
Prefix4	Bu ayrılmış bir yönergedir.
Prefix5	Bu ayrılmış bir yönergedir.
Prefix6	Bu ayrılmış bir yönergedir.
Prefix7	Bu ayrılmış bir yönergedir.
Prefixref	Bu ayrılmış bir yönergedir.
Readonly	Sonraki dizi adresi işleminin çalışma zamanında hiçbir tür denetimi gerçekleştirmediğini ve sessizliği kısıtlanmış bir yönetilen işaretçi döndürdüğünü belirtir.
Refanytype	Yazılan başvuruya katıştırılmış tür belirtecini alır.
Refanyval	Yazılan başvuruya eklenmiş olan adresi (tür `&`) alır.
Rem	İki değeri böler ve kalanı değerlendirme yığınına iter.
Rem_Un	İki imzasız değeri böler ve kalanları değerlendirme yığınına iter.
Ret	Çağıranın değerlendirme yığınından çağıranın değerlendirme yığınına bir dönüş değeri (varsa) göndererek geçerli yöntemden döndürür.
Rethrow	Geçerli özel durumu yeniden oluşturur.
Shl	Bir tamsayı değerini belirtilen sayıda bitle sola (sıfır cinsinden) kaydırarak sonucu değerlendirme yığınına iletir.
Shr	Bir tamsayı değerini (in sign) belirtilen sayıda bit sağa kaydırarak sonucu değerlendirme yığınına iletir.
Shr_Un	İşaretsiz bir tamsayı değerini (sıfır cinsinden) belirtilen sayıda bit sağa kaydırarak sonucu değerlendirme yığınına iletir.
Sizeof	Sağlanan değer türünün bayt cinsinden boyutunu değerlendirme yığınına iletir.
Starg	Değeri, belirtilen dizindeki bağımsız değişken yuvasında değerlendirme yığınının üzerinde depolar.
Starg_S	Değeri, bağımsız değişken yuvasındaki değerlendirme yığınının en üstünde belirtilen dizinde, kısa biçimde depolar.
Stelem	Belirli bir dizindeki dizi öğesini, türü yönergede belirtilen değerlendirme yığınındaki değerle değiştirir.
Stelem_I	Belirli bir dizindeki dizi öğesini değerlendirme yığınındaki `native int` değerle değiştirir.
Stelem_I1	Belirli bir dizindeki dizi öğesini değerlendirme yığınındaki `int8` değerle değiştirir.
Stelem_I2	Belirli bir dizindeki dizi öğesini değerlendirme yığınındaki `int16` değerle değiştirir.
Stelem_I4	Belirli bir dizindeki dizi öğesini değerlendirme yığınındaki `int32` değerle değiştirir.
Stelem_I8	Belirli bir dizindeki dizi öğesini değerlendirme yığınındaki `int64` değerle değiştirir.
Stelem_R4	Belirli bir dizindeki dizi öğesini değerlendirme yığınındaki `float32` değerle değiştirir.
Stelem_R8	Belirli bir dizindeki dizi öğesini değerlendirme yığınındaki `float64` değerle değiştirir.
Stelem_Ref	Belirli bir dizindeki dizi öğesini değerlendirme yığınındaki nesne başvuru değeriyle (tür `O`) değiştirir.
Stfld	Nesne başvurusu veya işaretçisi alanında depolanan değeri yeni bir değerle değiştirir.
Stind_I	Sağlanan adreste türündeki `native int` bir değeri depolar.
Stind_I1	Sağlanan adreste türündeki `int8` bir değeri depolar.
Stind_I2	Sağlanan adreste türündeki `int16` bir değeri depolar.
Stind_I4	Sağlanan adreste türündeki `int32` bir değeri depolar.
Stind_I8	Sağlanan adreste türündeki `int64` bir değeri depolar.
Stind_R4	Sağlanan adreste türündeki `float32` bir değeri depolar.
Stind_R8	Sağlanan adreste türündeki `float64` bir değeri depolar.
Stind_Ref	Bir nesne başvuru değerini sağlanan adreste depolar.
Stloc	Geçerli değeri değerlendirme yığınının en üstünden açar ve belirtilen dizindeki yerel değişken listesinde depolar.
Stloc_0	Geçerli değeri değerlendirme yığınının en üstünden açar ve dizin 0'daki yerel değişken listesinde depolar.
Stloc_1	Geçerli değeri değerlendirme yığınının en üstünden açar ve dizin 1'deki yerel değişken listesinde depolar.
Stloc_2	Geçerli değeri değerlendirme yığınının en üstünden açar ve dizin 2'deki yerel değişken listesinde depolar.
Stloc_3	Geçerli değeri değerlendirme yığınının en üstünden açar ve dizin 3'teki yerel değişken listesinde depolar.
Stloc_S	Geçerli değeri değerlendirme yığınının en üstünden açar ve yerel değişken listesinde `index` (kısa form) depolar.
Stobj	Belirtilen türdeki bir değeri değerlendirme yığınından sağlanan bellek adresine kopyalar.
Stsfld	Statik alanın değerini değerlendirme yığınındaki bir değerle değiştirir.
Sub	Bir değeri diğerinden çıkarır ve sonucu değerlendirme yığınına iletir.
Sub_Ovf	Bir tamsayı değerini diğerinden çıkarır, taşma denetimi gerçekleştirir ve sonucu değerlendirme yığınına iter.
Sub_Ovf_Un	İmzalanmamış bir tamsayı değerini diğerinden çıkarır, taşma denetimi gerçekleştirir ve sonucu değerlendirme yığınına iletir.
Switch	Atlama tablosu uygular.
Tailcall	Gerçek çağrı yönergesi yürütülmeden önce geçerli yöntemin yığın çerçevesinin kaldırılmasını sağlayan sonekli bir yöntem çağrısı yönergesi gerçekleştirir.
Throw	Değerlendirme yığınında şu anda özel durum nesnesini oluşturur.
Unaligned	Değerlendirme yığınının üzerinde bulunan bir adresin hemen sonra `ldind`gelen , , `stind`, `ldfld`, `stfld`, `ldobj`, `stobj`, , `initblk`veya `cpblk` yönergesinin doğal boyutuyla hizalanmayabileceğini gösterir.
Unbox	Bir değer türünün kutulu gösterimini kutulanmamış biçimine dönüştürür.
Unbox_Any	Yönergede belirtilen bir türün kutulu gösterimini kutulanmamış formuna dönüştürür.
Volatile	Değerlendirme yığınının üzerinde bulunan bir adresin geçici olabileceğini ve bu konumu okumanın sonuçlarının önbelleğe alınamayacağını veya bu konuma birden çok deponun gizlenemeyeceğini belirtir.
Xor	Değerlendirme yığınındaki ilk iki değerin bit düzeyinde XOR değerini hesaplayarak sonucu değerlendirme yığınına iletir.

Yöntemler

Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
TakesSingleByteArgument(OpCode)	Sağlanan işlem kodu tek bir bayt bağımsız değişkeni alırsa true veya false döndürür.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)

Şunlara uygulanır

Aracılığıyla paylaş