IsLong Classe

Définition

Espace de noms:

System.Runtime.CompilerServices

Assembly:

System.Runtime.CompilerServices.VisualC.dll

Indique qu'un entier modifié est une valeur long C++ standard. Cette classe ne peut pas être héritée.

public ref class IsLong abstract sealed

public static class IsLong

type IsLong = class

Public Class IsLong

Héritage

Object

IsLong

Exemples

L’exemple suivant montre comment émettre un IsLong 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 = {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.");
}

Remarques

La norme C++ indique qu’une long valeur et une valeur entière sont des types distincts. Toutefois, ils sont tous deux représentés à l’aide ELEMENT_TYPE_I4 d’un assembly. Pour distinguer un long d’un entier en C++, le compilateur C++ Microsoft ajoute le IsLong modificateur à n’importe quelle instance d’un long lorsque l’instance est émise. Ce processus est d’une importance critique pour le maintien de la sécurité de type au niveau de la langue.

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 manière spécifiée par le modificateur. 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 :

• Utilisation de méthodes dans la TypeBuilder classe , telles que DefineMethod, DefineField, DefineConstructoret DefineProperty.

• Génération d’un fichier d’instruction MSIL (Microsoft intermediate language) qui contient des appels à modopt et modreq, et assemblage du fichier avec le Ilasm.exe (assembleur IL).

• Utilisation de l’API de réflexion non managée.