OpCodes.TakesSingleByteArgument(OpCode) Metoda

Definicja

Przestrzeń nazw:

System.Reflection.Emit

Zestaw:

System.Reflection.Primitives.dll

Źródło:

OpCodes.cs

Zwraca wartość true lub false, jeśli podany kod opcode przyjmuje jeden argument bajtowy.

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

Parametry

inst

OpCode

Wystąpienie obiektu Opcode.

Zwraca

Boolean

true lub false.

Uwagi

Tej metody można użyć do znalezienia, które kody operacyjne MSIL są "krótką formą", do użycia w zoptymalizowanym kodzie.

TakesSingleByteArgument Zwraca true wartość , jeśli OpCode wystąpienie przyjmuje jeden argument bajtowy w następujących przypadkach:

• Kod opcode wykonuje instrukcję gałęzi na adres o rozmiarze bajtu (na przykład Br_S i Bgt_S).

• Kod operacji wypycha wartość bajtu do stosu (na przykład Ldc_I4_S).

• Kod opcode odwołuje się do zmiennej lub argumentu za pośrednictwem bajtów o rozmiarze "krótkim formularzu" (na przykład Ldloc_S i Stloc_S).

W przeciwnym razie zwraca wartość false.

W poniższym przykładzie pokazano użycie metody TakesSingleByteArgument przez zastanowienie się nad klasą OpCodes i testowaniem w celu sprawdzenia, czy każde OpCode pole przyjmuje argument pojedynczego bajtu.

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