Unterschiede zwischen MSIL und Java-Bytecode?

Zunächst einmal möchte ich sagen, dass ich nicht glaube, dass die subtilen Unterschiede zwischen Java bytecode und MSIL ist etwas, das sollte die Mühe einem Anfänger .NET-Entwickler. Beide dienen dem gleichen Zweck, der Definition der abstrakten Zielmaschine, die eine Ebene über der physischen Maschine verwendet wird, in das Ende.

MSIL-und Java-bytecode sind sehr ähnlich, in der Tat gibt es ein tool namens Heuschrecke die MSIL übersetzt, um Java-bytecode, ich war Teil des Entwicklungsteams für die Heuschrecke, so kann ich teilen, ein bisschen von meinem (verblichenen) wissen.
Bitte beachten Sie, dass ich aufgehört zu arbeiten auf diese um, wenn .NET framework 2.0 kam also einige dieser Dinge kann nicht wahr sein (wenn ja, bitte einen Kommentar hinterlassen und ich werde es richtig).

• .NET erlaubt es, benutzerdefinierte Typen, die Wert-Semantik, die als adaptiert auf die regelmäßige Referenz-Semantik (struct).
• .NET unterstützt unsigned-Typen, das macht der Befehlssatz ein bisschen reicher.
• Java enthält die exception-Spezifikation von Methoden in den bytecode. Obwohl Ausnahme-Spezifikation ist in der Regel nur durchgesetzt werden, indem der compiler, es kann erzwungen werden, indem die JVM, wenn ein class loader eine andere als die Standardeinstellung verwendet wird.
• .NET generics sind ausgedrückt in IL, während das Java generics verwenden Sie nur type erasure.
• .NET-Attribute haben keine Entsprechung in Java (ist das noch immer wahr?).
• .NET enums sind nicht viel mehr als Wrapper integer-Typen, während Java Enumerationen sind ziemlich vollwertige Klassen (Dank Internet-Freund für die Kommentare).
• .NET hat out und ref Parameter.

Gibt es andere sprachliche Unterschiede, aber die meisten von Ihnen sind nicht ausgedrückt an der byte-code-Ebene, zum Beispiel, wenn der Speicher dient Java ist nichtstatic innere Klassen (die nicht existieren .NET) sind keine bytecode-Funktion generiert der compiler ein zusätzliches argument zu der inneren Klasse den Konstruktor und übergibt die äußeren Objekt. Das gleiche gilt für .NET lambda-Ausdrücke.

InformationsquelleAutor der Antwort Motti

CIL (der richtige name für MSIL) und Java-bytecode sind mehr die gleichen, als Sie anders sind. Es gibt einige wichtige Unterschiede, obwohl:

1) CIL wurde von Anfang an als Ziel für mehrere Sprachen. Als solche unterstützt es eine viel reichere Typ system einschließlich signed-und unsigned-Typen, Datentypen, Zeiger, Eigenschaften, Delegaten, Ereignisse, Generika, ein Objekt-system mit einer einzigen Wurzel, und mehr. CIL unterstützt Funktionen, die nicht erforderlich für das erste CLR-Sprachen (C# und VB.NET) wie Globale Funktionen und tail-call-Optimierungen. Im Vergleich, Java-bytecode wurde als Ziel für die Java-Sprache und spiegelt viele der Marker gefunden, in Java selbst. Es wäre viel schwieriger zu schreiben, C oder Scheme mit Hilfe von Java-bytecode.

2) CIL wurde entwickelt, um eine einfache Integration in native-Bibliotheken und nicht verwalteten code

3) Java-bytecode entworfen, um entweder interpretiert oder kompiliert, während CIL wurde entwickelt, vorausgesetzt, die JIT-Kompilierung nur. Das heißt, die erste Implementierung von Mono verwendet einen interpreter anstelle eines JIT.

4) CIL konzipiert wurde (und angegeben) zu einer lesbaren und beschreibbaren assembly-Sprache, die form, die Karten direkt auf dem bytecode-form. Ich glaube, dass Java-bytecode wurde (wie der name schon sagt) gemeint zu sein, nur maschinenlesbar. Der Kurs, der Java-bytecode ist relativ leicht dekompiliert zurück zur ursprünglichen Java-und, wie unten gezeigt, es kann auch "zerlegt".

Sollte ich beachten Sie, dass die JVM (die meisten von Ihnen) ist höher optimiert als die CLR (jeder von Ihnen). So, raw-Leistung könnte ein Grund sein, lieber targeting Java-bytecode. Dies ist eine Implementierung detail, obwohl.

Einige Leute sagen, dass der Java-bytecode wurde entwickelt, um multi-Plattform, während CIL wurde entwickelt, um nur Windows. Dies ist nicht der Fall. Es gibt einige "Windows" - Ismen in der .NET framework, aber es sind keine in CIL.

Als ein Beispiel für die Punkt-Zahl 4) oben schrieb ich ein Spielzeug Java-CIL-compiler eine Weile zurück. Wenn Sie füttern diese compiler die folgende Java-Programm:

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 ;
    }
}

mein compiler spuckt folgende 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
   }
}

Dies ist eine gültige CIL-Programm eingespeist werden kann, in einem CIL-assembler wie ilasm.exe erstellen Sie eine ausführbare Datei. Wie Sie sehen können, CIL ist eine vollständig lesbare und schreibbare Sprache. Sie können ganz einfach erstellen Sie gültigen CIL-Programme, die in einem beliebigen text-editor.

Können Sie auch kompilieren des Java-Programms mit der javac - compiler und führen Sie dann die resultierenden class-Dateien durch die javap "disassembler", um die folgenden:

class Factorial extends java.lang.Object{
Factorial();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:   new #3; //class Fac
   6:   dup
   7:   invokespecial   #4; //Method Fac."<init>":()V
   10:  bipush  10
   12:  invokevirtual   #5; //Method Fac.ComputeFac:(I)I
   15:  invokevirtual   #6; //Method java/io/PrintStream.println:(I)V
   18:  return

}

class Fac extends java.lang.Object{
Fac();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   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; //Method ComputeFac:(I)I
   18:  imul
   19:  istore_2
   20:  iload_2
   21:  ireturn
}

Den javap Ausgang ist nicht kompilierbar (meines Wissens nach) aber wenn Sie es vergleichen, um die CIL-Ausgabe oben sehen Sie, dass die beiden sich sehr ähnlich sind.

InformationsquelleAutor der Antwort Justin

Gibt es nicht viel Unterschiede. Beide sind mittleren Formaten der code, den Sie schrieb. Wenn es ausgeführt wird, den Virtuellen Maschinen ausgeführt wird, die intermediate language verwaltet, die bedeutet, dass die Virtuelle Maschine steuert den Variablen und Aufrufe. Es gibt sogar eine Sprache, die ich nicht kenne, gerade jetzt, das betrieben werden kann .Net und Java auf die gleiche Weise.

Im Grunde, es ist nur ein anderes format für die gleiche Sache

Edit: Gefunden, die Sprache (neben Scala): Es ist ein FAN (http://www.fandev.org/), sieht sehr interessant, aber noch gar keine Zeit, um zu bewerten

InformationsquelleAutor der Antwort GHad

Serge Lidin verfasste ein anständiges Buch über die details des MSIL: Experte .NET 2.0 IL Assembler. Ich war auch in der Lage zu pick-up MSIL schnell durch den Blick auf die einfachen Methoden mit .NET Reflector und Ildasm (Tutorial).

Konzepte zwischen den MSIL-und Java-bytecode sehr ähnlich sind.

InformationsquelleAutor der Antwort Jeffrey LeCours