Metadatos y componentes autodescriptivosMetadata and Self-Describing Components

Hasta ahora, un componente de software (.exe o .dll) escrito en un lenguaje no podía usar fácilmente un componente de software escrito en otro lenguaje.In the past, a software component (.exe or .dll) that was written in one language could not easily use a software component that was written in another language. COM supuso un paso adelante en la resolución de este problema.COM provided a step towards solving this problem. En .NET se facilita todavía más la interoperación entre los componentes, ya que se permite que los compiladores emitan información de declaración adicional en todos los módulos y ensamblados..NET makes component interoperation even easier by allowing compilers to emit additional declarative information into all modules and assemblies. Esta información, denominada metadatos, contribuye a que los componentes interactúen sin problemas.This information, called metadata, helps components to interact seamlessly.

Los metadatos son información binaria que describe un programa, almacenada en un archivo ejecutable portable (PE) de Common Language Runtime o en memoria.Metadata is binary information describing your program that is stored either in a common language runtime portable executable (PE) file or in memory. Cuando se compila el código en un archivo PE, los metadatos se insertan en una parte del archivo, y el código se convierte al lenguaje intermedio de Microsoft (MSIL) y se inserta en otra parte del archivo.When you compile your code into a PE file, metadata is inserted into one portion of the file, and your code is converted to Microsoft intermediate language (MSIL) and inserted into another portion of the file. Cada tipo y miembro que se define y al que se hace referencia en un módulo o ensamblado se describe en los metadatos.Every type and member that is defined and referenced in a module or assembly is described within metadata. Cuando se ejecuta código, el motor en tiempo de ejecución carga los metadatos en la memoria y hace referencia a ellos para detectar información acerca de las clases, miembros, herencia, etc., del código.When code is executed, the runtime loads metadata into memory and references it to discover information about your code's classes, members, inheritance, and so on.

Los metadatos describen todos los tipos y miembros definidos en el código mediante un lenguaje neutro.Metadata describes every type and member defined in your code in a language-neutral manner. Los metadatos almacenan la siguiente información:Metadata stores the following information:

  • Descripción del ensambladoDescription of the assembly.

    • Identidad (nombre, versión, referencia cultural, clave pública).Identity (name, version, culture, public key).

    • Los tipos que se exportan.The types that are exported.

    • Otros ensamblados de los que depende éste.Other assemblies that this assembly depends on.

    • Permisos de seguridad que hay que ejecutar.Security permissions needed to run.

  • Descripción de los tipos.Description of types.

    • Nombre, visibilidad, clase base e interfaces implementadas.Name, visibility, base class, and interfaces implemented.

    • Miembros (métodos, campos, propiedades, eventos, tipos anidados).Members (methods, fields, properties, events, nested types).

  • Atributos.Attributes.

    • Elementos descriptivos adicionales que modifiquen los tipos y los miembros.Additional descriptive elements that modify types and members.

Ventajas de los metadatosBenefits of Metadata

Los metadatos son la clave para un modelo de programación más sencillo y eliminando la necesidad de tener archivos de Lenguaje de definición de interfaz (IDL), archivos de encabezado o cualquier método externo de referencia a componentes.Metadata is the key to a simpler programming model, and eliminates the need for Interface Definition Language (IDL) files, header files, or any external method of component reference. Los metadatos permiten que los lenguajes de .NET se describan a sí mismos de forma automática con independencia del lenguaje, que no ven ni el programador ni el usuario.Metadata enables .NET languages to describe themselves automatically in a language-neutral manner, unseen by both the developer and the user. Además, los metadatos se pueden extender mediante el uso de atributos.Additionally, metadata is extensible through the use of attributes. Los metadatos proporcionan las siguientes ventajas principales:Metadata provides the following major benefits:

  • Archivos autodescriptivosSelf-describing files.

    Los módulos y ensamblados de Common Language Runtime son autodescriptivos.Common language runtime modules and assemblies are self-describing. Los metadatos de un módulo contienen todo lo necesario para interactuar con otro módulo.A module's metadata contains everything needed to interact with another module. Los metadatos proporcionan automáticamente la funcionalidad del IDL en COM, por lo que puede usar un archivo tanto para la definición como para la implementación.Metadata automatically provides the functionality of IDL in COM, so you can use one file for both definition and implementation. Los módulos y ensamblados de Common Language Runtime no necesitan ni registrarse en el sistema operativo.Runtime modules and assemblies do not even require registration with the operating system. En consecuencia, las descripciones que usa el motor en tiempo de ejecución reflejan siempre el código actual del archivo compilado, lo que aumenta la confiabilidad de la aplicación.As a result, the descriptions used by the runtime always reflect the actual code in your compiled file, which increases application reliability.

  • Interoperabilidad de lenguajes y diseño más sencillo, basado en el componente.Language interoperability and easier component-based design.

    Los metadatos proporcionan toda la información necesaria sobre el código compilado para derivar clases de archivos PE escritos en otro lenguaje.Metadata provides all the information required about compiled code for you to inherit a class from a PE file written in a different language. Se puede crear una instancia de cualquier clase escrita en cualquier lenguaje administrado (cualquier lenguaje dirigido a Common Language Runtime) sin tener que preocuparse por la serialización explícita ni por usar código de interoperabilidad personalizado.You can create an instance of any class written in any managed language (any language that targets the common language runtime) without worrying about explicit marshaling or using custom interoperability code.

  • Atributos.Attributes.

    .NET le permite declarar determinados tipos de metadatos, denominados atributos, en el archivo compilado..NET lets you declare specific kinds of metadata, called attributes, in your compiled file. Los atributos se encuentran en la totalidad de .NET y se usan para controlar con más detalle el comportamiento del programa en tiempo de ejecución.Attributes can be found throughout .NET and are used to control in more detail how your program behaves at run time. Además, se pueden emitir metadatos personalizados propios en archivos de .NET mediante atributos personalizados definidos por el usuario.Additionally, you can emit your own custom metadata into .NET files through user-defined custom attributes. Para obtener más información, consulte Attributes (Atributos).For more information, see Attributes.

Metadatos y la estructura del archivo PEMetadata and the PE File Structure

Los metadatos se almacenan en una sección de un archivo ejecutable portable (PE) de .NET, mientras que el lenguaje intermedio de Microsoft (MSIL) se guarda en otra sección del mismo archivo.Metadata is stored in one section of a .NET portable executable (PE) file, while Microsoft intermediate language (MSIL) is stored in another section of the PE file. La parte de los metadatos del archivo contiene una serie de estructuras de datos de tablas y montones.The metadata portion of the file contains a series of table and heap data structures. La parte del MSIL contiene símbolos (token) de MSIL y de metadatos que hacen referencia a la parte de metadatos del archivo PE.The MSIL portion contains MSIL and metadata tokens that reference the metadata portion of the PE file. Puede encontrarse con tokens de metadatos al usar herramientas como el Desensamblador de MSIL (Ildasm.exe) para ver el MSIL del código, por ejemplo.You might encounter metadata tokens when you use tools such as the MSIL Disassembler (Ildasm.exe) to view your code's MSIL, for example.

Tablas y montones de metadatosMetadata Tables and Heaps

Cada tabla de metadatos tiene información sobre los elementos del programa.Each metadata table holds information about the elements of your program. Por ejemplo, una tabla de metadatos describe las clases del código, otra los campos, etc.For example, one metadata table describes the classes in your code, another table describes the fields, and so on. Si hay diez clases en el código, la tabla de clases tendrá diez filas, una por clase.If you have ten classes in your code, the class table will have tens rows, one for each class. Las tablas de metadatos hacen referencia a otras tablas y montones.Metadata tables reference other tables and heaps. Por ejemplo, la tabla de metadatos de clases hace referencia a la tabla de métodos.For example, the metadata table for classes references the table for methods.

Los metadatos también almacenan información en cuatro estructuras de montón: cadena, objeto binario, cadena de usuario y GUID.Metadata also stores information in four heap structures: string, blob, user string, and GUID. Todas las cadenas usadas en los nombres de los tipos y los miembros se almacenan en el montón de cadenas.All the strings used to name types and members are stored in the string heap. Por ejemplo, una tabla de métodos no almacena directamente el nombre de un método concreto, sino que señala al nombre del método almacenado en el montón de cadenas.For example, a method table does not directly store the name of a particular method, but points to the method's name stored in the string heap.

Símbolos (token) de metadatosMetadata Tokens

Cada fila de cada tabla de metadatos se identifica de forma exclusiva en la parte de MSIL del archivo PE mediante un token de metadatos.Each row of each metadata table is uniquely identified in the MSIL portion of the PE file by a metadata token. Los tokens de metadatos responden a un concepto similar a los punteros, que persisten en MSIL, que hacen referencia a una tabla de metadatos concreta.Metadata tokens are conceptually similar to pointers, persisted in MSIL, that reference a particular metadata table.

Un token de metadatos es un número de cuatro bytes.A metadata token is a four-byte number. El byte superior indica la tabla de metadatos a la que se refiere un token concreto (método, tipo, etc.).The top byte denotes the metadata table to which a particular token refers (method, type, and so on). Los tres bytes restantes especifican la fila de la tabla de metadatos que corresponde al elemento de programación que se describe.The remaining three bytes specify the row in the metadata table that corresponds to the programming element being described. Si se define un método en C# y se compila en un archivo PE, en la porción de MSIL del archivo PE podrían aparecer los tokens de metadatos siguientes:If you define a method in C# and compile it into a PE file, the following metadata token might exist in the MSIL portion of the PE file:

0x06000004

El byte superior (0x06) indica que este es un token de MethodDef.The top byte (0x06) indicates that this is a MethodDef token. Los tres bytes inferiores (000004) indican a Common Language Runtime que busque en la cuarta fila de la tabla MethodDef la información que describe la definición de este método.The lower three bytes (000004) tells the common language runtime to look in the fourth row of the MethodDef table for the information that describes this method definition.

Metadatos en un archivo PEMetadata within a PE File

Cuando se compila un programa para Common Language Runtime, se convierte en un archivo PE formado por tres partes.When a program is compiled for the common language runtime, it is converted to a PE file that consists of three parts. La tabla siguiente describe el contenido de cada una de estas partes.The following table describes the contents of each part.

Sección del archivo PEPE section Contenido de la sección del archivo PEContents of PE section
Encabezado PEPE header El índice de las secciones principales del archivo PE y la dirección del punto de entrada.The index of the PE file's main sections and the address of the entry point.

El motor en tiempo de ejecución usa esta información para identificar el archivo como archivo PE y para determinar dónde comienza la ejecución al cargar el programa en la memoria.The runtime uses this information to identify the file as a PE file and to determine where execution starts when loading the program into memory.
Instrucciones MSILMSIL instructions Instrucciones del Lenguaje intermedio de Microsoft (MSIL) que contiene el código.The Microsoft intermediate language instructions (MSIL) that make up your code. Muchas de las instrucciones MSIL van acompañadas por tokens de metadatos.Many MSIL instructions are accompanied by metadata tokens.
MetadatosMetadata Tablas y montones de metadatos.Metadata tables and heaps. El motor en tiempo de ejecución usa esta sección para registrar información sobre todos los tipos y miembros del código.The runtime uses this section to record information about every type and member in your code. Esta sección incluye también atributos personalizados e información de seguridad.This section also includes custom attributes and security information.

Uso de metadatos en tiempo de ejecuciónRun-Time Use of Metadata

Para comprender mejor los metadatos y su uso en Common Language Runtime, puede resultar útil construir un programa sencillo y mostrar cómo afectan los metadatos a su comportamiento durante su ejecución.To better understand metadata and its role in the common language runtime, it might be helpful to construct a simple program and illustrate how metadata affects its run-time life. El siguiente ejemplo de código muestra dos métodos dentro de una clase llamada MyApp.The following code example shows two methods inside a class called MyApp. El método Main es el punto de entrada del programa, mientras que el método Add simplemente devuelve la suma de dos argumentos de enteros.The Main method is the program entry point, while the Add method simply returns the sum of two integer arguments.

Public Class MyApp
   Public Shared Sub Main()
      Dim ValueOne As Integer = 10
      Dim ValueTwo As Integer = 20
      Console.WriteLine("The Value is: {0}", Add(ValueOne, ValueTwo))
   End Sub

   Public Shared Function Add(One As Integer, Two As Integer) As Integer
      Return (One + Two)
   End Function
End Class
using System;
public class MyApp
{
   public static int Main()
   {
      int ValueOne = 10;
      int ValueTwo = 20;
      Console.WriteLine("The Value is: {0}", Add(ValueOne, ValueTwo));
      return 0;
   }
   public static int Add(int One, int Two)
   {
      return (One + Two);
   }
}

Cuando se ejecuta el código, el motor en tiempo de ejecución carga el módulo en la memoria y consulta los metadatos de esta clase.When the code runs, the runtime loads the module into memory and consults the metadata for this class. Una vez cargado, el motor en tiempo de ejecución realiza una análisis exhaustivo de la secuencia de lenguaje intermedio de Microsoft (MSIL) del método para convertirla en rápidas instrucciones máquina nativas.Once loaded, the runtime performs extensive analysis of the method's Microsoft intermediate language (MSIL) stream to convert it to fast native machine instructions. El motor en tiempo de ejecución usa un compilador Just-In-Time (JIT) para convertir las instrucciones MSIL en código máquina nativo, método a método, según sea necesario.The runtime uses a just-in-time (JIT) compiler to convert the MSIL instructions to native machine code one method at a time as needed.

En el siguiente ejemplo de código se muestra parte del MSIL producido a partir de la función Main del código anterior.The following example shows part of the MSIL produced from the previous code's Main function. El MSIL y los metadatos se pueden ver desde cualquier aplicación de .NET mediante el Desensamblador de MSIL (Ildasm.exe).You can view the MSIL and metadata from any .NET application using the MSIL Disassembler (Ildasm.exe).

.entrypoint
.maxstack  3
.locals ([0] int32 ValueOne,
         [1] int32 ValueTwo,
         [2] int32 V_2,
         [3] int32 V_3)
IL_0000:  ldc.i4.s   10
IL_0002:  stloc.0
IL_0003:  ldc.i4.s   20
IL_0005:  stloc.1
IL_0006:  ldstr      "The Value is: {0}"
IL_000b:  ldloc.0
IL_000c:  ldloc.1
IL_000d:  call int32 ConsoleApplication.MyApp::Add(int32,int32) /* 06000003 */

El compilador JIT lee el MSIL de todo el método, lo analiza exhaustivamente y genera instrucciones nativas efectivas para ese método.The JIT compiler reads the MSIL for the whole method, analyzes it thoroughly, and generates efficient native instructions for the method. En IL_000d se encuentra un token de metadatos del método Add (/* 06000003 */), y el motor en tiempo de ejecución usa ese token para consultar la tercera fila de la tabla MethodDef.At IL_000d, a metadata token for the Add method (/* 06000003 */) is encountered and the runtime uses the token to consult the third row of the MethodDef table.

En la siguiente tabla, se muestra parte de la tabla MethodDef a la que hace referencia el token de los metadatos que describe el método Add.The following table shows part of the MethodDef table referenced by the metadata token that describes the Add method. Aunque existen otras tablas de metadatos en el ensamblado y tienen sus propios valores únicos, sólo se trata esta tabla.While other metadata tables exist in this assembly and have their own unique values, only this table is discussed.

FilaRow Dirección relativa virtual (RVA)Relative Virtual Address (RVA) ImplFlagsImplFlags MarcasFlags NOMBREName

(señala el montón de cadenas).(Points to string heap.)
Firma (señala el montón de objetos binarios)Signature (Points to blob heap.)
11 0x000020500x00002050 ILIL

AdministradoManaged
PublicPublic

ReuseSlotReuseSlot

SpecialNameSpecialName

RTSpecialNameRTSpecialName

.ctor.ctor
.ctor (constructor).ctor (constructor)
22 0x000020580x00002058 ILIL

AdministradoManaged
PublicPublic

EstáticoStatic

ReuseSlotReuseSlot
Método MainMain StringString
33 0x0000208c0x0000208c ILIL

AdministradoManaged
PublicPublic

EstáticoStatic

ReuseSlotReuseSlot
AgregarAdd int, int, intint, int, int

Cada columna de la tabla contiene información importante sobre el código.Each column of the table contains important information about your code. La columna RVA permite que el motor en tiempo de ejecución calcule la dirección de memoria de inicio del MSIL que define este método.The RVA column allows the runtime to calculate the starting memory address of the MSIL that defines this method. Las columnas ImplFlags y Flags contienen máscaras de bits que describen el método (por ejemplo, si el método es público o privado).The ImplFlags and Flags columns contain bitmasks that describe the method (for example, whether the method is public or private). La columna Nombre indexa el nombre del método del montón de cadenas.The Name column indexes the name of the method from the string heap. La columna Firma indexa la definición de la firma del método del montón de blobs.The Signature column indexes the definition of the method's signature in the blob heap.

El motor en tiempo de ejecución calcula la dirección de desplazamiento deseada desde la columna RVA de la tercera fila y la devuelve al compilador JIT, que, después, se dirige a la nueva dirección.The runtime calculates the desired offset address from the RVA column in the third row and returns this address to the JIT compiler, which then proceeds to the new address. El compilador JIT continúa procesando el MSIL en la nueva dirección hasta que encuentra otro token de metadatos y se repite el proceso.The JIT compiler continues to process MSIL at the new address until it encounters another metadata token and the process is repeated.

Usando metadatos, el motor en tiempo de ejecución tiene acceso a toda la información que necesita para cargar el código y procesarlo en instrucciones máquina nativas.Using metadata, the runtime has access to all the information it needs to load your code and process it into native machine instructions. De este modo, los metadatos hacen posible los archivos autodescriptivos y, junto con el sistema de tipos comunes, la herencia de un lenguaje a otro.In this manner, metadata enables self-describing files and, together with the common type system, cross-language inheritance.

TitleTitle DescripciónDescription
AtributosAttributes Describe cómo aplicar atributos, escribir atributos personalizados y recuperar información almacenada en atributos.Describes how to apply attributes, write custom attributes, and retrieve information that is stored in attributes.