MetadataBuilder Klasse

Referenz

Definition

Namespace:: System.Reflection.Metadata.Ecma335

Assembly:: System.Reflection.Metadata.dll

Quelle:: MetadataBuilder.cs

Quelle:: MetadataBuilder.cs

Quelle:: MetadataBuilder.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.

public ref class MetadataBuilder sealed

public sealed class MetadataBuilder

type MetadataBuilder = class

Public NotInheritable Class MetadataBuilder

Vererbung: Object
MetadataBuilder

Beispiele

In diesem Beispiel wird gezeigt, wie eine Konsolenanwendungsassembly mit ausgegeben wird MetadataBuilder:

private static readonly Guid s_guid = new Guid("87D4DBE1-1143-4FAD-AAB3-1001F92068E6");
private static readonly BlobContentId s_contentId = new BlobContentId(s_guid, 0x04030201);

private static MethodDefinitionHandle EmitHelloWorld(MetadataBuilder metadata, BlobBuilder ilBuilder)
{
    // Create module and assembly for a console application.
    metadata.AddModule(
        0,
        metadata.GetOrAddString("ConsoleApplication.exe"),
        metadata.GetOrAddGuid(s_guid),
        default(GuidHandle),
        default(GuidHandle));

    metadata.AddAssembly(
        metadata.GetOrAddString("ConsoleApplication"),
        version: new Version(1, 0, 0, 0),
        culture: default(StringHandle),
        publicKey: default(BlobHandle),
        flags: 0,
        hashAlgorithm: AssemblyHashAlgorithm.None);

    // Create references to System.Object and System.Console types.
    AssemblyReferenceHandle mscorlibAssemblyRef = metadata.AddAssemblyReference(
        name: metadata.GetOrAddString("mscorlib"),
        version: new Version(4, 0, 0, 0),
        culture: default(StringHandle),
        publicKeyOrToken: metadata.GetOrAddBlob(
            new byte[] { 0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89 }
            ),
        flags: default(AssemblyFlags),
        hashValue: default(BlobHandle));

    TypeReferenceHandle systemObjectTypeRef = metadata.AddTypeReference(
        mscorlibAssemblyRef,
        metadata.GetOrAddString("System"),
        metadata.GetOrAddString("Object"));

    TypeReferenceHandle systemConsoleTypeRefHandle = metadata.AddTypeReference(
        mscorlibAssemblyRef,
        metadata.GetOrAddString("System"),
        metadata.GetOrAddString("Console"));

    // Get reference to Console.WriteLine(string) method.
    var consoleWriteLineSignature = new BlobBuilder();

    new BlobEncoder(consoleWriteLineSignature).
        MethodSignature().
        Parameters(1,
            returnType => returnType.Void(),
            parameters => parameters.AddParameter().Type().String());

    MemberReferenceHandle consoleWriteLineMemberRef = metadata.AddMemberReference(
        systemConsoleTypeRefHandle,
        metadata.GetOrAddString("WriteLine"),
        metadata.GetOrAddBlob(consoleWriteLineSignature));

    // Get reference to Object's constructor.
    var parameterlessCtorSignature = new BlobBuilder();

    new BlobEncoder(parameterlessCtorSignature).
        MethodSignature(isInstanceMethod: true).
        Parameters(0, returnType => returnType.Void(), parameters => { });

    BlobHandle parameterlessCtorBlobIndex = metadata.GetOrAddBlob(parameterlessCtorSignature);

    MemberReferenceHandle objectCtorMemberRef = metadata.AddMemberReference(
        systemObjectTypeRef,
        metadata.GetOrAddString(".ctor"),
        parameterlessCtorBlobIndex);

    // Create signature for "void Main()" method.
    var mainSignature = new BlobBuilder();

    new BlobEncoder(mainSignature).
        MethodSignature().
        Parameters(0, returnType => returnType.Void(), parameters => { });

    var methodBodyStream = new MethodBodyStreamEncoder(ilBuilder);

    var codeBuilder = new BlobBuilder();
    InstructionEncoder il;
    
    // Emit IL for Program::.ctor
    il = new InstructionEncoder(codeBuilder);

    // ldarg.0
    il.LoadArgument(0); 

    // call instance void [mscorlib]System.Object::.ctor()
    il.Call(objectCtorMemberRef);

    // ret
    il.OpCode(ILOpCode.Ret);

    int ctorBodyOffset = methodBodyStream.AddMethodBody(il);
    codeBuilder.Clear();

    // Emit IL for Program::Main
    var flowBuilder = new ControlFlowBuilder();
    il = new InstructionEncoder(codeBuilder, flowBuilder);

    // ldstr "hello"
    il.LoadString(metadata.GetOrAddUserString("Hello, world"));

    // call void [mscorlib]System.Console::WriteLine(string)
    il.Call(consoleWriteLineMemberRef);

    // ret
    il.OpCode(ILOpCode.Ret);

    int mainBodyOffset = methodBodyStream.AddMethodBody(il);
    codeBuilder.Clear();

    // Create method definition for Program::Main
    MethodDefinitionHandle mainMethodDef = metadata.AddMethodDefinition(
        MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig,
        MethodImplAttributes.IL,
        metadata.GetOrAddString("Main"),
        metadata.GetOrAddBlob(mainSignature),
        mainBodyOffset,
        parameterList: default(ParameterHandle));

    // Create method definition for Program::.ctor
    MethodDefinitionHandle ctorDef = metadata.AddMethodDefinition(
        MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
        MethodImplAttributes.IL,
        metadata.GetOrAddString(".ctor"),
        parameterlessCtorBlobIndex,
        ctorBodyOffset,
        parameterList: default(ParameterHandle));

    // Create type definition for the special <Module> type that holds global functions
    metadata.AddTypeDefinition(
        default(TypeAttributes),
        default(StringHandle),
        metadata.GetOrAddString("<Module>"),
        baseType: default(EntityHandle),
        fieldList: MetadataTokens.FieldDefinitionHandle(1),
        methodList: mainMethodDef);

    // Create type definition for ConsoleApplication.Program
    metadata.AddTypeDefinition(
        TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.BeforeFieldInit,
        metadata.GetOrAddString("ConsoleApplication"),
        metadata.GetOrAddString("Program"),
        baseType: systemObjectTypeRef,
        fieldList: MetadataTokens.FieldDefinitionHandle(1),
        methodList: mainMethodDef);
    
    return mainMethodDef;
}

private static void WritePEImage(
    Stream peStream,
    MetadataBuilder metadataBuilder,
    BlobBuilder ilBuilder,
    MethodDefinitionHandle entryPointHandle
    )
{
    // Create executable with the managed metadata from the specified MetadataBuilder.
    var peHeaderBuilder = new PEHeaderBuilder(
        imageCharacteristics: Characteristics.ExecutableImage
        );

    var peBuilder = new ManagedPEBuilder(
        peHeaderBuilder,
        new MetadataRootBuilder(metadataBuilder),
        ilBuilder,
        entryPoint: entryPointHandle,
        flags: CorFlags.ILOnly,
        deterministicIdProvider: content => s_contentId);

    // Write executable into the specified stream.
    var peBlob = new BlobBuilder();
    BlobContentId contentId = peBuilder.Serialize(peBlob);
    peBlob.WriteContentTo(peStream);
}

public static void BuildHelloWorldApp()
{
    using var peStream = new FileStream(
        "ConsoleApplication.exe", FileMode.OpenOrCreate, FileAccess.ReadWrite
        );
    
    var ilBuilder = new BlobBuilder();
    var metadataBuilder = new MetadataBuilder();

    MethodDefinitionHandle entryPoint = EmitHelloWorld(metadataBuilder, ilBuilder);
    WritePEImage(peStream, metadataBuilder, ilBuilder, entryPoint);
}

Hinweise

Mit MetadataBuilder der -Klasse können Sie Assemblys programmgesteuert generieren. Diese Assemblys können in einer Datei gespeichert werden, im Gegensatz zu dynamischen Assemblys, die von einer Klasse generiert werden, die das Speichern von AssemblyBuilder Assemblys in einer Datei unter .NET 5 und .NET Core nicht unterstützt.

Die MetadataBuilder API betreibt Metadatenkonstrukte auf niedriger Ebene, z. B. Tabellen oder Blobs. Eine einfachere Möglichkeit zum dynamischen Generieren von Assemblys mit C# finden Sie CSharpCompilation unter Roslyn-API.

Das Format der CLI-Metadaten wird durch die ECMA-335-Spezifikation definiert. Weitere Informationen finden Sie auf der Ecma International-Website unter Standard ECMA-335 – Common Language Infrastructure (CLI).

Konstruktoren

MetadataBuilder(Int32, Int32, Int32, Int32)

Erstellt einen Generator für Metadatentabellen und Heaps.

Methoden

AddAssembly(StringHandle, Version, StringHandle, BlobHandle, AssemblyFlags, AssemblyHashAlgorithm)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddAssemblyFile(StringHandle, BlobHandle, Boolean)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddAssemblyReference(StringHandle, Version, StringHandle, BlobHandle, AssemblyFlags, BlobHandle)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddConstant(EntityHandle, Object)	Fügt einen Standardwert für einen Parameter, ein Feld oder eine Eigenschaft hinzu.
AddCustomAttribute(EntityHandle, EntityHandle, BlobHandle)	Fügt ein benutzerdefiniertes Attribut hinzu.
AddCustomDebugInformation(EntityHandle, GuidHandle, BlobHandle)	Fügt benutzerdefinierte Debuginformationen hinzu.
AddDeclarativeSecurityAttribute(EntityHandle, DeclarativeSecurityAction, BlobHandle)	Fügt einem Typ, einer Methode oder einer Assembly ein deklaratives Sicherheitsattribut hinzu.
AddDocument(BlobHandle, GuidHandle, BlobHandle, GuidHandle)	Fügt Dokumentdebuginformationen hinzu.
AddEncLogEntry(EntityHandle, EditAndContinueOperation)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddEncMapEntry(EntityHandle)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddEvent(EventAttributes, StringHandle, EntityHandle)	Fügt eine Ereignisdefinition hinzu.
AddEventMap(TypeDefinitionHandle, EventDefinitionHandle)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddExportedType(TypeAttributes, StringHandle, StringHandle, EntityHandle, Int32)	Fügt einen exportierten Typ hinzu.
AddFieldDefinition(FieldAttributes, StringHandle, BlobHandle)	Fügt eine Felddefinition hinzu.
AddFieldLayout(FieldDefinitionHandle, Int32)	Definiert ein Feldlayout einer Felddefinition.
AddFieldRelativeVirtualAddress(FieldDefinitionHandle, Int32)	Fügt dem im PE-Image gespeicherten Anfangswert eine Zuordnung von einem Feld hinzu.
AddGenericParameter(EntityHandle, GenericParameterAttributes, StringHandle, Int32)	Fügt eine generische Parameterdefinition hinzu.
AddGenericParameterConstraint(GenericParameterHandle, EntityHandle)	Fügt einem generischen Parameter eine Typeinschränkung hinzu.
AddImportScope(ImportScopeHandle, BlobHandle)	Fügt Debuginformationen für den lokalen Bereich hinzu.
AddInterfaceImplementation(TypeDefinitionHandle, EntityHandle)	Fügt einem Typ eine Schnittstellenimplementierung hinzu.
AddLocalConstant(StringHandle, BlobHandle)	Fügt Debuginformationen für die lokale Konstante hinzu.
AddLocalScope(MethodDefinitionHandle, ImportScopeHandle, LocalVariableHandle, LocalConstantHandle, Int32, Int32)	Fügt Debuginformationen für den lokalen Bereich hinzu.
AddLocalVariable(LocalVariableAttributes, Int32, StringHandle)	Fügt Debuginformationen für die lokale Variable hinzu.
AddManifestResource(ManifestResourceAttributes, StringHandle, EntityHandle, UInt32)	Fügt eine Manifestressource hinzu.
AddMarshallingDescriptor(EntityHandle, BlobHandle)	Fügt einem Feld oder einem Parameter Marshallinginformationen hinzu.
AddMemberReference(EntityHandle, StringHandle, BlobHandle)	Fügt eine MemberRef-Tabellenzeile hinzu.
AddMethodDebugInformation(DocumentHandle, BlobHandle)	Fügt Debuginformationen für die Methode hinzu.
AddMethodDefinition(MethodAttributes, MethodImplAttributes, StringHandle, BlobHandle, Int32, ParameterHandle)	Fügt eine Methodendefinition hinzu.
AddMethodImplementation(TypeDefinitionHandle, EntityHandle, EntityHandle)	Definiert eine Implementierung für eine Methodendeklaration innerhalb eines Typs.
AddMethodImport(MethodDefinitionHandle, MethodImportAttributes, StringHandle, ModuleReferenceHandle)	Fügt einer Methodendefinition Importinformationen hinzu.
AddMethodSemantics(EntityHandle, MethodSemanticsAttributes, MethodDefinitionHandle)	Ordnet eine Methode (Getter, Setter, Adder usw.) einer Eigenschaft oder einem Ereignis zu.
AddMethodSpecification(EntityHandle, BlobHandle)	Fügt eine Methodenspezifikation (Instanziierung) hinzu.
AddModule(Int32, StringHandle, GuidHandle, GuidHandle, GuidHandle)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddModuleReference(StringHandle)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddNestedType(TypeDefinitionHandle, TypeDefinitionHandle)	Definiert eine Schachtelungsbeziehung mit angegebenen Typdefinitionen.
AddParameter(ParameterAttributes, StringHandle, Int32)	Fügt eine Parameterdefinition hinzu.
AddProperty(PropertyAttributes, StringHandle, BlobHandle)	Fügt eine Eigenschaftsdefinition hinzu.
AddPropertyMap(TypeDefinitionHandle, PropertyDefinitionHandle)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddStandaloneSignature(BlobHandle)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
AddStateMachineMethod(MethodDefinitionHandle, MethodDefinitionHandle)	Fügt Debuginformationen für die Zustandsautomatenmethode hinzu.
AddTypeDefinition(TypeAttributes, StringHandle, StringHandle, EntityHandle, FieldDefinitionHandle, MethodDefinitionHandle)	Fügt eine Typdefinition hinzu.
AddTypeLayout(TypeDefinitionHandle, UInt16, UInt32)	Definiert ein Typlayout einer Typdefinition.
AddTypeReference(EntityHandle, StringHandle, StringHandle)	Fügt einen Typverweis hinzu.
AddTypeSpecification(BlobHandle)	Die MetadataBuilder-Klasse schreibt Metadaten für eine Assembly mit hoher Leistung. Sie dient der Verwendung durch Compiler und andere Tools zum Generieren von Assemblys.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetOrAddBlob(BlobBuilder)	Fügt dem Blobheap das angegebene Blob aus einem unveränderlichen Bytearray hinzu, sofern es nicht bereits enthalten ist.
GetOrAddBlob(Byte[])	Fügt dem Blobheap das angegebene Blob hinzu, sofern es nicht bereits enthalten ist.
GetOrAddBlob(ImmutableArray<Byte>)	Fügt dem Blobheap das angegebene Blob aus dem Bytearray hinzu, sofern es nicht bereits enthalten ist.
GetOrAddBlobUTF16(String)	Codiert eine Zeichenfolge mithilfe der UTF16-Codierung in ein Blob, und fügt sie dem Blobheap hinzu, wenn sie nicht bereits enthalten ist.
GetOrAddBlobUTF8(String, Boolean)	Codiert eine Zeichenfolge mithilfe der UTF8-Codierung in ein Blob, und fügt es dem Blobheap hinzu, sofern es nicht bereits enthalten ist.
GetOrAddConstantBlob(Object)	Codiert einen konstanten Wert in ein Blob, und fügt es dem Blobheap hinzu, sofern es nicht bereits enthalten ist. Verwendet UTF16 zum Codieren von Zeichenfolgenkonstanten.
GetOrAddDocumentName(String)	Codiert einen Debugdokumentnamen, und fügt ihn dem Blobheap hinzu, sofern er nicht bereits enthalten ist.
GetOrAddGuid(Guid)	Fügt dem GUID-Heap die angegebene GUID hinzu, sofern sie nicht bereits enthalten ist.
GetOrAddString(String)	Fügt dem Zeichenfolgenheap die angegebene Zeichenfolge hinzu, sofern sie nicht bereits enthalten ist.
GetOrAddUserString(String)	Fügt dem Benutzerzeichenfolgenheap die angegebene Zeichenfolge hinzu, sofern sie nicht bereits enthalten ist.
GetRowCount(TableIndex)	Gibt die aktuelle Anzahl der Elemente in der angegebenen Tabelle zurück.
GetRowCounts()	Gibt die aktuelle Anzahl der Elemente in den einzelnen Tabellen zurück.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ReserveGuid()	Reserviert im GUID-Heap Speicherplatz für eine GUID.
ReserveUserString(Int32)	Reserviert im Benutzerzeichenfolgenheap Speicherplatz für eine Zeichenfolge der angegebenen Länge.
SetCapacity(HeapIndex, Int32)	Legt die Kapazität des angegebenen Heaps fest.
SetCapacity(TableIndex, Int32)	Legt die Kapazität der angegebenen Tabelle fest.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Gilt für: