IsByValue Classe

  • Riferimento

Definizione

Spazio dei nomi:
System.Runtime.CompilerServices
Assembly:
System.Runtime.CompilerServices.VisualC.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Indica che un argomento di metodo modificato deve essere interpretato come avente una semantica di oggetti passati per valore. Questo modificatore viene applicato ai tipi di riferimento. La classe non può essere ereditata.

public ref class IsByValue abstract sealed
public static class IsByValue
type IsByValue = class
Public Class IsByValue
Ereditarietà
Object
IsByValue

Esempio

Nell'esempio seguente viene illustrato come generare un IsByValue oggetto in un assembly usando la reflection.



#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 = {IsByValue::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.");
}

Commenti

La IsByValue classe viene usata dal compilatore Microsoft C++ per indicare i parametri del metodo e i valori restituiti la cui semantica segue le regole C++ per gli oggetti passati per valore.

I compilatori generano modificatori personalizzati all'interno dei metadati per modificare il modo in cui il compilatore JIT gestisce i valori quando il comportamento predefinito non è appropriato. Quando il compilatore JIT rileva un modificatore personalizzato, gestisce il valore nel modo specificato dal modificatore. I compilatori possono applicare modificatori personalizzati a metodi, parametri e valori restituiti. Il compilatore JIT deve rispondere ai modificatori necessari, ma può ignorare i modificatori facoltativi.

È possibile generare modificatori personalizzati nei metadati usando una delle tecniche seguenti:

Si applica a