IsSignUnspecifiedByte Klas

Definitie

public ref class IsSignUnspecifiedByte abstract sealed

public static class IsSignUnspecifiedByte

type IsSignUnspecifiedByte = class

Public Class IsSignUnspecifiedByte

Overname

Object

IsSignUnspecifiedByte

Voorbeelden

In het volgende codevoorbeeld wordt een assembly gemaakt met behulp van klassen in de System.Reflection.Emit naamruimte en wordt de IsSignUnspecifiedByte wijzigingsfunctie naar die assembly verzonden.

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

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

Opmerkingen

Sommige programmeertalen, zoals C++, herkennen drie afzonderlijke char waarden: signed char, unsigned charen char. Om het ongewijzigde type char van de andere te onderscheiden, voegt de Microsoft C++-compiler de IsSignUnspecifiedByte modifier toe aan elk type char dat wordt verzonden naar een assembly.

Compilers verzenden aangepaste modifiers binnen metagegevens om de manier te wijzigen waarop de Just-In-Time-compiler (JIT) waarden verwerkt wanneer het standaardgedrag niet geschikt is. Wanneer de JIT-compiler een aangepaste wijzigingsfunctie tegenkomt, wordt de waarde verwerkt op de manier die door de wijzigingsfunctie wordt opgegeven. Compilers kunnen aangepaste modifiers toepassen op methoden, parameters en retourwaarden. De JIT-compiler moet reageren op vereiste modifiers, maar kan optionele modifiers negeren.

U kunt aangepaste modifiers verzenden naar metagegevens met behulp van een van de volgende technieken:

• Methoden gebruiken in de TypeBuilder klasse, zoals DefineMethod, DefineField, DefineConstructoren DefineProperty.

• Het genereren van een Microsoft tussenliggende taal (MSIL) instructiebestand met aanroepen naar modopt en modreq, en het samenstellen van het bestand met de Ilasm.exe (IL Assembler).

• De onbeheerde weerspiegelings-API gebruiken.