IsPinned Classe

Définition

Espace de noms:

System.Runtime.CompilerServices

Assembly:

System.Runtime.CompilerServices.VisualC.dll

Indique qu'une instance modifiée est épinglée en mémoire. Cette classe ne peut pas être héritée.

public ref class IsPinned abstract sealed

public static class IsPinned

type IsPinned = class

Public Class IsPinned

Héritage

Object

IsPinned

Exemples

L’exemple suivant montre comment émettre un IsPinned 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 = {IsPinned::typeid};

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

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. Un compilateur C++ peut émettre un modificateur personnalisé pour décrire comment un octet doit être traité dans les cas où le compilateur JIT traite les octets d’une manière non compatible avec C++ par défaut.

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.