Metadatos .NET

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

Los metadatos .NET, en el Microsoft .NET framework, hacen referencia a ciertas estructuras de datos embebidas en el código CIL que describen la estructura de alto nivel del código. Los metadatos describen todas las clases y los miembros de clase que se definen en el ensamblado, así como las clases y miembros de clase de otros ensamblados que son invocados por el ensamblado actual. Los metadatos de un método contienen la descripción completa del método, incluyendo la clase (y el ensamblado que contiene la clase), el tipo de retorno y todos los parámetros del método.

Un compilador de un lenguaje .Net generará los metadatos y los almacenará en el ensamblado que contiene el CIL. Cuando el CLR ejecute el CIL comprobará que los metadatos del método llamado coinciden con los metadatos almacenados en el método llamante. Esto asegura que sólo se pueda invocar el método con el número y tipo de parámetros correctos.

Atributos[editar]

Los desarrolladores pueden añadir metadatos a su código a través de atributos. Existen dos tipos de atributos, personalizados y pseudo personalizados, presentando ambos tipos la misma sintaxis de cara al desarrollador. Los atributos en el código son mensajes que indican al compilador que genere metadatos. En el CIL, los metadatos tales como modificadores de herencia, los modificadores de alcance, y prácticamente cualquier cosa que no sea un código de operación o un flujo de datos, son denominados también atributos.

Un atributo personalizado es una clase regular que hereda de una clase Atributte. Un atributo personalizado puede utilizarse sobre cualquier método, propiedad, clase, o incluso sobre el ensamblado completo, empleando la siguiente sintaxis: [Nombre del atributo(parámetro opcional, pares nombre=valor opcionales)] como en el siguiente ejemplo:

 [Custom]
 [Custom(1)]
 [Custom(1, comment="yes")]

Los atributos personalizados se usan de forma generalizada en el .NET Framework. Windows Communication Framework emplea atributos para definir contratos de servicio, ASP.NET para exponer métodos en forma de servicios web, LINQ to SQL los emplea para definir el mapeo de clases al esquema relacional subyacente, Visual Studio los utiliza para agrupar propiedades de objetos, los desarrolladores de clases indican la categoría de la clase del objeto aplicando el atributo personalizado [Category]. Los atributos perosonalizados son interpretados por el código de aplicación y no por el CLR. Cuando el compilador observa un atributo personalizado, genera unos metadatos personalizados que no puede reconocer el CLR. El desarrollador tiene que proporcionar el código necesario para poder leer los metadatos y actuar sobre ellos. A modo de ejemplo, el atributo que se muestra a continuación podría ser manejado por el código:

class CustomAttribute : Attribute
{
   int ParamNumber = 0;
   string Comment = "";
 
   public CustomAttribute () { }
   public CustomAttribute (int num) { ParamNumber = num; }
 
   public String comment
   {
      set { Comment = value; }
      get { return Comment; }
   }
}

El nombre de la clase se mapea al nombre del atributo. El compilador de Visual C# añade automáticamente la cadena "attribute" al final del nombre del atributo. Por lo tanto, toda clase que implemente el manejo de un atributo debe finalizar con esta cadena, pero la utilización de esta cadena es opcional cuando se emplee el atributo. La utilización del atributo invoca el constructor de la clase. Se permiten constructores sobrecargados. Los pares Nombre-Valor se mapean a propiedades, siendo el nombre el de la propiedad y el valor proporcionado el establecido por la propiedad.

Un atributo pseudo-personalizado se emplea de la misma forma que un atributo personalizado convencional, pero no posee un manejador personalizado; en su lugar, el compilador percibe intrínsecamente estos atributos y maneja el código marcado con estos atributos de una forma diferente. Atributos tales como Serializable y Obsolete están implementados como atributos pseudo-personalizados.

Metadata storage[editar]

Assemblies contain tables of metadata. These tables are described by the CIL specification. The metadata tables will have zero or more entries and the position of an entry determines its index. When CIL code uses metadata it does so through a metadata token. This is a 32-bit value where the top 8 bits identify the appropriate metadata table, and the remaining 24 bits give the index of the metadata in the table. The Framework SDK contains a sample called metainfo that will list the metadata tables in an assembly, however, this information is rarely of use to a developer. Metadata in an assembly may be viewed using the ILDASM tool provided by the .NET Framework SDK.

Reflection[editar]

Reflection is the API used to read .NET metadata. The reflection API provides a logical view of metadata rather than the literal view provided by tools like metainfo. Reflection in version 1.1 of the .NET framework can be used to inspect the descriptions of classes and their members, and invoke methods. However, it does not allow runtime access to the CIL for a method. Version 2.0 of the framework allows the CIL for a method to be obtained.

Other Metadata Tools[editar]

Besides the System.Reflection namespace, other tools are also available that can be used to handle metadata. The Microsoft .NET Framework ships a CLR metadata manipulation library that is implemented in native code. Third party tools to retrieve and manipulate metadata include PostSharp and Mono Cecil can also be used.