IsUdtReturn Klasse

Definition

Namespace:

System.Runtime.CompilerServices

Assembly:

System.Runtime.CompilerServices.VisualC.dll

Gibt an, dass ein Rückgabetyp einen benutzerdefinierten Typ darstellt. Diese Klasse kann nicht vererbt werden.

public ref class IsUdtReturn abstract sealed

public static class IsUdtReturn

type IsUdtReturn = class

Public Class IsUdtReturn

Vererbung

Object

IsUdtReturn

Beispiele

Im folgenden Codebeispiel wird eine Assembly mithilfe von Klassen im System.Reflection.Emit Namespace erstellt und der IsUdtReturn Modifizierer an diese Assembly ausgegeben.

#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.");
}

Hinweise

Der IsUdtReturn -Modifizierer wird vom C++-Compiler verwendet, um Rückgabetypen von Methoden zu markieren, die systemeigene C++-Objektrückgabesemantik aufweisen. Der verwaltete Debugger erkennt diesen Modifizierer, um ordnungsgemäß zu bestimmen, dass die native Aufrufkonvention verwendet wird.

Compiler geben benutzerdefinierte Modifizierer innerhalb von Metadaten aus, um die Art und Weise zu ändern, wie der JIT-Compiler Werte verarbeitet, wenn das Standardverhalten nicht geeignet ist. Wenn der JIT-Compiler auf einen benutzerdefinierten Modifizierer trifft, behandelt 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 aber optionale Modifizierer ignorieren.

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

• Verwenden von Methoden in der TypeBuilder -Klasse wie DefineMethod, DefineField, DefineConstructorund DefineProperty.

• Generieren einer MSIL-Anweisungsdatei (Microsoft Intermediate Language), die Aufrufe von modopt und modreqenthält, und Zusammenstellen der Datei mit dem Ilasm.exe (IL Assembler).

• Verwenden der nicht verwalteten Reflektions-API.