Voy a intentar explicar de forma breve en varios artículos como funciona el .NET Framework y que papel juegan sus diferentes partes. En esta primera parte a modo de introducción explicaré la diferencia entre el código fuente y el código administrado generado por el compilador, dejando el CLR y el JIT para una segunda parte.
Nuestro código C# (ó cualquier otro lenguaje con el que desarrollemos en .NET... por exótico que sea), es un leguaje de alto nivel con el componemos la lógica que queremos programar.
Aquí se puede ver una extensa lista de los lenguajes con los que se puede programar en .NET.
En lenguajes convencionales no administrados, el compilador es el encargado de generar código binario final a partir del código fuente, dicho código binario también se denomina código nativo, y es el que el procesador de nuestro ordenador puede interpretar.
Este código se genera para una determinada arquitectura, como pueden ser x86, x64 ó IA64 y en determinados casos para un determinado tipo de procesador. El hecho de compilarlo para una determinada arquitectura ó procesador como objetivo, permite optimizar el código al máximo aprovechando las optimizaciones y/ó juegos de instruciones específicos de ese objetivo. El problema, es que solo existe compatibilidad hacia atrás y no en todos los casos, por lo que lo que se compile para x64 no funcionará en x86 y si por ejemplo compilasemos explícitamente para Intel PIV, ejecutarlo en un Intel PIII podría causar problemas inésperados y difíciles de seguir al intentar por ejemplo, ejecutar instrucciones que no existen en el juego de instrucciones de Intel PIII.
En los lenguajes administrados, el compilador de nuestro IDE genera un código intermedio, a mitad de camino entre el lenguaje ensamblador y el lenguaje de alto nivel (más próximo al segundo que al primero) que se usará a posteriori para generar el código nativo que entiende nuestro procesador. En .NET este código es denominado código administrado, CIL (Common Intermediate Language) ó MSIL (Microsoft Intermediate Language). El compilador genera lo que se demomina ensamblado ó ensamble, donde además de nuestro código administrado se añade un manifiesto que es una descripción el esamblado, los recursos que hemos decidido incluir dentro del ensamblado y los metadatos, que son datos que describen los tipos, métodos y campos que lo componen.
Podemos ver el código administrado de un ensamblado mediante la herramienta Ildasm.exe.
Entre las principales ventajas de este método destacan ser independiente del lenguaje elegido y de la plataforma, de forma que cualquier lenguaje de .NET genera el mismo código administrado y este es independiente de la arquitectura donde se ejecute, a no ser que se indique explícitamente. En ocasiones, el ensamblado puede requerir de código nativo que sea dependiente de la plataforma, en las que podemos indicar que generamos en ensamblado para una determinada arquitectura, de forma que el .NET Framework nos avise de ello si intentamos ejecutarlo en otra distinta, pero esto no genera ninguna optimización especial del código administrado, simplemente es una restricción.
Este código es convertido a código nativo en tiempo de ejecución por medio del JIT, del que hablaré próximamente.
Subscribir