IsByValue Classe

Definição

Indica que um argumento de método modificado deve ser interpretado como tendo a semântica de objeto passado por valor.Indicates that a modified method argument should be interpreted as having object passed-by-value semantics. Esse modificador é aplicado a tipos de referência.This modifier is applied to reference types. Essa classe não pode ser herdada.This class cannot be inherited.

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

Exemplos

O exemplo a seguir demonstra como emitir um IsByValue objeto em um assembly usando reflexão.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.");
}

Comentários

A IsByValue classe é usada pelo compilador do Microsoft C++ para denotar parâmetros de método e valores de retorno cuja semântica segue as regras de C++ para objetos passados por valor.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.

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