IsUdtReturn Classe

Definição

Indica que um tipo de retorno é um tipo definido pelo usuário.Indicates that a return type is a user-defined type. Essa classe não pode ser herdada.This class cannot be inherited.

public ref class IsUdtReturn abstract sealed
public static class IsUdtReturn
type IsUdtReturn = class
Public Class IsUdtReturn
Herança
IsUdtReturn

Exemplos

O exemplo de código a seguir cria um assembly usando classes no System.Reflection.Emit namespace e emite o IsUdtReturn modificador para esse assembly.The following code example creates an assembly using classes in the System.Reflection.Emit namespace and emits the IsUdtReturn modifier into that 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.");
}

Comentários

O IsUdtReturn modificador é usado pelo compilador c++ para marcar tipos de retorno de métodos que têm semântica de retorno de objeto C++ nativo.The IsUdtReturn modifier is used by the C++ compiler to mark return types of methods that have native C++ object return semantics. O depurador gerenciado reconhece esse modificador para determinar corretamente se a Convenção de chamada nativa está em uso.The managed debugger recognizes this modifier to correctly determine that the native calling convention is in use.

Os compiladores emitem modificadores personalizados dentro de metadados para alterar a forma como o compilador JIT (just-in-time) manipula valores quando o comportamento padrão não é apropriado.Compilers emit custom modifiers within metadata to change the way that the just-in-time (JIT) compiler handles values when the default behavior is not appropriate. Quando o compilador JIT encontra um modificador personalizado, ele manipula o valor da maneira que o modificador especifica.When the JIT compiler encounters a custom modifier, it handles the value in the way that the modifier specifies. Os compiladores podem aplicar modificadores personalizados a métodos, parâmetros e valores de retorno.Compilers can apply custom modifiers to methods, parameters, and return values. O compilador JIT deve responder aos modificadores necessários, mas pode ignorar modificadores opcionais.The JIT compiler must respond to required modifiers but can ignore optional modifiers.

Você pode emitir modificadores personalizados em metadados usando uma das seguintes técnicas:You can emit custom modifiers into metadata using one of the following techniques:

Aplica-se a