OpCodes.TakesSingleByteArgument(OpCode) Yöntem

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kod:

System.Reflection.Primitives.dll

Kaynak:

OpCodes.cs

Sağlanan işlem kodu tek bir bayt bağımsız değişkeni alırsa true veya false döndürür.

public:
 static bool TakesSingleByteArgument(System::Reflection::Emit::OpCode inst);

public static bool TakesSingleByteArgument (System.Reflection.Emit.OpCode inst);

static member TakesSingleByteArgument : System.Reflection.Emit.OpCode -> bool

Public Shared Function TakesSingleByteArgument (inst As OpCode) As Boolean

Parametreler

inst

OpCode

Opcode nesnesinin bir örneği.

Döndürülenler

Boolean

true veya false.

Açıklamalar

Bu yöntem, iyileştirilmiş kodda kullanılmak üzere hangi MSIL işlem kodlarının "kısa form" olduğunu bulmak için kullanılabilir.

TakesSingleByteArgumentaşağıdaki durumlarda örnek tek bir bayt bağımsız değişkeni alırsa OpCode döndürürtrue:

• İşlem kodu, bayt boyutunda bir adrese (örneğin ve Br_SBgt_S) dal yönergesi gerçekleştirir.

• İşlem kodu yığına bir bayt değeri (örneğin, Ldc_I4_S) iletir.

• İşlem kodu bayt boyutlu "kısa form" (örneğin, Ldloc_S ve Stloc_S) aracılığıyla bir değişkene veya bağımsız değişkene başvurur.

Aksi takdirde döndürür false.

Aşağıdaki örnekte, sınıfına yansıtılarak ve her OpCode alanın tek baytlık bir bağımsız değişken alıp almadığını görmek için test edilerek OpCodes kullanımı TakesSingleByteArgument gösterilmektedir.

int main()
{
   
   // We need a blank OpCode Object for reference when calling FieldInfo::GetValue().
   OpCode blankOpCode;
   Type^ myOpCodesType = Type::GetType( "System.Reflection.Emit.OpCodes" );
   array<FieldInfo^>^listOfOpCodes = myOpCodesType->GetFields();
   Console::WriteLine( "Which OpCodes take single-Byte arguments?" );
   Console::WriteLine( "-----------------------------------------" );
   
   // Now, let's reflect on each FieldInfo and create an instance of the OpCode it represents.
   System::Collections::IEnumerator^ myEnum = listOfOpCodes->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      FieldInfo^ opCodeFI = safe_cast<FieldInfo^>(myEnum->Current);
      Object^ theOpCode = opCodeFI->GetValue( blankOpCode );
      Console::WriteLine( " {0}: {1}", opCodeFI->Name, OpCodes::TakesSingleByteArgument(  *dynamic_cast<OpCode^>(theOpCode) ) );
   }
}

public static void Main()
{
   // We need a blank OpCode object for reference when calling FieldInfo.GetValue().

   OpCode blankOpCode = new OpCode();

   Type myOpCodesType = Type.GetType("System.Reflection.Emit.OpCodes");
   FieldInfo[] listOfOpCodes = myOpCodesType.GetFields();

   Console.WriteLine("Which OpCodes take single-byte arguments?");
   Console.WriteLine("-----------------------------------------");

   // Now, let's reflect on each FieldInfo and create an instance of the OpCode it represents.

   foreach (FieldInfo opCodeFI in listOfOpCodes)
   {
    object theOpCode = opCodeFI.GetValue(blankOpCode);
    
    Console.WriteLine("{0}: {1}", opCodeFI.Name,
              OpCodes.TakesSingleByteArgument((OpCode)theOpCode).ToString());
   }
}

Public Shared Sub Main()

   ' We need a blank OpCode object for reference when calling FieldInfo.GetValue().

   Dim blankOpCode As New OpCode()
   
   Dim myOpCodesType As Type = Type.GetType("System.Reflection.Emit.OpCodes")
   Dim listOfOpCodes As FieldInfo() = myOpCodesType.GetFields()
   
   Console.WriteLine("Which OpCodes take single-byte arguments?")
   Console.WriteLine("-----------------------------------------")
   
   ' Now, let's reflect on each FieldInfo and create an instance of the OpCode it represents.
   Dim opCodeFI As FieldInfo
   For Each opCodeFI In  listOfOpCodes
      Dim theOpCode As Object = opCodeFI.GetValue(blankOpCode)
      
      Console.WriteLine("{0}: {1}", opCodeFI.Name, _
            OpCodes.TakesSingleByteArgument(CType(theOpCode, OpCode)).ToString())
   Next opCodeFI

End Sub