El blog del burgués

14 septiembre 2010

Programación orientada a componentes: Fundamentos I

Filed under: Uncategorized — elburgues @ 6:54 AM

Antes de seguir hablando de los principios de la programación orientada a componentes, es necesario aclarar ciertos conceptos.

El Common Language Runtime (CLR)

El CLR provee un contexto común dentro del cual todos los componentes .NET se ejecutan, independientemente del lenguaje con el que han sido escritos. El CLR maneja cualquier aspecto del código en tiempo de ejecución, (gestión de la memoria, entorno seguro de ejecución, acceso a los servicios del sistema operativo subyacente…). O sea, que lo que hace el CLR es gestionar la ejecución de las aplicaciones diseñadas para la plataforma .NET. Por eso, al código de estas aplicaciones se le suele llamar código gestionado o manejado y al código no escrito para ser ejecutado directamente en la plataforma .NET se le suele llamar código no gestionado o no manejado.

Microsoft Intermediate Languaje (MSIL)

Compilar código manejado es un proceso que comprende dos fases_

  1. Todos los compiladores que generan código para la plataforma .NET no generan código máquina para CPUs x86 ni para ningún otro tipo de CPU concreta, sino que generan código escrito en el lenguaje intermedio conocido como Microsoft Intermediate Language (MSIL). MSIL es el único código que es capaz de interpretar el CLR, y por tanto cuando se dice que un compilador genera código para la plataforma .NET lo que se está diciendo es que genera MSIL definido por Microsoft.
  2. Ya que las CPUs no pueden ejecutar directamente MSIL, antes de ejecutarlo habrá que convertirlo al código nativo de la CPU sobre la que se vaya a ejecutar. De esto se encarga un componente del CLR conocido como compilador JIT (Just-In-Time) o jitter que va convirtiendo dinámicamente el código MSIL a ejecutar en código nativo. La actuación de un jitter durante la ejecución de una aplicación gestionada puede dar la sensación de hacer que ésta se ejecute más lentamente debido a que ha de invertirse tiempo en las compilaciones dinámicas. Esto es cierto, pero en .NET, cada código no es interpretado cada vez que se ejecuta sino que sólo es compilado la primera vez que se llama al método al que pertenece. El hecho de que la compilación se realice dinámicamente permite que el jitter tenga acceso a mucha información sobre la máquina en que se ejecutará la aplicación, con lo que puede optimizar el código para ella generado.

Metadatos

Cuando un cliente usa un servidor ¿Cómo sabe que tipos contiene, el espacio de nombres en el que está contenido cada tipo, el nombre de cada tipo, su visibilidad, su clase base, que interfaces soporta, sus métodos, el prototipo de cada método y cosas así? La solución que .NET da a este problema se llama metadatos. Los metadatos son un conjunto de datos organizados de forma estándar en tablas, generados por el compilador de alto nivel directamente desde los archivos fuente e incrustándolos en el archivo físico que contiene el MSIL.

El significado de los metadatos es similar al de otras tecnologías previas a la plataforma .NET como lo son los ficheros IDL (interface definition languaje). Sin embargo, los metadatos tienen ventajas:

  • Contienen más información.
  • Siempre se almacenan incrustados en el módulo al que describen, haciendo imposible la separación entre ambos.
  • Es posible consultar los metadatos de cualquier módulo a través de las clases del espacio de nombres System.Reflection. Por ejemplo, IntelliSense usa Reflection.

En otra entrada ya haremos un resumen de lo que son los ensamblados y los archivos manifiestos y con eso ya tendremos los fundamentos para seguir hablando de los principios de la programación orientada a componentes.

Anuncios

2 comentarios »

  1. Muy interesante tus dos entradas acerca de la POC. Actualmente se me ha asignado el trabajo de “refactorizar” código, para hacerlo orientado a componentes. Ya se tiene algo avanzado, pero aún seguimos identificando que clases pueden ser candidatas a ser expuestas mediante interfaces.

    Estaré esperando tu nueva entrada sobre este interesante paradigma de programación.

    Saludos

    Comentario por Jorge Muñoz — 18 febrero 2011 @ 11:29 PM | Responder

  2. Muy interesante el paradigma de POC. Muchas veces buscamos algo referido a este tema, pero nunca encontramos algo claro. Seria bueno que publicaras cosas mas prácticas, me refiero a que a veces no sabemos como estructurar una aplicación en componentes, es decir como definir las interfaces y en dónde ubicar los datos, esas cosas. Espero tu próxima publicacion.

    Comentario por Adriel — 15 diciembre 2011 @ 4:29 PM | Responder


RSS feed for comments on this post. TrackBack URI

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

Blog de WordPress.com.

A %d blogueros les gusta esto: