IsExplicitlyDereferenced Klass

Definition

Namnområde:
System.Runtime.CompilerServices
Sammansättning:
mscorlib.dll
Sammansättning:
netstandard.dll

Anger att en hanterad pekare representerar en pekarparameter i en metodsignatur. Det går inte att ärva den här klassen.

public ref class IsExplicitlyDereferenced abstract sealed
public static class IsExplicitlyDereferenced
type IsExplicitlyDereferenced = class
Public Class IsExplicitlyDereferenced
Arv
Object
IsExplicitlyDereferenced

Exempel

I följande exempel visas hur du genererar ett IsExplicitlyDereferenced objekt till en sammansättning med reflektion.



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

Kommentarer

I C++ genereras hanterade pekare och hanterade referenser till metadata som pekare. För att skilja mellan de två typerna i metadata tillämpar Microsoft C++-kompilatorn den här modifieraren på hanterade pekare. Den genererar ingen modifierare för hanterade referenstyper. Kompilatorer måste känna till rätt anropande syntax när de importerar en metod från metadataomfånget. Klassen IsExplicitlyDereferenced och dess partner, IsImplicitlyDereferenced klassen, tvetydiga referensparametrar från pekarparametrar.

Kompilatorer genererar anpassade modifierare i metadata för att ändra hur jit-kompilatorn (just-in-time) hanterar värden när standardbeteendet inte är lämpligt. När JIT-kompilatorn stöter på en anpassad modifierare hanterar den värdet på det sätt som modifieraren anger. Kompilatorer kan använda anpassade modifierare för metoder, parametrar och returvärden. JIT-kompilatorn måste svara på nödvändiga modifierare men kan ignorera valfria modifierare.

Du kan generera anpassade modifierare i metadata med någon av följande tekniker:

Gäller för