IsUdtReturn Klasse

  • Referenz

Definition

Namespace:
System.Runtime.CompilerServices
Assembly:
System.Runtime.CompilerServices.VisualC.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.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 in 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 mit systemeigener C++-Objektrückgabesemantik zu markieren. Der verwaltete Debugger erkennt diesen Modifizierer, um korrekt zu ermitteln, dass die systemeigene Aufrufkonvention verwendet wird.

Compiler geben benutzerdefinierte Modifizierer innerhalb von Metadaten aus, um die Art und Weise zu ändern, wie der Just-in-Time-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 jedoch optionale Modifizierer ignorieren.

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

Gilt für