IsExplicitlyDereferenced Clase

Definición

Espacio de nombres:

System.Runtime.CompilerServices

Ensamblado:

System.Runtime.CompilerServices.VisualC.dll

Indica que un puntero administrado representa un parámetro de puntero dentro de una firma de método. Esta clase no puede heredarse.

public ref class IsExplicitlyDereferenced abstract sealed

public static class IsExplicitlyDereferenced

type IsExplicitlyDereferenced = class

Public Class IsExplicitlyDereferenced

Herencia

Object

IsExplicitlyDereferenced

Ejemplos

En el ejemplo siguiente se muestra cómo emitir un IsExplicitlyDereferenced objeto en un ensamblado mediante la 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 = {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.");
}

Comentarios

En C++, los punteros administrados y las referencias administradas se emiten en metadatos como punteros. Para distinguir entre los dos tipos de metadatos, el compilador de Microsoft C++ aplica este modificador a punteros administrados. No emite ningún modificador en los tipos de referencia administrados. Los compiladores deben conocer la sintaxis de llamada correcta al importar un método desde el ámbito de metadatos. La IsExplicitlyDereferenced clase y su asociado, la IsImplicitlyDereferenced clase , desambiguan los parámetros de referencia de los parámetros de puntero.

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 forma en 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 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 y modreq, y ensamblar el archivo con el Ilasm.exe (ensamblador de IL).

• Uso de la API de reflexión no administrada.