Common Language Runtime
description
Transcript of Common Language Runtime
Common Language Runtime
Dr. Diego Lz. de Ipiña Gz. de Artaza
Common Language Runtime
EL Common Language Runtime es el núcleo de la plataforma .NET.
Es el responsable de la gestión y ejecución del código compilado para la plataforma .NET (código gestionado).
Common Language Runtime
Estos son algunos de los servicios y características que provee el CLR: Integración multilenguaje: El CLR permite
integrar código escrito en un lenguaje con código escrito en otro (CLS)
Depuración y administración de servicios: El CLR provee de los mecanismos necesarios para que los desarrolladores puedan depurar y administrar el código gestionado.
Common Language Runtime
Gestión de memoria: El CLR, a través de su servicio de recolección de basuras, es el responsable de recoger de memoria los objetos no referenciados (Garbage collector)
Common Language Runtime
Vamos a ver qué no es el CLR:Las aplicaciones .NET no son interpretadas
por una “maquina virtual”: El CLR compila el código MSIL a código máquina nativo.
El CLR no está limitado a la plataforma Microsoft: Es “técnicamente” posible portar el CLR a otras plataformas hardware, así como a otros SO. Proyecto Mono: http://www.go-mono.com/
Anatomía de las aplicaciones .NET
Tenemos 3 entidades principales:Ensamblado o Assembly que es la
unidad principal de desarrollo de .NET.
Módulos o Modules que son los ficheros individuales que conforman un ensamblado.
IL es el código del programador que conforma el módulo.
Anatomía de las aplicaciones .NET
Manifest
Metadata
Tipos
Assembly o Ensamblado
Module
IL
Ensamblado o Assembly
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.
Es la unidad de trabajo del CLR.Permiten abstraerse de la ubicación
física del código o de los recursos.
Ensamblado o Assembly Todo ensamblado contiene un manifiesto, que
son metadatos con información sobre las características del ensamblado: Identidad (nombre, versión...) Nombres de los ficheros del ensamblado Clave hash de todos los ficheros Detalles sobre los tipos definidos en el ensamblado
(accesibilidad desde otros...) Nombres y hashes de otros ensamblados Permisos de seguridad Una lista de los tipos de datos exportados desde
otros ficheros
Ensamblado o AssemblyDos tipos de ensamblado:
Privados: Solo es usado por una aplicación que se encuentra en la misma subcarpeta. Es el tipo que crea el compilador por defecto.También llamadas weakly named assemblies
Públicos o compartidos: Son ensamblados creados para ser usados por cualquier aplicación. Se almacenan en la caché global de ensamblado. Deben ser strongly named (contiene la clave
pública y firma digital del que publica).
Ensamblado o Assembly
Ventajas de los ensamblados:No hace falta instalación.
Los ensamblados son auto-descriptivos (manifiesto).
Versionado.Eliminan el infierno de las DLLs.
Ensamblados públicos frente a registro a nivel de máquina.
Módules o Modules Los módulos son ficheros que pueden ser de
dos tipos: ficheros o módulos de recursos(ficheros.gif, .html,
etc.). ficheros o módulos de código compilado(código
MSIL). En la plataforma .NET se distinguen tres tipos
de módulos de código compilado: Ejecutables (ficheros.exe) . Librerías de enlace dinámico (ficheros.dll). Módulos que conforman un ensamblado
(ficheros.netmodule)
Módules o Modules Ambos ficheros contienen definiciones de
tipos de datos y tan solo los primeros (ejecutables) tienen un punto de entrada a partir del que es posible ejecutar el código.
A ambos tipos de módulos se les suele llamar ejecutables portables (PE), ya que su código puede ser ejecutado por un CLR de cualquier plataforma siempre que se encuentren en un ensamblado (en estos momentos tan solo familia Windows).
Módules o Modules
Un módulo de código compilado se compone de:Cabecera de CLR que le informa de si es
un módulo gestionado, la versión del CLR que necesita, su firma digital...
Los metadatos que son información sobre los tipos definidos en su código.
Código MSIL.
Microsoft Intermediate Language (MSIL)
Todos los compiladores que generan código para la plataforma .NET generan código escrito en un lenguaje intermedio conocido como MSIL.
De esta forma, MSIL es el único código que el CLR comprende.
Herramientas de la plataforma
Csc.exe
Vbc.exe
MSILMSIL facilita la ejecución
multiplataforma y la integración entre lenguajes al ser independiente de la CPU.
La CPU solo ejecuta código nativo luego alguien tiene que encargarse de transformar este código MSIL en código nativo para la CPU.
MSIL 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 según sea necesario.
Este jitter se distribuye en tres versiones: Normal Económico Prejitter
Jitter NormalEs el que se suele usar por defecto, y
sólo compila el código MSIL a código nativo a medida que va siendo necesario.
Así se ahorra tiempo y memoria al evitarse tener que compilar innecesariamente código que nunca se ejecute.
Jitter Normal El cargador de clases del CLR sustituye
inicialmente las llamadas a métodos de las nuevas clases que vaya cargando por llamadas a funciones auxiliares (stubs) que se encarguen de compilar el verdadero código del método.
Una vez compilado, la llamada al stub es sustituida por una llamada directa al código ya compilado, con lo que posteriores llamadas al mismo no necesitarán compilación.
Jitter Económico Funciona de forma similar al jitter normal
solo que no realiza ninguna optimización de código al compilar sino que traduce cada instrucción MSIL por su equivalente en el código máquina sobre la que se ejecute.
Se utiliza en dispositivos empotrados con poca memoria y potencia de CPU.
Aunque genere código más ineficiente es menor el tiempo y memoria que necesita para compilar.
Jitter Económico Para ahorrar memoria este jitter puede
descargar código ya compilado que lleve cierto tiempo sin ejecutarse y sustituirlo de nuevo por el stub apropiado.
Por estas razones, este es el jitter usado por defecto en Windows CE, sistema operativo que se suele incluir en los dispositivos empotrados antes mencionados.
Prejitter Permite compilar completamente cualquier
ejecutable o librería (cualquier ensamblado en general) que contenga código gestionado y convertirlo a código nativo.
De este modo posteriores ejecuciones del mismo se harán usando esta versión ya compilada y no se perderá tiempo en hacer la compilación dinámica.
Herramientas de la plataforma
Ngen.exe
Compilación dinámica La compilación dinámica supone que la
aplicación se ejecute más lentamente. Es una solución más eficiente que la utilizada
en Java donde se interpreta cada código. Permite que el jitter tenga más información
sobre la máquina que un compilador tradicional pudiendo optimizar el código generado para ella (usando instrucciones para PentiumIV, registros extra...)
Metadatos del Módulo Los metadatos son un conjunto de datos
organizados en forma de tablas que pueden almacenan información sobre: Tipos definidos en el módulo. Los miembros de estos tipos. Tipos externos a los que se hace referencia.
El compilador los genera automáticamente al crear el módulo.
Metadatos del Módulo
Los metadatos de un módulo pueden ser consultados a través del espacio de nombres System.Reflection de la FCL.
También podemos añadir información adicional en los metadatos a través de los atributos.
Integración MultilenguajeUna de las características avanzadas
de la plataforma .NET es la integración multilenguaje.
Podemos integrar aplicaciones escritas en un lenguaje de la plataforma con código escrito en otro lenguaje.
Para ello vamos a ver dos conceptos fundamentales: CTS y CLS.
Common Type System (CTS) 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.
Aunque cada lenguaje gestionado disponga de sus propia sintaxis para definir tipos de datos, en el MSIL resultante de la compilación de sus códigos fuente se ha de cumplir las reglas del CTS.
Common Type System (CTS)Algunos ejemplos de estas reglas son:
Cada tipo de dato puede constar de cero o más miembros. Cada uno de estos miembros puede ser un campo, un método una propiedad o un evento.
No puede haber herencia múltiple, y todo tipo de dato ha de heredar directa o indirectamente de System.Object.
Clasificación de tipos del CTSTipos
Valor Referencia
Enumeraciones
De usuario
Predefinidos InterfacesAuto-
descriptivosPunteros
ArraysClases
DelegadosBoxedDe usuario
Tipos del CTS
El CTS clasifica los tipos en dos bloques: Por valor: Se almacenan en la pila. Todos los
datos de tipo por valor descienden de System.ValueTypes el cuál desciende de System.Object.
Por referencia: Se almacenan en el Heap (montón de datos). Todos los datos de los tipos por referencia descienden directamente de System.Object.
Tipos por valor
Pila Pila Pila
Instancia
Montón gestionado
Montón gestionado
Montón gestionado
El CLR necesita crear una instancia de un tipo por valor
Se reserva memoria en la pila
Cuando se sale del ámbito de la variable, su espacio de memoria se libera
Tipos por referencia
Heap Heap Heap
Instancia
Montón gestionado
Montón gestionado
Montón gestionado
El CLR necesita crear una instancia de un tipo por valor
Se reserva memoria en la pila
Cuando se sale del ámbito de la variable, su espacio de memoria se libera
Valor vs. Referencia Diferencias:
Liberación de memoria:Los tipos por referencia hay que eliminarlos
explícitamente del montón (GC).
Asignación:La asignación de tipos por referencia copia direcciones
de memoria.
Comparación de igualdad:La comparación de tipos por referencia compara
direcciones de memoria.
.NET built-in types INET C# VB.NET IL Valor o
Referen.
System.Boolean bool Boolean bool Valor
System.Byte byte Byte unsigned int8 Valor
System.Char char Char char Valor
System.DateTime - Date - Valor
System.Decimal decimal Decimal - Valor
System.Double double Double float64 Valor
System.Int16 short Short int16 Valor
System.Int32 int Integer int32 Valor
.NET built-in types IINET C# VB.NET IL Valor o
Referen.
System.Int64 long Long int64 Valor
System.Object object Object Object Reference
System.SByte sbyte - int8 Valor
System.Single float Single float32 Valor
System.String string String string Reference
System.UInt16 ushort - unsigned int16 Valor
System.UInt32 uint - Unsigned int32 Valor
System.UInt64 ulong - Unsigned int64 Valor
.NET built-in types III Como vemos CTS es un sistema de tipos independiente
del lenguaje de programación No todos los tipos son soportados en cada lenguaje, por
ejemplo Date: En esos casos se puede usar el tipo .NET directamente:System.DateTime d = System.DateTime.Now;
CLS define un subconjunto de tipos de CTS que pueden ser usadas cuando se definen librerías multi-lenguaje Tipos no compatibles con CLS no son soportados por algunos
lenguajes Importante añadir atributo CLSCompliant a código para que el
compilador verifique los tipos usados
Tipos personalizados
EL Common Type System no sería muy flexible si no permitiese al programador crear sus propios tipos de datos.
Podremos definir tipos de datos personalizados tanto por valor como por referencia.
C# class y struct I Generalmente creamos un tipo personalizado a través de una clase:
public class Persona { public Persona(string nombre, string apellido1, int edad) { Nombre = nombre; Apellido1 = apellido1; Edad = edad; } public readonly string Nombre; public readonly string Apellido1; public readonly int Edad;
public bool Equals(Persona temp) {if (temp.Nombre == this.Nombre && temp.Apellido1 == this.Apellido1 && temp.Edad ==
this.Edad) {return true;
} else {return false;
}}
}...Persona p = new Persona(“Diego”, “Ipiña”, 29);Persona p1 = p; // p == p1Persona p2 = new Persona(“Diego”, “Ipiña”, 29); // p != p2
C# class y struct II Podemos crear nuevos tipos por valor a través de struct:
public struct Point { public Point(int x, int y) { this.x = x; this.y = y; } private int x; private int y;}...Point p = new Point(10,20);
Concepto boxing/unboxing Para asegurar que “todo sea un objeto”, .NET ofrece un
tipo por referencia por cada tipo por valor A esto se le denomina boxed type del tipo por valorint i = 123;object o = i; CLR creará un nuevo objeto conteniendo una copia de i en
el heap, una referencia al objeto se guardará en o. Para hacer un unbox de un tipo por referencia se usa
casting:int i = (int)o; Se generará InvalidCastException si se trata de hacer
un unbox de un tipo incompatible
v.Add(3); // se permite gracias al concepto de boxingv.Add(new Int32(3));
System.Object Es la clase base de la cual todos los tipos por referencia
de .NET derivan Provee los siguientes métodos:
Equals: verifica si dos instancias son iguales (implementación por defecto evalúa igualdad por referencia)
Finalize: ejecutado automáticamente cuando un objeto es destruido. En c# este método no aparece y se usa ~NombreObjeto como en C++
GetHashCode: produce un código hash del objeto, usado para guardar un objeto en una HashTable
GetType: devuelve el tipo de un objeto, posible a través de capacidades de Metadata en .NET
ReferenceEquals: verifica si dos instancias son idénticas ToString: devuelve una representación en forma de string
del objeto
Ejemplo System.Objectpublic class Pixel { public Pixel(byte x, byte y) { this.x = x; this.y = y; } private byte x; private byte y; public override string ToString() { // return “(x,y)” return “(“ + x + “,” + y + “)”; } public override bool Equals(object o) { try { Pixel p = (Pixel)o; return p.x == x && p.y == y; } catch (Exception) { return false; } } public override int GetHashCode() { return (x<<8) + y; }}...Pixel p = new Pixel(200, 150);Console.WriteLine(p);
Common Language Specification (CLS)
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.
Forman un subconjunto del CTS.
Common Language Specification (CLS)
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.
Si no importa la interoperabilidad entre lenguajes tampoco es necesario seguirlas.
Código accesible
Para crear código accesible a través de otros lenguajes debemos hacer dos cosas:Seguir las reglas definidas en la
especificación del CLS.Marcar el código a compartir como
compartible a través del atributo CLSCompliantAttribute.
Ejemplos
Variable por valor y por defectoDirectorio: 2-ejemplovalorref
InteroperatibilidadDirectorio: 3-interoperabilidad
Creando un multi-file assembly
Multi-file AssemblyVamos a crear un assembly que
consiste de dos clases:SimpleMath en VB.NET con métodos Add y
SubstractComplexMath en C# con método Square
Físicamente la assembly consistirá de:Simple.netmodule con SimpleMathComplex.netmodule con ComplexMathMath.dll que contiene el manifiesto
Multi-file Assembly Pasos para crear la assembly:
1. Crear Complex.cs (4-multifileassembly\Weak)2. Compilarlo: csc /target:module complex.cs3. Crear Simple.vb con: vbc /target:module
simple.vb4. Crear una assembly con AL (Assembly Linker) como:
al /target:library /out:Math.dll simple.netmodule complex.netmodule
5. Crear MathDemo.cs6. Compilar MathDemo con: csc /target:exe
/reference:math.dll mathdemo.cs7. Ejecutar mathdemo.exe