OpCodes.TakesSingleByteArgument(OpCode) Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Devuelve true o false si el código de operación suministrado utiliza un argumento de un solo byte.
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
Parámetros
- inst
- OpCode
Instancia de un objeto código de operación.
Devoluciones
true
o false
.
Comentarios
Este método se puede usar para buscar qué códigos de operación MSIL son "formato corto", para su uso en código optimizado.
TakesSingleByteArgument
devuelve true
si la OpCode instancia toma un único argumento de byte en los casos siguientes:
El código de operación realiza una instrucción de rama en una dirección de tamaño de bytes (por ejemplo, Br_S y Bgt_S).
El código de operación inserta un valor de byte en la pila (por ejemplo, Ldc_I4_S).
El código de operación hace referencia a una variable o argumento a través del "formato corto" de tamaño byte (por ejemplo, Ldloc_S y Stloc_S).
En caso contrario, devuelve false
.
En el ejemplo siguiente se muestra el uso de TakesSingleByteArgument
mediante la reflexión en la OpCodes
clase y las pruebas para ver si cada OpCode
campo toma un argumento de un solo byte.
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