MetadataBuilder Clase

Definición

Espacio de nombres:

System.Reflection.Metadata.Ecma335

Ensamblado:

System.Reflection.Metadata.dll

Paquete:

System.Reflection.Metadata v9.0.0-rc.2.24473.5

Source:

MetadataBuilder.cs

La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.

public ref class MetadataBuilder sealed

public sealed class MetadataBuilder

type MetadataBuilder = class

Public NotInheritable Class MetadataBuilder

Herencia

Object

MetadataBuilder

Ejemplos

En este ejemplo se muestra cómo emitir un ensamblado de aplicación de consola mediante 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);
}

Comentarios

La MetadataBuilder clase permite generar ensamblados mediante programación. Estos ensamblados se pueden guardar en un archivo, a diferencia de los ensamblados dinámicos generados por AssemblyBuilder la clase , que no admite guardar ensamblados en un archivo en .NET 5+ y .NET Core.

La MetadataBuilder API opera construcciones de metadatos de bajo nivel, como tablas o blobs. Para obtener una manera más sencilla de generar ensamblados dinámicamente mediante C#, consulte CSharpCompilation en Roslyn API.

El formato de los metadatos de la CLI se define mediante la especificación ECMA-335. Para obtener más información, consulte Standard ECMA-335 - Common Language Infrastructure (CLI) en el sitio web de Ecma International.

Constructores

MetadataBuilder(Int32, Int32, Int32, Int32)

Crea un generador para las tablas de metadatos y los montones.

Métodos

AddAssembly(StringHandle, Version, StringHandle, BlobHandle, AssemblyFlags, AssemblyHashAlgorithm)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddAssemblyFile(StringHandle, BlobHandle, Boolean)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddAssemblyReference(StringHandle, Version, StringHandle, BlobHandle, AssemblyFlags, BlobHandle)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddConstant(EntityHandle, Object)	Agrega un valor predeterminado para un parámetro, un campo o una propiedad.
AddCustomAttribute(EntityHandle, EntityHandle, BlobHandle)	Agrega un atributo personalizado.
AddCustomDebugInformation(EntityHandle, GuidHandle, BlobHandle)	Agrega información de depuración personalizada.
AddDeclarativeSecurityAttribute(EntityHandle, DeclarativeSecurityAction, BlobHandle)	Agrega un atributo de seguridad declarativa a un tipo, un método o un ensamblado.
AddDocument(BlobHandle, GuidHandle, BlobHandle, GuidHandle)	Agrega información de depuración del documento.
AddEncLogEntry(EntityHandle, EditAndContinueOperation)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddEncMapEntry(EntityHandle)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddEvent(EventAttributes, StringHandle, EntityHandle)	Agrega una definición de evento.
AddEventMap(TypeDefinitionHandle, EventDefinitionHandle)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddExportedType(TypeAttributes, StringHandle, StringHandle, EntityHandle, Int32)	Agrega un tipo exportado.
AddFieldDefinition(FieldAttributes, StringHandle, BlobHandle)	Agrega una definición de campo.
AddFieldLayout(FieldDefinitionHandle, Int32)	Define un diseño de campo de una definición de campo.
AddFieldRelativeVirtualAddress(FieldDefinitionHandle, Int32)	Agrega una asignación de un campo a su valor inicial almacenado en la imagen de PE.
AddGenericParameter(EntityHandle, GenericParameterAttributes, StringHandle, Int32)	Agrega una definición de parámetro genérico.
AddGenericParameterConstraint(GenericParameterHandle, EntityHandle)	Agrega una restricción de tipo a un parámetro genérico.
AddImportScope(ImportScopeHandle, BlobHandle)	Agrega información de depuración del ámbito local.
AddInterfaceImplementation(TypeDefinitionHandle, EntityHandle)	Agrega una implementación de interfaz a un tipo.
AddLocalConstant(StringHandle, BlobHandle)	Agrega información de depuración de constante local.
AddLocalScope(MethodDefinitionHandle, ImportScopeHandle, LocalVariableHandle, LocalConstantHandle, Int32, Int32)	Agrega información de depuración del ámbito local.
AddLocalVariable(LocalVariableAttributes, Int32, StringHandle)	Agrega información de depuración de la variable local.
AddManifestResource(ManifestResourceAttributes, StringHandle, EntityHandle, UInt32)	Agrega un recurso de manifiesto.
AddMarshallingDescriptor(EntityHandle, BlobHandle)	Agrega información de serialización a un campo o un parámetro.
AddMemberReference(EntityHandle, StringHandle, BlobHandle)	Agrega una fila de la tabla MemberRef.
AddMethodDebugInformation(DocumentHandle, BlobHandle)	Agrega información de depuración de métodos.
AddMethodDefinition(MethodAttributes, MethodImplAttributes, StringHandle, BlobHandle, Int32, ParameterHandle)	Agrega una definición de método.
AddMethodImplementation(TypeDefinitionHandle, EntityHandle, EntityHandle)	Define una implementación para una declaración de método dentro de un tipo.
AddMethodImport(MethodDefinitionHandle, MethodImportAttributes, StringHandle, ModuleReferenceHandle)	Agrega información de importación a una definición de método.
AddMethodSemantics(EntityHandle, MethodSemanticsAttributes, MethodDefinitionHandle)	Asocia un método (un captador, un establecedor, un agregador, etc.) a una propiedad o un evento.
AddMethodSpecification(EntityHandle, BlobHandle)	Agrega una especificación de método (una creación de instancias).
AddModule(Int32, StringHandle, GuidHandle, GuidHandle, GuidHandle)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddModuleReference(StringHandle)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddNestedType(TypeDefinitionHandle, TypeDefinitionHandle)	Define una relación de anidamiento con las definiciones de tipo especificadas.
AddParameter(ParameterAttributes, StringHandle, Int32)	Agrega una definición de parámetro.
AddProperty(PropertyAttributes, StringHandle, BlobHandle)	Agrega una definición de propiedad.
AddPropertyMap(TypeDefinitionHandle, PropertyDefinitionHandle)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddStandaloneSignature(BlobHandle)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
AddStateMachineMethod(MethodDefinitionHandle, MethodDefinitionHandle)	Agrega información de depuración del método de equipo de estado.
AddTypeDefinition(TypeAttributes, StringHandle, StringHandle, EntityHandle, FieldDefinitionHandle, MethodDefinitionHandle)	Agrega una definición de tipo.
AddTypeLayout(TypeDefinitionHandle, UInt16, UInt32)	Define un diseño de tipo de una definición de tipo.
AddTypeReference(EntityHandle, StringHandle, StringHandle)	Agrega una referencia de tipo.
AddTypeSpecification(BlobHandle)	La clase MetadataBuilder escribe metadatos para un ensamblado de forma muy eficaz. Está diseñada para su uso por parte de compiladores y otras herramientas de generación de ensamblados.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetOrAddBlob(BlobBuilder)	Agrega el blob especificado desde una matriz de bytes inmutable al montón blob, si aún no lo está.
GetOrAddBlob(Byte[])	Agrega el blob especificado al montón blob, si aún no lo está.
GetOrAddBlob(ImmutableArray<Byte>)	Agrega el blob especificado desde una matriz de bytes al montón blob, si aún no lo está.
GetOrAddBlobUTF16(String)	Codifica una cadena mediante la codificación UTF16 en un blob y lo agrega al montón blob, si aún no lo está.
GetOrAddBlobUTF8(String, Boolean)	Codifica una cadena mediante la codificación UTF8 en un blob y lo agrega al montón blob, si aún no lo está.
GetOrAddConstantBlob(Object)	Codifica un valor constante en un blob y lo agrega al montón blob, si aún no lo está. Usa UTF16 para codificar las constantes de cadena.
GetOrAddDocumentName(String)	Codifica un nombre de documento de depuración y lo agrega al montón blob, si aún no lo está.
GetOrAddGuid(Guid)	Agrega el GUID especificado al montón GUID, si aún no lo está.
GetOrAddString(String)	Agrega la cadena especificada al montón de cadenas, si aún no lo está.
GetOrAddUserString(String)	Agrega la cadena especificada al montón de usuario, si aún no lo está.
GetRowCount(TableIndex)	Devuelve el número de elementos actuales de la tabla especificada.
GetRowCounts()	Devuelve el número de elementos actuales de cada tabla.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ReserveGuid()	Reserva espacio en el montón GUID para un GUID.
ReserveUserString(Int32)	Reserva espacio en el montón de cadenas de usuario para una cadena de la longitud especificada.
SetCapacity(HeapIndex, Int32)	Establece la capacidad del montón especificado.
SetCapacity(TableIndex, Int32)	Establece la capacidad de la tabla especificada.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)