IsImplicitlyDereferenced Classe

  • Referência

Definição

Namespace:
System.Runtime.CompilerServices
Assembly:
System.Runtime.CompilerServices.VisualC.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Indica que a referência de coleta de lixo modificada representa um parâmetro de referência em uma assinatura de método. Essa classe não pode ser herdada.

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

Exemplos

O exemplo a seguir demonstra como emitir um IsImplicitlyDereferenced objeto em um assembly usando reflexão.



#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 = {IsImplicitlyDereferenced::typeid};

    mainClass->DefineField("modifiedInteger", Type::GetType("System.IntPtr"), 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

O compilador C++ usa o IsImplicitlyDereferenced modificador para distinguir classes de referência que são passadas por referência gerenciada daquelas passadas pelo ponteiro gerenciado. A IsImplicitlyDereferenced classe e seu parceiro, a IsExplicitlyDereferenced classe, desambiguam parâmetros de referência de parâmetros de ponteiro.

Os compiladores emitem modificadores personalizados dentro de metadados para alterar a maneira como o compilador JIT (just-in-time) manipula valores quando o comportamento padrão não é apropriado. Quando o compilador JIT encontra um modificador personalizado, ele manipula o valor da maneira especificada pelo modificador. Os compiladores podem aplicar modificadores personalizados a métodos, parâmetros e valores retornados. O compilador JIT deve responder aos modificadores necessários, mas pode ignorar modificadores opcionais.

Você pode emitir modificadores personalizados em metadados usando uma das seguintes técnicas:

Aplica-se a