Introducción a .NET Framework
.NET Framework es un entorno de
ejecución runtime que administra aplicaciones cuyo destino es .NET Framework. Incorpora
Common Language Runtime, que proporciona administración de la memoria y otros
servicios del sistema, y una biblioteca de clases completa, que permite a los
programadores aprovechar el código sólido y confiable de todas las áreas
principales del desarrollo de aplicaciones.
¿Qué es .NET Framework?
.NET Framework es un entorno de
ejecución administrado que proporciona diversos servicios a las aplicaciones en
ejecución. Consta de dos componentes principales: Common Language Runtime
(CLR), que es el motor de ejecución que controla las aplicaciones en ejecución,
y la biblioteca de clases de .NET Framework, que proporciona una biblioteca de
código probado y reutilizable al que pueden llamar los desarrolladores desde
sus propias aplicaciones.
Dentro del .NET
framework están integrados los lenguajes .NET (C#, VB.NET, J#),
el CRL, el CLS, ADO.NET, ASP.NET
...
.NET soporta varios
lenguajes de programación, siendo los más populares:
- C#
- VB.NET
- C++
- J#
- Delphi
CLR
El Common Language
Runtime (CLR) es el núcleo de la plataforma .NET. Es el motor
encargado de gestionar la ejecución de las aplicaciones para ella desarrolladas
y a las que ofrece numerosos servicios que simplifican su
desarrollo y favorecen su fiabilidad y seguridad.
El CLR permite que excepciones
lanzadas desde código para .NET escrito en un cierto lenguaje se puedan
capturar en código escrito usando otro lenguaje, e incluye mecanismos de
depuración que pueden saltar desde código escrito para .NET en un determinado
lenguaje a código escrito en cualquier otro. Por ejemplo, se puede recorrer la
pila de llamadas de una excepción aunque ésta incluya métodos definidos en
otros módulos usando otros lenguajes.
MSIL - Microsoft Intermediate Language
Ninguno de los compiladores
que generan código para la plataforma .NET produce 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 Lenguage (MSIL)
El CLR da a las aplicaciones la sensación de que se están ejecutando sobre una
máquina virtual, y precisamente MSIL es el código máquina de esa máquina
virtual. Es decir, 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.
Es un lenguaje de un nivel de
abstracción mucho más alto que el de la mayoría de los códigos máquina de las
CPUs existentes, e incluye instrucciones que permiten trabajar directamente con
objetos (crearlos, destruirlos, inicializarlos, llamar a métodos virtuales,
etc.), tablas y excepciones (lanzarlas, capturarlas y tratarlas)
Ya se comentó
que el compilador de C# compila directamente el código fuente a MSIL, que
Microsoft ha desarrollado nuevas versiones de sus lenguajes Visual Basic
(Visual Basic.NET) y C++ (C++ con extensiones gestionadas) cuyos compiladores
generan MSIL, y que ha desarrollado un intérprete de JScript (JScript.NET) que
genera código MSIL. Pues bien, también hay numerosos terceros que han anunciado
estar realizando versiones para la plataforma .NET de otros lenguajes como APL,
CAML, Cobol, Eiffel, Fortran, Haskell, Java (J#), Mercury, ML, Mondrian,
Oberon, Oz, Pascal, Perl, Python, RPG, Scheme y Smalltalk.
La principal
ventaja del MSIL es que facilita la ejecución multiplataforma y la integración
entre lenguajes al ser independiente de la CPU y proporcionar un formato común
para el código máquina generado por todos los compiladores que generen código
para .NET.
Metadatos
En la plataforma .NET se
distinguen dos tipos de módulos de código compilado: ejecutables (extensión .exe)
y librerías de enlace dinámico (extensión.dll generalmente)
Ambos son ficheros que contienen definiciones de tipos de datos, y la
diferencia entre ellos es que sólo los primeros disponen de un método especial
que sirve de punto de entrada a partir del que es posible ejecutar el código que
contienen haciendo una llamada desde la línea de comandos del sistema
operativo. A ambos tipos de módulos se les suele llamar ejecutables
portables (PE), ya que su código puede ejecutarse en cualquiera de los
diferentes sistemas operativos de la familia Windows para los que existe alguna
versión del CLR.
Emsamblados - Assemblies
Un ensamblado es una agrupación lógica de uno o
más módulos o ficheros de recursos (ficheros .GIF, .HTML, etc.) que se engloban
bajo un nombre común. Un programa puede acceder a información o código
almacenados en un ensamblado sin tener que conocer cuál es el fichero en
concreto donde se encuentran, por lo que los ensamblados nos permiten
abstraernos de la ubicación física del código que ejecutemos o de los recursos
que usemos. Por ejemplo, podemos incluir todos los tipos de una aplicación en
un mismo ensamblado pero colocando los más frecuentemente usados en un cierto
módulo y los menos usados en otro, de modo que sólo se descarguen de Internet
los últimos si es que se van a usar.
La Librería de Clase Base (BCL)
La
Librería de Clase Base (BCL) es una librería incluida en el .NET
Framework formada por cientos de tipos de datos que permiten acceder a
los servicios ofrecidos por el CLR y a las funcionalidades más frecuentemente
usadas a la hora de escribir programas. Además, a partir de estas clases
prefabricadas el programador puede crear nuevas clases que mediante herencia
extiendan su funcionalidad y se integren a la perfección con el resto de clases
de la BCL. Por ejemplo, implementando ciertos interfaces podemos crear nuevos
tipos de colecciones que serán tratadas exactamente igual que cualquiera de las
colecciones incluidas en la BCL.
Espacio de nombres
|
Utilidad de los tipos de
datos que contiene
|
System
|
Tipos muy frecuentemente
usados, como los tipos básicos, tablas, excepciones, fechas, números
aleatorios, recolector de basura, entrada/salida en consola, etc.
|
System.Collections
|
Colecciones de datos de
uso común como pilas, colas, listas, diccionarios, etc.
|
System.Data
|
Manipulación de bases de
datos. Forman la denominada arquitectura ADO.NET.
|
System.IO
|
Manipulación de ficheros
y otros flujos de datos.
|
System.Net
|
Realización de
comunicaciones en red.
|
System.Reflection
|
Acceso a los metadatos
que acompañan a los módulos de código.
|
System.Runtime.Remoting
|
Acceso a objetos remotos.
|
System.Security
|
Acceso a la política de
seguridad en que se basa el CLR.
|
System.Threading
|
Manipulación de hilos.
|
System.Web.UI.WebControls
|
Creación de interfaces de
usuario basadas en ventanas para aplicaciones Web.
|
System.Windows.Forms
|
Creación de interfaces de
usuario basadas en ventanas para aplicaciones estándar.
|
System.XML
|
Acceso a datos en formato
XML.
|
Common Type System
El Common Type
System (CTS) o Sistema de Tipo Común es el conjunto de reglas que han
de seguir las definiciones de tipos de datos para que el CLR las acepte.
El Common Language Specification (CLS) o Especificación del
Lenguaje Común es un conjunto de reglas que han de seguir las definiciones de
tipos que se hagan usando un determinado lenguaje gestionado si se desea que
sean accesibles desde cualquier otro lenguaje gestionado. Obviamente, sólo es
necesario seguir estas reglas en las definiciones de tipos y miembros que sean
accesibles externamente, y no la en las de los privados. Además, si no
importa la interoperabilidad entre lenguajes tampoco es necesario seguirlas. A
continuación se listan algunas de reglas significativas del CLS:
Los tipos de datos básicos admitidos son bool, char, byte,
short, int, long, float, double, string y object. Nótese pues que no todos los lenguajes tienen
porqué admitir los tipos básicos enteros sin signo o el tipo decimal como lo hace C#.
Las tablas han de tener una o más dimensiones, y el
número de dimensiones de cada tabla ha de ser fijo. Además, han de indexarse
empezando a contar desde 0.
Se pueden definir tipos abstractos y tipos sellados. Los
tipos sellados no pueden tener miembros abstractos.
Las excepciones han de
derivar de System.Exception, los delegados de System.Delegate, las
enumeraciones de System.Enum, y
los tipos por valor que no sean enumeraciones deSystem.ValueType.
