IsLong Klasse

Definition

Namespace:
System.Runtime.CompilerServices
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Gibt an, dass eine geänderte ganze Zahl ein C++ long -Standardwert ist. Diese Klasse kann nicht vererbt werden.

public ref class IsLong abstract sealed
public static class IsLong
type IsLong = class
Public Class IsLong
Vererbung
Object
IsLong

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie ein IsLong Objekt mithilfe von Spiegelung 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 = {IsLong::typeid};

    mainClass->DefineField("modifiedInteger", Type::GetType("System.Int64"), 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.");
}

Hinweise

Der C++-Standard gibt an, dass ein long Wert und ein ganzzahliger Wert unterschiedliche Typen sind. Sie werden jedoch beide in ELEMENT_TYPE_I4 einer Assembly dargestellt. Um einen long von einer ganzen Zahl in C++ zu unterscheiden, fügt der Microsoft C++-Compiler die IsLong Modifizierer einer Instanz eines long hinzu, wenn die Instanz ausgegeben wird. Dieser Prozess ist für die Aufrechterhaltung der Typsicherheit auf Sprachniveau von entscheidender Bedeutung.

Compiler geben benutzerdefinierte Modifizierer innerhalb von Metadaten aus, um die Art und Weise zu ändern, wie der Just-in-Time-Compiler Werte verarbeitet, wenn das Standardverhalten nicht geeignet ist. Wenn der JIT-Compiler auf einen benutzerdefinierten Modifizierer trifft, verarbeitet er den Wert so, wie der Modifizierer angibt. Compiler können benutzerdefinierte Modifizierer auf Methoden, Parameter und Rückgabewerte anwenden. Der JIT-Compiler muss auf erforderliche Modifizierer reagieren, kann jedoch optionale Modifizierer ignorieren.

Sie können benutzerdefinierte Modifizierer mithilfe einer der folgenden Techniken in Metadaten ausgeben:

Gilt für: