CIL o MSIL | Lenguaje intermedio de Microsoft o lenguaje intermedio común

El lenguaje intermedio de Microsoft (MSIL), también conocido como lenguaje intermedio común (CIL), es un conjunto de instrucciones que son independientes de la plataforma y son generadas por el compilador específico del lenguaje a partir del código fuente. MSIL es independiente de la plataforma y, en consecuencia, se puede ejecutar en cualquiera de los entornos compatibles con Common Language Infrastructure, como el tiempo de ejecución de Windows .NET . El compilador JIT
convierte el MSIL en un código de máquina específico del entorno informático particular . Esto se hace antes de que se pueda ejecutar MSIL. Además, el MSIL se convierte en el código de máquina según los requisitos, es decir, el compilador JIT compila el MSIL según sea necesario en lugar de todo.

Proceso de ejecución en Common Language Runtime (CLR): El proceso de ejecución que incluye la creación del MSIL y la conversión del MSIL en código de máquina por parte del compilador JIT es el siguiente:

• El código fuente se convierte en MSIL mediante un compilador específico del idioma en el tiempo de compilación de CLR. Además, junto con el MSIL, también se producen metadatos en la compilación. Los metadatos contienen información como la definición y firma de los tipos en el código, información de tiempo de ejecución, etc.
• Se crea un ensamblado de infraestructura de lenguaje común (CLI) ensamblando el MSIL. Este ensamblado es básicamente una biblioteca de código compilado que se usa para seguridad, implementación, control de versiones, etc. y es de dos tipos, es decir, ensamblado de proceso (EXE) y ensamblado de biblioteca (DLL).
• El compilador JIT luego convierte el lenguaje intermedio de Microsoft (MSIL) en el código de máquina que es específico para el entorno informático en el que se ejecuta el compilador JIT. El MSIL se convierte en el código de máquina según los requisitos, es decir, el compilador JIT compila el MSIL según sea necesario en lugar de todo.
• El código de máquina obtenido usando el compilador JIT es luego ejecutado por el procesador de la computadora.

Ejemplo: el compilador específico del idioma genera el MSIL a partir del código fuente que se proporciona a continuación. Para comprender el MSIL en detalle, el código fuente C# simple con la clase Demo que imprime “ GeeksforGeeks ” se proporciona de la siguiente manera:

using System;
  
public class Demo {
    public static void Main()
    {
        Console.WriteLine("GeeksforGeeks");
    }
}

El MSIL creado por el compilador de C# para el código proporcionado anteriormente es el siguiente:

// =============== CLASS MEMBERS DECLARATION ===================

.class public auto ansi beforefieldinit Demo
       extends [mscorlib]System.Object
{
  .method public hidebysig static void  Main() cil managed
  {
    // 
    .maxstack  8
    IL_0000:  nop
    IL_0001:  ldstr      "GeeksforGeeks"
    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
    IL_000b:  nop
    IL_000c:  ret
  } // end of method Demo::Main

  .method public hidebysig specialname rtspecialname 
          instance void  .ctor() cil managed
  {
    // 
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
    IL_0006:  ret
  } // end of method Demo::.ctor

} // end of class Demo


// =============================================================

En el MSIL anterior, hay códigos de operación que tienen uno o dos bytes de longitud. Las declaraciones de clase base de las que se heredan todas las demás clases están contenidas en mscorlib.dll . En el método Main(), la instrucción ldstr carga la string » GeeksforGeeks » en la pila. Luego se llama a la función estática System.Console.Writeline y la string se extrae de la pila. Finalmente, la instrucción ret señala el final de la llamada a la función.
Entonces el .ctor() implica un constructor predeterminado sin parámetros para la clase Demo. El compilador crea automáticamente este constructor para la demostración de clase no estática. La instrucción de llamada pasa al constructor del objeto base y la instrucción ret señala el final de la llamada a la función.