IsByValue Classe

Definizione

Indica che un argomento di metodo modificato deve essere interpretato come avente una semantica di oggetti passati per valore.Indicates that a modified method argument should be interpreted as having object passed-by-value semantics. Questo modificatore viene applicato ai tipi di riferimento.This modifier is applied to reference types. Questa classe non può essere ereditata.This class cannot be inherited.

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

Esempi

Nell'esempio seguente viene illustrato come creare un IsByValue oggetto in un assembly utilizzando la reflection.The following example demonstrates how to emit an IsByValue object into an assembly using 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 C++ segue le regole per gli oggetti passati per valore.The IsByValue class is used by the Microsoft C++ compiler to denote method parameters and return values whose semantics follow the C++ rules for objects passed by value.

I compilatori creano modificatori personalizzati all'interno dei metadati per modificare la modalità di gestione dei valori da parte del compilatore just-in-time (JIT) quando il comportamento predefinito non è appropriato.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 il compilatore JIT rileva un modificatore personalizzato, gestisce il valore nel modo in cui viene specificato il modificatore.When the JIT compiler encounters a custom modifier, it handles the value in the way that the modifier specifies. I compilatori possono applicare modificatori personalizzati a metodi, parametri e valori restituiti.Compilers can apply custom modifiers to methods, parameters, and return values. Il compilatore JIT deve rispondere ai modificatori obbligatori, ma può ignorare i modificatori facoltativi.The JIT compiler must respond to required modifiers but can ignore optional modifiers.

È possibile creare modificatori personalizzati nei metadati utilizzando una delle tecniche seguenti:You can emit custom modifiers into metadata using one of the following techniques:

Si applica a