IsExplicitlyDereferenced Classe

Definizione

Spazio dei nomi:

System.Runtime.CompilerServices

Assembly:

System.Runtime.CompilerServices.VisualC.dll

Indica che un puntatore gestito rappresenta un parametro di puntatore all'interno di una firma del metodo. La classe non può essere ereditata.

public ref class IsExplicitlyDereferenced abstract sealed

public static class IsExplicitlyDereferenced

type IsExplicitlyDereferenced = class

Public Class IsExplicitlyDereferenced

Ereditarietà

Object

IsExplicitlyDereferenced

Esempio

Nell'esempio seguente viene illustrato come generare un IsExplicitlyDereferenced oggetto in un assembly usando la reflection.

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

Commenti

In C++, i puntatori gestiti e i riferimenti gestiti vengono generati nei metadati come puntatori. Per distinguere i due tipi nei metadati, il compilatore Microsoft C++ applica questo modificatore ai puntatori gestiti. Non genera alcun modificatore nei tipi di riferimento gestiti. I compilatori devono conoscere la sintassi di chiamata corretta durante l'importazione di un metodo dall'ambito dei metadati. La IsExplicitlyDereferenced classe e il relativo partner, la IsImplicitlyDereferenced classe, disambiguano i parametri di riferimento dai parametri del puntatore.

I compilatori generano modificatori personalizzati all'interno dei metadati per modificare il modo in cui il compilatore JIT gestisce i valori quando il comportamento predefinito non è appropriato. Quando il compilatore JIT rileva un modificatore personalizzato, gestisce il valore nel modo in cui il modificatore specifica. I compilatori possono applicare modificatori personalizzati a metodi, parametri e valori restituiti. Il compilatore JIT deve rispondere ai modificatori necessari, ma può ignorare i modificatori facoltativi.

È possibile generare modificatori personalizzati nei metadati usando una delle tecniche seguenti:

• Uso di metodi nella TypeBuilder classe, ad DefineMethodesempio , DefineField, DefineConstructore DefineProperty.

• Generazione di un file di istruzioni MSIL (Microsoft Intermediate Language) che contiene chiamate a modopt e e modreqe l'assemblaggio del file con il Ilasm.exe (IL Assembler).

• Uso dell'API reflection non gestita.