OpCodes.TakesSingleByteArgument(OpCode) Méthode

Définition

Espace de noms:

System.Reflection.Emit

Assembly:

System.Reflection.Primitives.dll

Source:

OpCodes.cs

Retourne true ou false si l’opcode fourni utilise un argument à octet unique.

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

Paramètres

inst

OpCode

Instance d'un objet Opcode.

Retours

Boolean

true ou false.

Remarques

Cette méthode peut être utilisée pour rechercher les opcodes MSIL qui sont « de forme abrégée », à utiliser dans le code optimisé.

TakesSingleByteArgumentretourne true si le OpCode instance prend un argument octet unique dans les cas suivants :

• L’opcode exécute une instruction de branche pour une adresse de taille octet (par exemple, Br_S et Bgt_S).

• L’opcode envoie (push) une valeur d’octet sur la pile (par exemple, Ldc_I4_S).

• L’opcode fait référence à une variable ou à un argument via le « formulaire court » de taille octet (par exemple, Ldloc_S et Stloc_S).

Sinon, falseest retourné.

L’exemple ci-dessous illustre l’utilisation de TakesSingleByteArgument en réfléchissant à la OpCodes classe et en testant pour voir si chaque OpCode champ prend un argument codé sur un octet.

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