IsBoxed Klasse

Definition

Namespace:

System.Runtime.CompilerServices

Assembly:

System.Runtime.CompilerServices.VisualC.dll

Gibt an, dass der geänderte Verweistyp einen geschachtelten Werttyp darstellt. Diese Klasse kann nicht vererbt werden.

public ref class IsBoxed abstract sealed

public static class IsBoxed

type IsBoxed = class

Public Class IsBoxed

Vererbung

Object

IsBoxed

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie ein IsBoxed Objekt mithilfe von Reflektion in eine Assembly ausgegeben wird.

#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.");
}

Hinweise

Der Microsoft C++-Compiler unterstützt Boxwerttypen direkt in der Sprache. Informationen zu Boxwerttypen werden als benutzerdefinierter Modifizierer in Metadaten ausgegeben, wobei der Modifizierer einen Verweis auf den im Feld befindlichen Werttyp darstellt.

Compiler geben benutzerdefinierte Modifizierer innerhalb von Metadaten aus, um die Art und Weise zu ändern, wie der JIT-Compiler (Just-in-Time) Werte verarbeitet, wenn das Standardverhalten nicht angemessen ist. Wenn der JIT-Compiler auf einen benutzerdefinierten Modifizierer stößt, verarbeitet er den Wert so, wie der Modifizierer angibt. Compiler können benutzerdefinierte Modifizierer auf Methoden, Parameter und Rückgabewerte anwenden. Der JIT-Compiler muss auf erforderliche Modifizierer reagieren, kann aber optionale Modifizierer ignorieren.

Sie können benutzerdefinierte Modifizierer mit einer der folgenden Techniken in Metadaten ausgeben:

• Verwenden von Methoden in der TypeBuilder -Klasse wie DefineMethod, DefineField, DefineConstructorund DefineProperty.

• Generieren einer MSIL-Befehlsdatei (Microsoft Intermediate Language), die Aufrufe modopt von und modreqenthält, und Zusammensetzen der Datei mit dem Ilasm.exe (IL Assembler).

• Verwenden der nicht verwalteten Reflektions-API.