CIL (el nombre propio de MSIL) y el código de bytes de Java son más iguales que diferentes. Sin embargo, existen algunas diferencias importantes:
1) CIL fue diseñado desde el principio para servir como un objetivo para múltiples idiomas. Como tal, es compatible con un sistema de tipos mucho más rico que incluye tipos firmados y sin firmar, tipos de valor, punteros, propiedades, delegados, eventos, genéricos, un sistema de objetos con una sola raíz y más. CIL admite funciones que no son necesarias para los lenguajes CLR iniciales (C # y VB.NET), como funciones globales y optimizaciones de llamadas finales . En comparación, el código de bytes de Java se diseñó como un objetivo para el lenguaje Java y refleja muchas de las limitaciones que se encuentran en el propio Java. Sería mucho más difícil escribir C o Scheme usando el código de bytes de Java.
2) CIL fue diseñado para integrarse fácilmente en bibliotecas nativas y código no administrado
3) El código de bytes de Java se diseñó para ser interpretado o compilado, mientras que CIL se diseñó asumiendo únicamente la compilación JIT. Dicho esto, la implementación inicial de Mono utilizó un intérprete en lugar de un JIT.
4) CIL fue diseñado ( y especificado ) para tener una forma de lenguaje ensamblador legible y de escritura que se asigna directamente a la forma de código de bytes. Creo que el código de bytes de Java (como su nombre lo indica) estaba destinado a ser solo legible por máquina. Por supuesto, el código de bytes de Java se descompila con relativa facilidad en el Java original y, como se muestra a continuación, también se puede "desensamblar".
Debo señalar que el JVM (la mayoría de ellos) está más optimizado que el CLR (cualquiera de ellos). Por lo tanto, el rendimiento en bruto podría ser una razón para preferir apuntar al código de bytes de Java. Sin embargo, este es un detalle de implementación.
Algunas personas dicen que el código de bytes de Java fue diseñado para ser multiplataforma, mientras que CIL fue diseñado solo para Windows. Este no es el caso. Hay algunos ismos de "Windows" en el marco .NET pero no hay ninguno en CIL.
Como ejemplo del punto número 4) anterior, escribí un compilador de Java para CIL de juguete hace un tiempo. Si alimenta este compilador con el siguiente programa Java:
class Factorial{
public static void main(String[] a){
System.out.println(new Fac().ComputeFac(10));
}
}
class Fac {
public int ComputeFac(int num){
int num_aux ;
if (num < 1)
num_aux = 1 ;
else
num_aux = num * (this.ComputeFac(num-1)) ;
return num_aux ;
}
}
mi compilador escupirá el siguiente CIL:
.assembly extern mscorlib { }
.assembly 'Factorial' { .ver 0:0:0:0 }
.class private auto ansi beforefieldinit Factorial extends [mscorlib]System.Object
{
.method public static default void main (string[] a) cil managed
{
.entrypoint
.maxstack 16
newobj instance void class Fac::'.ctor'()
ldc.i4 3
callvirt instance int32 class Fac::ComputeFac (int32)
call void class [mscorlib]System.Console::WriteLine(int32)
ret
}
}
.class private Fac extends [mscorlib]System.Object
{
.method public instance default void '.ctor' () cil managed
{
ldarg.0
call instance void object::'.ctor'()
ret
}
.method public int32 ComputeFac(int32 num) cil managed
{
.locals init ( int32 num_aux )
ldarg num
ldc.i4 1
clt
brfalse L1
ldc.i4 1
stloc num_aux
br L2
L1:
ldarg num
ldarg.0
ldarg num
ldc.i4 1
sub
callvirt instance int32 class Fac::ComputeFac (int32)
mul
stloc num_aux
L2:
ldloc num_aux
ret
}
}
Este es un programa CIL válido que puede introducirse en un ensamblador CIL como ilasm.exepara crear un ejecutable. Como puede ver, CIL es un lenguaje completamente legible y de escritura. Puede crear fácilmente programas CIL válidos en cualquier editor de texto.
También puede compilar el programa Java anterior con el javaccompilador y luego ejecutar los archivos de clase resultantes a través del javap"desensamblador" para obtener lo siguiente:
class Factorial extends java.lang.Object{
Factorial();
Code:
0: aload_0
1: invokespecial #1;
4: return
public static void main(java.lang.String[]);
Code:
0: getstatic #2;
3: new #3;
6: dup
7: invokespecial #4;
10: bipush 10
12: invokevirtual #5;
15: invokevirtual #6;
18: return
}
class Fac extends java.lang.Object{
Fac();
Code:
0: aload_0
1: invokespecial #1;
4: return
public int ComputeFac(int);
Code:
0: iload_1
1: iconst_1
2: if_icmpge 10
5: iconst_1
6: istore_2
7: goto 20
10: iload_1
11: aload_0
12: iload_1
13: iconst_1
14: isub
15: invokevirtual #2;
18: imul
19: istore_2
20: iload_2
21: ireturn
}
El javapresultado no es compilable (que yo sepa) pero si lo compara con el resultado de CIL anterior, puede ver que los dos son muy similares.