IsBoxed Clase
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í.
Indica que el tipo de referencia modificado es un tipo de valor al que se le ha aplicado la conversión boxing. Esta clase no puede heredarse.
public ref class IsBoxed abstract sealed
public static class IsBoxed
type IsBoxed = class
Public Class IsBoxed
- Herencia
-
IsBoxed
En el ejemplo siguiente se muestra cómo emitir un IsBoxed objeto en un ensamblado mediante reflexión.
#using <mscorlib.dll>
using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Runtime::CompilerServices;
using namespace System::Threading;
ref class CodeEmitter
{
private:
AssemblyBuilder^ asmBuilder;
String^ asmName;
ModuleBuilder^ modBuilder;
void prepareAssembly(String^ name){
// Check the input.
if(!name){
throw gcnew ArgumentNullException("AssemblyName");
}
asmName = name;
// Create an AssemblyName object and set the name.
AssemblyName^ asmName = gcnew AssemblyName();
asmName->Name = name;
// Use the AppDomain class to create an AssemblyBuilder instance.
AppDomain^ currentDomain = Thread::GetDomain();
asmBuilder = currentDomain->DefineDynamicAssembly(asmName,AssemblyBuilderAccess::RunAndSave);
// Create a dynamic module.
modBuilder = asmBuilder->DefineDynamicModule(name);
}
public:
// Constructor.
CodeEmitter(String ^ AssemblyName){
prepareAssembly(AssemblyName);
}
// Create a new type.
TypeBuilder^ CreateType(String^ name){
// Check the input.
if(!name){
throw gcnew ArgumentNullException("AssemblyName");
}
return modBuilder->DefineType( name );
}
// Write the assembly.
void WriteAssembly(MethodBuilder^ entryPoint){
// Check the input.
if(!entryPoint){
throw gcnew ArgumentNullException("entryPoint");
}
asmBuilder->SetEntryPoint( entryPoint );
asmBuilder->Save( asmName );
}
};
void main()
{
// Create a CodeEmitter to handle assembly creation.
CodeEmitter ^ e = gcnew CodeEmitter("program.exe");
// Create a new type.
TypeBuilder^ mainClass = e->CreateType("MainClass");
// Create a new method.
MethodBuilder^ mBuilder = mainClass->DefineMethod("mainMethod", MethodAttributes::Static);
// Create an ILGenerator and emit IL for
// a simple "Hello World." program.
ILGenerator^ ilGen = mBuilder->GetILGenerator();
ilGen->Emit(OpCodes::Ldstr, "Hello World");
array<Type^>^mType = {String::typeid};
MethodInfo^ writeMI = Console::typeid->GetMethod( "WriteLine", mType );
ilGen->EmitCall(OpCodes::Call, writeMI, nullptr );
ilGen->Emit( OpCodes::Ret );
/////////////////////////////////////////////////
/////////////////////////////////////////////////
// Apply a required custom modifier
// to a field.
/////////////////////////////////////////////////
/////////////////////////////////////////////////
array<Type^>^fType = {IsBoxed::typeid};
mainClass->DefineField("modifiedInteger", Type::GetType("System.Int32"), fType, nullptr, FieldAttributes::Private);
// Create the type.
mainClass->CreateType();
// Write the assembly using a reference to
// the entry point.
e->WriteAssembly(mBuilder);
Console::WriteLine(L"Assembly created.");
}
El compilador de Microsoft C++ admite tipos de valor boxed directamente en el lenguaje. La información sobre los tipos de valor boxed se emite en los metadatos como un modificador personalizado, donde el modificador representa una referencia al tipo de valor que se va a boxear.
Los compiladores emiten modificadores personalizados dentro de los metadatos para cambiar la forma en que el compilador Just-In-Time (JIT) controla los valores cuando el comportamiento predeterminado no es adecuado. Cuando el compilador JIT encuentra un modificador personalizado, controla el valor de la manera que especifica el modificador. Los compiladores pueden aplicar modificadores personalizados a métodos, parámetros y valores devueltos. El compilador JIT debe responder a los modificadores necesarios, pero puede omitir los modificadores opcionales.
Puede emitir modificadores personalizados en metadatos mediante una de las técnicas siguientes:
Uso de métodos en la TypeBuilder clase como DefineMethod, DefineField, DefineConstructory DefineProperty.
Generar un archivo de instrucciones de lenguaje intermedio de Microsoft (MSIL) que contiene llamadas a
modopt
ymodreq
, y ensamblar el archivo con el Ilasm.exe (Ensamblador de IL).Uso de la API de reflexión no administrada.
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
Comentarios de .NET
.NET es un proyecto de código abierto. Seleccione un vínculo para proporcionar comentarios: