IsExplicitlyDereferenced Klas

Definitie

public ref class IsExplicitlyDereferenced abstract sealed

public static class IsExplicitlyDereferenced

type IsExplicitlyDereferenced = class

Public Class IsExplicitlyDereferenced

Overname

Object

IsExplicitlyDereferenced

Voorbeelden

In het volgende voorbeeld ziet u hoe u een IsExplicitlyDereferenced object in een assembly verzendt met behulp van weerspiegeling.

#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 = {IsExplicitlyDereferenced::typeid};

    mainClass->DefineField("modifiedInteger", Type::GetType("System.IntPtr"), 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.");
}

Opmerkingen

In C++worden beheerde aanwijzers en beheerde verwijzingen verzonden naar metagegevens als aanwijzers. Als u onderscheid wilt maken tussen de twee typen metagegevens, past de Microsoft C++-compiler deze wijzigingsfunctie toe op beheerde aanwijzers. Er wordt geen wijzigingsfunctie verzonden voor beheerde referentietypen. Compilers moeten de juiste aanroepende syntaxis weten bij het importeren van een methode uit het metagegevensbereik. De IsExplicitlyDereferenced klasse en de partner, de IsImplicitlyDereferenced klasse, onderscheiden referentieparameters van aanwijzerparameters.

Compilers verzenden aangepaste modifiers binnen metagegevens om de manier te wijzigen waarop de Just-In-Time-compiler (JIT) waarden verwerkt wanneer het standaardgedrag niet geschikt is. Wanneer de JIT-compiler een aangepaste wijzigingsfunctie tegenkomt, wordt de waarde verwerkt op de manier die door de wijzigingsfunctie wordt opgegeven. Compilers kunnen aangepaste modifiers toepassen op methoden, parameters en retourwaarden. De JIT-compiler moet reageren op vereiste modifiers, maar kan optionele modifiers negeren.

U kunt aangepaste modifiers verzenden naar metagegevens met behulp van een van de volgende technieken:

• Methoden gebruiken in de TypeBuilder klasse, zoals DefineMethod, DefineField, DefineConstructoren DefineProperty.

• Het genereren van een Microsoft tussenliggende taal (MSIL) instructiebestand met aanroepen naar modopt en modreq, en het samenstellen van het bestand met de Ilasm.exe (IL Assembler).

• De onbeheerde weerspiegelings-API gebruiken.