Freigeben über


IsSignUnspecifiedByte Klasse

Definition

Gibt an, dass ein Modifizierer weder signed noch unsigned lautet. Diese Klasse kann nicht vererbt werden.

public ref class IsSignUnspecifiedByte abstract sealed
public static class IsSignUnspecifiedByte
type IsSignUnspecifiedByte = class
Public Class IsSignUnspecifiedByte
Vererbung
IsSignUnspecifiedByte

Beispiele

Im folgenden Codebeispiel wird eine Assembly mithilfe von Klassen im System.Reflection.Emit Namespace erstellt und der IsSignUnspecifiedByte Modifizierer an diese Assembly ausgegeben.



#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.");
}

Hinweise

Einige Programmiersprachen, z. B. C++, erkennen drei unterschiedliche char Werte: signed char, unsigned charund char. Um den unveränderten char Typ von den anderen zu unterscheiden, fügt der Microsoft C++-Compiler jedem Typ, der an eine Assembly ausgegeben wird, den IsSignUnspecifiedByte Modifizierer char hinzu.

Compiler geben benutzerdefinierte Modifizierer innerhalb von Metadaten aus, um die Art und Weise zu ändern, wie der JIT-Compiler (Just-in-Time) Werte verarbeitet, wenn das Standardverhalten nicht angemessen ist. Wenn der JIT-Compiler auf einen benutzerdefinierten Modifizierer stößt, verarbeitet er den Wert so, wie der Modifizierer angibt. Compiler können benutzerdefinierte Modifizierer auf Methoden, Parameter und Rückgabewerte anwenden. Der JIT-Compiler muss auf erforderliche Modifizierer reagieren, kann aber optionale Modifizierer ignorieren.

Sie können benutzerdefinierte Modifizierer mit einer der folgenden Techniken in Metadaten ausgeben:

Gilt für: