Glengamoi (Forum) · AspHeute · .NET Heute (RSS-Suche) · AspxFiles (Wiki) · .NET Blogs

Sprachenintegration in .NET

Geschrieben von: Christoph Wille
Kategorie: .NET Allgemein

This printed page brought to you by AlphaSierraPapa

Unter .NET sticht ein Feature besonders heraus - die Programmiersprachen setzen auf einem gemeinsamen Substrat auf, der Common Language Runtime (CLR). Dadurch wird eine Sprachintegration möglich, die es zuvor nicht gab: Klassen, die in Programmiersprache A entwickelt wurden, können in Programmiersprache B verwendet werden - und es kommt sogar besser: man kann über Sprachgrenzen Klassen voneinander ableiten!

Dieses Ableiten könnte so aussehen: die Basisklasse wird zB in C# entwickelt, und andere Programmierer - zB VB.NET Programmierer - leiten von dieser Basisklasse Subklassen in VB.NET ab. Solange sich alle beteiligten Programmierer an die Common Language Specification (CLS) halten, kein Problem. Apropos CLS: diese definiert welche Datentypen in allen Sprachen existieren müssen, und daher in öffentlich zugänglichen Teilen der Klassen exklusiv verwendet werden dürfen (mehr zur CLS findet man in der .NET SDK Dokumentation).

Heute wollen wir uns die Sprachintegration auf Ebene der Klassenprogrammierung in der Praxis genauer ansehen. Und zwar mit Code und Debugger!

Die Probe aufs Exempel

Als Programmierer glaubt man es erst, wenn man es wirklich sieht. Aus diesem Grund habe ich folgendes Beispiel konstruiert:

Eine Basisklasse wird in VB.NET implementiert (namens MyBaseClass). Diese enthält eine überladbare Funktion SayHello, sowie eine öffentliche Add Funktion als auch eine protected-Variante derselben namens InternalAdd. Die Klasse ist im Namespace InheritanceSamples gekapselt, die Klasse wird in eine Library Assembly (DLL) kompiliert.

Basierend auf der Basisklasse leite ich in C# die Klasse MySubClass ab. Diese überladt SayHello, und fügt eine Funktion Compute ein, die die protected Methode InternalAdd aufruft. Zusätzlich findet sich noch die Klasse App in der C# Datei, die uns ein Testprogramm für die Kommandozeile bereitstellt (könnte aber genauso gut getrennt, und in einer anderen Programmiersprache geschrieben sein).

Die Basisklasse

Was die Basisklasse tut, habe ich bereits besprochen. In der Datei MyBaseClass.vb findet sich die entsprechende Implementierung:

Imports System

Namespace InheritanceSamples

Public Class MyBaseClass
  Public Overridable Function SayHello() As String
    Return "Hello World from VB"
  End Function

  Public Function Add(nA As Long, nB As Long) As Long
    Return (nA+nB)
  End Function

  Protected Function InternalAdd(nA As Long, nB As Long) As Long
    Return (nA+nB)
  End Function
End Class

End Namespace

Kompiliert wird alles mit dem folgenden Kommando:

vbc /debug+ /t:library MyBaseClass.vb

Das debug+ Statement wird uns dann später erlauben, die Anwendung zu debuggen.

Die abgeleitete Klasse

Wie versprochen ist die abgeleitete Klasse in C# implementiert (MySubClass.cs). In App.Main rufe ich verschiedene Methoden der abgeleiteten Klasse als auch der Basisklasse auf (Testszenarien):

using System;
using InheritanceSamples;

public class MySubClass : MyBaseClass
{
  public override string SayHello()
  {
    return "Hello World from C#";
  }

  public long Compute()
  {
    return InternalAdd(3, 8);
  }
}

public class App
{
  static void Main()
  {
    MySubClass objSubClass = new MySubClass();
    Console.WriteLine(objSubClass.SayHello());
    Console.WriteLine(objSubClass.Add(5, 10));
    Console.WriteLine(objSubClass.Compute());

    MyBaseClass objBaseClass = new MyBaseClass();
    Console.WriteLine(objBaseClass.SayHello());
  }
}

Kompiliert wird das ganze wie folgt:

csc /r:MyBaseClass.dll /debug+ /out:client.exe /main:App MySubClass.cs

Der Output der Applikation sieht so aus:

Hello World from C#
15
11
Hello World from VB

Die Applikation bestehend aus mehreren Programmiersprachen funktioniert also - was hinter den Kulissen passiert, werden wir uns nun mit dem Debugger ansehen.

Debuggen von mehrsprachigen Anwendungen

Netterweise bekommt man im SDK einen Debugger mitgeliefert. In der Beta 2 hatte er allerdings noch keinen Menüeintrag, man mußte ihn direkt aus dem GuiDebug Verzeichnis starten:

Da unsere Applikation schon kompiliert vorliegt, wählen wir diese mittels Debug/Program to Debug:

In der Dialogbox kann man nach client.exe suchen:

Damit könnte man bereits eine Debug-Session starten (einfach F5 drücken). Allerdings sollte man vorher noch in der Datei MySubClass.cs einen Breakpoint auf die erste Zeile der Main Methode setzen, weil sonst läuft das Programm einfach durch:

So - und jetzt aber starten wir die Debugging-Session mit F5. Wie erwartet stoppt die Programmausführung auf unserem Breakpoint, ich bin aber bereits mit Step Over auf den Aufruf der Add Methode gegangen:

Dort verwende ich Step Into - und et voila, ich lande im Sourcecode meiner VB.NET Klasse!

Es ist jeder aufgefordert, das auszuprobieren - ja, das Debuggen von mehrsprachigen .NET Anwendungen ist so einfach!

Schlußbemerkung

Programmiersprachen können unter .NET sehr einfach miteinander verbunden werden - und steht diese Verbindung, ist auch das Testen solcher Anwendungen kein Problem. Also genau das Gegenteil dessen, was man vor .NET gewöhnt war.