(0) exportieren Drucken
Alle erweitern

IsExplicitlyDereferenced-Klasse

Hinweis: Diese Klasse ist neu in .NET Framework, Version 2.0.

Gibt an, dass ein verwalteter Zeiger einen Zeigerparameter in einer Methodensignatur darstellt. Die Klasse kann nicht geerbt werden.

Namespace: System.Runtime.CompilerServices
Assembly: mscorlib (in mscorlib.dll)

public static class IsExplicitlyDereferenced
public final class IsExplicitlyDereferenced
public final class IsExplicitlyDereferenced

In C++ werden verwaltete Zeiger und verwaltete Verweise als Zeiger in Metadaten ausgegeben. Der Microsoft C++-Compiler wendet diesen Modifizierer auf verwaltete Zeiger an, um zwischen den zwei Typen in Metadaten zu unterscheiden. Er gibt keinen Modifizierer für verwaltete Verweistypen aus. Compiler müssen beim Importieren einer Methode aus dem Metadatenbereich die richtige Aufrufsyntax kennen. Die IsExplicitlyDereferenced-Klasse und der dazugehörige Partner, die IsImplicitlyDereferenced-Klasse, unterscheiden Verweisparameter eindeutig von Zeigerparametern.

Compiler geben benutzerdefinierte Modifizierer innerhalb der Metadaten aus, um die Behandlung von Werten durch den JIT-Compiler (Just-In-Time) zu ändern, wenn das Standardverhalten nicht geeignet ist. Wenn der JIT-Compiler auf einen benutzerdefinierten Modifizierer trifft, wird der Wert wie vom Modifizierer angegeben behandelt. Compiler können benutzerdefinierte Modifizierer auf Methoden, Parameter und Rückgabewerte anwenden. Der JIT-Compiler muss auf erforderliche Modifizierer reagieren, kann optionale Modifizierer jedoch ignorieren.

Benutzerdefinierte Modifizierer können mit einer der folgenden Methoden in Metadaten ausgegeben werden:

Im folgenden Beispiel wird veranschaulicht, wie ein IsExplicitlyDereferenced-Objekt mit der Reflektion in eine Assembly ausgegeben wird.



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

System.Object
  System.Runtime.CompilerServices.IsExplicitlyDereferenced

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

.NET Framework

Unterstützt in: 2.0
Anzeigen:
© 2014 Microsoft