IsExplicitlyDereferenced Classe

  • Référence

Définition

Espace de noms:
System.Runtime.CompilerServices
Assembly:
System.Runtime.CompilerServices.VisualC.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Indique qu'un pointeur managé représente un paramètre pointeur dans une signature de méthode. Cette classe ne peut pas être héritée.

public ref class IsExplicitlyDereferenced abstract sealed
public static class IsExplicitlyDereferenced
type IsExplicitlyDereferenced = class
Public Class IsExplicitlyDereferenced
Héritage
Object
IsExplicitlyDereferenced

Exemples

L’exemple suivant montre comment émettre un IsExplicitlyDereferenced objet dans un assembly à l’aide de la réflexion.



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

Remarques

En C++, les pointeurs managés et les références managées sont émis dans les métadonnées en tant que pointeurs. Pour distinguer les deux types de métadonnées, le compilateur Microsoft C++ applique ce modificateur aux pointeurs managés. Il n’émet aucun modificateur sur les types de référence managés. Les compilateurs doivent connaître la syntaxe d’appel correcte lors de l’importation d’une méthode à partir de l’étendue des métadonnées. La IsExplicitlyDereferenced classe et son partenaire, la IsImplicitlyDereferenced classe, disambiguent les paramètres de référence des paramètres de pointeur.

Les compilateurs émettent des modificateurs personnalisés dans les métadonnées pour modifier la façon dont le compilateur juste-à-temps (JIT) gère les valeurs lorsque le comportement par défaut n’est pas approprié. Lorsque le compilateur JIT rencontre un modificateur personnalisé, il gère la valeur de la façon dont le modificateur spécifie. Les compilateurs peuvent appliquer des modificateurs personnalisés aux méthodes, aux paramètres et aux valeurs de retour. Le compilateur JIT doit répondre aux modificateurs requis, mais peut ignorer les modificateurs facultatifs.

Vous pouvez émettre des modificateurs personnalisés dans des métadonnées à l’aide de l’une des techniques suivantes :

S’applique à