IsUdtReturn Classe

Définition

Espace de noms:

System.Runtime.CompilerServices

Assembly:

System.Runtime.CompilerServices.VisualC.dll

Indique qu'un type de retour est un type défini par l'utilisateur. Cette classe ne peut pas être héritée.

public ref class IsUdtReturn abstract sealed

public static class IsUdtReturn

type IsUdtReturn = class

Public Class IsUdtReturn

Héritage

Object

IsUdtReturn

Exemples

L’exemple de code suivant crée un assembly à l’aide de classes dans l’espace System.Reflection.Emit de noms et émet le IsUdtReturn modificateur dans cet assembly.

#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 _tmain()
{

    // Create a CodeEmitter to handle assembly creation.
    CodeEmitter ^ e = gcnew CodeEmitter("programAssem.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 = {IsUdtReturn::typeid};

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

Le IsUdtReturn modificateur est utilisé par le compilateur C++ pour marquer les types de retour de méthodes qui ont une sémantique de retour d’objet C++ native. Le débogueur managé reconnaît ce modificateur pour déterminer correctement que la convention d’appel native est en cours d’utilisation.

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.