OpCodes.TakesSingleByteArgument(OpCode) Methode

Definition

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Primitives.dll

Quelle:

OpCodes.cs

Gibt TRUE oder FALSE zurück, wenn der bereitgestellte Opcode ein Einzelbyte-Argument akzeptiert.

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

Parameter

inst

OpCode

Eine Instanz eines eines Opcodeobjekts.

Gibt zurück

Boolean

true oder false.

Hinweise

Diese Methode kann verwendet werden, um zu ermitteln, welche MSIL-Opcodes "Kurzform" für die Verwendung in optimiertem Code sind.

TakesSingleByteArgumentgibt zurücktrue, wenn die OpCode instance in den folgenden Fällen ein einzelnes Byteargument akzeptiert:

• Der Opcode führt eine Branch-Anweisung an eine Byteadresse aus (z. B Br_S . und Bgt_S).

• Der Opcode pusht einen Bytewert auf den Stapel (z. B Ldc_I4_S. ).

• Der Opcode verweist auf eine Variable oder ein Argument über die bytegroße "Kurzform" (z. B. Ldloc_S und Stloc_S).

Andernfalls wird falsezurückgegeben.

Im folgenden Beispiel wird die Verwendung von TakesSingleByteArgument veranschaulicht, indem die -Klasse berücksichtigt OpCodes und getestet wird, ob jedes OpCode Feld ein Ein-Byte-Argument verwendet.

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