Arbeiten mit .NET: Allgemeines/ Entwicklungsumgebungen/ MonoDevelop

Dieses Kapitel beschreibt für MonoDevelop spezifische Vorgehensweisen. Nutzer einer anderen IDE richten sich bitte nach den Informationen in Microsoft Visual Studio oder SharpDevelop.

Eine komfortable IDE

MonoDevelop ist eine vollständige IDE (Integrated Development Environment, also Integrierte Entwicklungsumgebung) und bietet alles, was das Programmieren erleichtert:

• Syntax-Hervorhebung
• Code-Vervollständigung
• Zusammenfassung mehrerer Quelltexte zu Projekten
• schneller Wechsel zum Compiler mit Debugger
• integrierte Hilfe zum .NET Framework und zu den Mono-Bibliotheken

MonoDevelop steht kostenlos zur Verfügung, siehe Weblinks. Damit können sowohl NET-Anwendungen als auch Mono-Anwendungen entwickelt werden; man kann zwischen mehreren Programmiersprachen wählen – vorzugsweise C#, aber nicht nur.

Die Initiative zum Mono-Projekt und von MonoDevelop ging von Spanien aus. Die Entwicklung und Gestaltung der Oberfläche erfolgte in Englisch; die Übersetzung ins Deutsche ist unvollständig. In der Praxis sollte das aber kaum eine Einschränkung bedeuten.

Installation und Einrichtung

MonoDevelop verfügt über eine Installationsroutine. Welche Voraussetzungen erfüllt sein müssen, hängt von der Arbeitsumgebung ab (Betriebssystem, Framework).

Einzelheiten dazu siehe:

• .NET installieren
• Das Mono-Projekt

Windows, Linux, MacOS usw.

Die verschiedenen Systeme benutzen „natürlich“ unterschiedliche Bezeichnungen für gleichartige Verfahren. Diese werden wir nur in diesem Kapitel erwähnen. Normalerweise verwenden wir die Formulierungen, die im Zusammenhang mit dem .NET Framework üblich sind. Listen zum Vergleich stehen am Ende dieses Kapitels.

Einstellungen

Nach dem Start wartet, wie bei jedem komplexen Programm, die Einrichtung der Oberfläche. Dazu öffnen Sie im Menü Werkzeuge den Punkt Einstellungen. Legen Sie dort zunächst dies fest:

• Unter Einstellungen – Laden/Speichern wählen Sie als Standard vor allem ein Projektformat und ein Verzeichnis für Projektmappen.
• Unter Einstellungen – .NET-Runtimes wählen Sie, ob vorzugsweise für das .NET-Framework oder für Mono entwickelt wird. Unter Umständen muss vorher eine andere Laufzeitumgebung hinzugefügt werden.

Alle anderen Optionen können Sie sich einmal ansehen und später bei Bedarf anpassen. Wir weisen vor allem auf die Einstellungen zum Texteditor und auf die Codeausschnitte hin. Bestätigen Sie die Festlegungen mit OK.

Die Oberfläche

Bei MonoDevelop werden ähnliche Überlegungen wie bei anderen IDEs berücksichtigt. Dadurch fällt es relativ leicht, zwischen den IDE zu wechseln; lediglich die Verteilung der Zusatzfenster unterscheidet sich.

Der größte Teil des Bildschirms wird vom Hauptfenster eingenommen. Es enthält ggf. das Willkommen-Fenster mit den zuletzt bearbeiteten Projekten und während der Laufzeit die geöffneten Dokumente. Dieses Hauptfenster wird eingerahmt von verschiedenen zusätzlichen Informationen und Fenstern zur Auswahl:

• Links finden Sie:
  • die Übersicht der Klassen einer Projektmappe
  • die Übersicht der Projektmappen mit den dazugehörigen Projekten
  • unter dem Stichwort Dateien der Zugriff auf Laufwerke, Verzeichnisse und Dateien
  • mit NUnit eine Software für Unit-Tests
• Rechts finden Sie:
  • die Übersicht von Werkzeugen, die bei WinForms-Anwendungen auch die Controls anbietet
  • die Eigenschaften, vor allem wenn ein Formular in der Designer-Ansicht geöffnet ist
  • als Dokumentationsoutline die Bearbeitung der Dokumentation
• Unten finden Sie:
  • Aufgaben, die in verschiedenen Programmteilen zu erledigen sind
  • Fehlermeldungen und Warnungen
  • Ausgabe während des Programmablaufs
  • Lokale Variable zum Debuggen während des Programmablaufs
  • Testergebnisse
  • ein Nachrichtenprotokoll, das sich auf das Programm selbst bezieht

Diese Fenster kann man bei Bedarf ein- und ausblenden. Im ausgefahrenen Zustand findet sich im Titel eines solchen Fensters neben dem obligatorischen X zum Schließen ein kleines Icon zum „Docken“ – also der dauerhaften Anzeige – oder zum automatischem Ausblenden. Im Menübefehl Ansicht – Pads können Sie diese Fenster nach Bedarf öffnen.

Ein erstes Projekt

Hello World

Das einfachste Programm ist ein Hello World-Programm, das lediglich diesen Text ausgibt. Ein solches Programm dient seit Urzeiten in Lehrbüchern einmal als Test für den Lernenden, um sich mit der Programmierumgebung vertraut zu machen und zu prüfen, ob alles funktioniert. Andererseits zeigt es die notwendige Grundstruktur eines Programms auf. Ein solches Programm enthält eigentlich nur die folgenden Zeilen:

Hello World als Einstieg

C++-Quelltext

System::Console::WriteLine("Hello World");
System::Console::WriteLine("Ende mit beliebiger Taste");
System::Console::ReadKey();

C#-Quelltext

System.Console.WriteLine("Hello World");
System.Console.WriteLine("Ende mit beliebiger Taste");
System.Console.ReadKey();

Delphi.Prism-Quelltext

System.Console.WriteLine('Hello World');
System.Console.WriteLine('Ende mit beliebiger Taste');
System.Console.ReadKey();

VB.NET-Quelltext

System.Console.WriteLine("Hello World")
System.Console.WriteLine("Ende mit beliebiger Taste")
System.Console.ReadKey()

"Mein neues Auto" als Einstieg

Wir wollen ein etwas größeres Projekt vorbereiten, das später ausführlicher besprochen werden soll.

Eine Projektmappe (Englisch solution, also Problemlösung) enthält mehrere, in der Regel inhaltlich zusammengehörende Projekte. Ein Projekt (project) enthält alles, was zum Erstellen einer einzelnen Assembly (exe- oder dll-Datei) unter .NET oder Mono notwendig ist.

Das folgende Programm wird auch im Kapitel "Mein neues Auto" als erstes Programm bei jeder Programmiersprache besprochen. Einzelheiten des Codes werden deshalb hier überhaupt nicht erklärt; jetzt geht es uns nur um die Möglichkeiten der IDE mit der Eingabe des Codes, dem Erstellen des Programms und der Fehlersuche.

Ein Projekt hinzufügen

Für eine neue Projektmappe gibt es diese Möglichkeiten:

• Klicken Sie auf der Willkommen-Seite auf Starte ein neues Projekt.
• Wählen Sie im Menü Datei > Neu > Projektmappe.

Für ein neues Projekt gibt es diese Möglichkeit:

• Rechtsklick auf die Projektmappe im Projekte-Fenster und Hinzufügen > Neues Projekt.

Es öffnet sich ein Dialog für die grundlegenden Einstellungen des neuen Projekts. Wählen Sie in der linken Liste Ihre Programmiersprache und rechts Terminal-Projekt; das ist die Mono-Bezeichnung für eine Konsolenanwendung. Geben Sie einen Namen für das Projekt ein, z.B. "Mein neues Auto", dazu das Basisverzeichnis, z.B. "E:\Eigene Dateien\NET Projects\Wikibooks" und den Namen für die Projektmappe, z.B. "Einstieg". Bestätigen Sie die Eingaben durch Klicken auf Weiter und im nächsten Fenster sofort auf OK. Die IDE erstellt ein Gerüst mit allen Dateien, die für das neue Projekt nötig sind.

Solange es uns um einzelne Funktionalitäten der Arbeit mit .NET oder einer Programmiersprache geht, werden wir uns vorwiegend mit Konsolenanwendungen (Terminal-Projekten) befassen. Andere Anwendungen werden in den Themen-Büchern behandelt.

Der Quelltext-Editor

Je nach Situation wird das Hauptprogramm bereits angezeigt; oder Sie müssen es auswählen: Öffnen Sie unter Projekte, bis die Datei Main.cs bzw. Application.vb angezeigt wird. Ein Doppelklick darauf zeigt sie an.

Dreist, wie MonoDevelop ist, hat es für uns bereits ein Hello-World-Programm geschrieben. Damit wir die Arbeitsweise von MonoDevelop demonstrieren können, ändern Sie den vorgegebenen Code, sodass der untenstehende Code zu sehen ist.

• Löschen Sie zunächst die Zeile mit Hello, World.
• Bei C# ändern Sie die Zeile hinter namespace.
• Bei Visual Basic ergänzen Sie am Anfang und Ende die Zeilen mit Imports und Namespace. Die Zeilen mit Application und Main müssen nicht angepasst werden.
• Schreiben Sie den untenstehenden Code, beginnend in der Zeile nach Main bis einschließlich der ersten Zeile mit WriteLine. Beenden Sie den Code mit den beiden letzten Befehlszeilen.
• Beachten Sie, dass teilweise automatisch Einrückungen erfolgen und Klammern gesetzt werden.
• Schreiben Sie langsam und machen Sie vor allem nach einem Punkt und einer öffnenden Klammer eine kurze Pause.
• Schreiben Sie nach einem Punkt erst einmal nur einen Buchstaben und warten Sie wieder.

Bei C# achten Sie dabei darauf, was die IDE sozusagen vorschreibt (im Sinne von "voraus schreibt") und als Erläuterungen anzeigt. Hier bietet MonoDevelop Möglichkeiten an, die Zeile logisch zu beenden. Wenn weitere Informationen angeboten werden (durch einen Text wie "2 von 19"), dann blättern Sie mit den Pfeiltasten weiter. Bei Visual Basic (VB) gibt es leider fast keine derartigen Erleichterungen.

Den vorgegebenen Dateinamen und den Namen der Klasse müssen Sie nicht ändern. Das gehört zu den Besonderheiten von Mono – siehe die vergleichenden Listen am Ende dieses Kapitels.

Es ist nicht erforderlich, dass Sie alle Informationen sofort verstehen. Es geht jetzt nur darum, dass diese Hilfestellung angeboten wird, damit Sie bei der eigenen Programmierung darauf achten und dies nutzen.

Das Hauptprogramm

C#-Quelltext

using System;

namespace Wikibooks.CSharp.Mein_neues_Auto
{
	class Program
	{
		public static void Main(string[] args)
		{
			string input;
			if (DateTime.Now.Hour < 12) {
				Console.Write("Guten Morgen, ");
			} else if (DateTime.Now.Hour < 18) {
				Console.Write("Grüß Gott, ");
			} else 
				Console.Write("Guten Abend, ");
			Console.WriteLine(Environment.UserName);
			
			// Typ abfragen
			Console.WriteLine("Welchen Typ Auto wollen Sie sich zulegen?");
			input = Console.ReadLine();
			Car mycar = new Car(input, "998cm³ 44kW", 3);
			Console.WriteLine(mycar.ToString());
			// beschleunigen
			mycar.Accelerate(40);
			mycar.ShowValues();
			// rechts blinken
			mycar.SetRightSignal(true);
			mycar.ShowValues();
			// etwas bremsen
			mycar.Delay(20);
			mycar.ShowValues();
			// Blinker aus
			mycar.SetRightSignal(false);
			mycar.ShowValues();
			// wieder beschleunigen
			mycar.Accelerate(30);
			mycar.ShowValues();
			// Warnblinker ein
			mycar.SetBothSignals(true);
			mycar.ShowValues();
			// bremsen bis auf 0
			mycar.Delay(mycar.Speed);
			mycar.ShowValues();
			// Warnblinker aus
			mycar.SetBothSignals(false);
			mycar.ShowValues();
			                  
			Console.Write("Press any key to continue . . . ");
			Console.ReadKey(true);
		}
	}
}

VB.NET-Quelltext

Imports System

Namespace Wikibooks.VBNet.Mein_neues_Auto
	Module Program
		Sub Main(ByVal args As String())
			Dim input As String
			If DateTime.Now.Hour < 12 Then
				Console.Write("Guten Morgen, ")
			ElseIf DateTime.Now.Hour < 18 Then
				Console.Write("Grüß Gott, ")
			Else
				Console.Write("Guten Abend, ")
			End If
			Console.WriteLine(Environment.UserName)
			
			' Typ abfragen
			Console.WriteLine("Welchen Typ Auto wollen Sie sich zulegen?")
			input = Console.ReadLine()
			Dim mycar As New Car(input, "998cm³ 44kW", 3)
			Console.WriteLine(mycar.ToString())
			' beschleunigen
			mycar.Accelerate(40)
			mycar.ShowValues()
			' rechts blinken
			mycar.SetRightSignal(True)
			mycar.ShowValues()
			' etwas bremsen
			mycar.Delay(20)
			mycar.ShowValues()
			' Blinker aus
			mycar.SetRightSignal(False)
			mycar.ShowValues()
			' wieder beschleunigen
			mycar.Accelerate(30)
			mycar.ShowValues()
			' Warnblinker ein
			mycar.SetBothSignals(True)
			mycar.ShowValues()
			' bremsen bis auf 0
			mycar.Delay(mycar.Speed)
			mycar.ShowValues()
			' Warnblinker aus
			mycar.SetBothSignals(False)
			mycar.ShowValues()
			
			Console.Write("Press any key to continue . . . ")
			Console.ReadKey(True)
		End Sub
	End Module
End Namespace

Die Art, wie bei C# Code-Teile vorgeschlagen werden, wird als Code-Completion (Code-Vervollständigung) bezeichnet. Der ebenfalls verwendete Begriff IntelliSense ist für Microsoft Visual Studio reserviert.

Beachten Sie die folgenden Besonderheiten der Anzeige:

• Bestimmte Abschnitte des Codes sind farbig. Diese Funktion heißt Syntaxhervorhebung. Wörter in Rot-Braun sind zum Beispiel Begriffe, die im Code eine besondere Bedeutung haben, sogenannte Schlüsselwörter (dazu später mehr).
• Die Wörter in Anführungszeichen sind Zeichenketten, die im Programm erscheinen, wie wir gleich sehen.

Mit diesem Code soll nun die IDE arbeiten.

Dateien speichern

Vor dem nächsten Schritt speichert MonoDevelop die betroffenen Quelldateien automatisch. Wenn Sie während umfangreicher Arbeiten nicht kompilieren, sondern die IDE beenden, können Sie die geänderten Dateien gezielt speichern. Welche Dateien seit der letzten Speicherung geändert wurden, ersehen Sie aus dem Sternchen    Main.cs *    beim Dateinamen. Sie können so speichern:

• mit einem Klick auf das Diskettensymbol oder Strg + S die aktuelle Datei
• mit einem Klick auf den Diskettenstapel oder Strg + Shift + S alle geöffneten Dateien.

Das Kompilieren

Vorbereitung nur für C#: Entfernen Sie vor der ersten Zeile mit WriteLine die schließende Klammer }.

Zunächst muss das Programm erstellt, also kompiliert werden. Das bedeutet, dass der ursprüngliche (von Ihnen geschriebene) Code in den .NET-Zwischencode übersetzt werden muss. Dies geschieht auf einem dieser Wege:

• durch F7
• durch Klick auf das entsprechende Symbol (es sieht etwas kompliziert aus; am besten ist es, Sie suchen es anhand der Beschreibung)
• über den Menü-Punkt Erstellen > Mein neues Auto erstellen
• über das Projekte-Fenster durch Rechtsclick auf den Projekt-Namen "Mein neues Auto" und Mein neues Auto erstellen

Kompilieren mit einem Fehler

Starten Sie also das Kompilieren. Leider enthält das Programm Fehler, die uns der Compiler durch das Schild mitteilt. Über das Zeichen rechts unten wird das Fenster der Fehlermeldungen mit einer genaueren Information eingeblendet:

// bei C#
Zeile 25 – Fehler: } erwartet. (CS1513) – Datei: Main.cs
' bei VB
Program.vb(12) : Fehler BC30081: "If" muss mit einem zugehörigen "End If" abgeschlossen werden.

VB ist in diesem Fall genauer, weil die richtige Stelle angegeben wird. Das letzte Else wurde mit End abgeschlossen, es muss aber – wie die Fehlermeldung feststellt – mit End If beendet werden.

Bei C# wird nur festgestellt, dass die Klammerpaare {...} nicht zusammenpassen: Es gibt eine öffnende Klammer ohne dazugehörige schließende Klammer. In diesem Fall ist es einfach: Weil die unter Vorbereitung entfernte Klammer fehlt, hat die öffnende Klammer von Zeile 16 keinen Partner. Schreiben Sie also die fehlende Klammer } wieder hin. Wie schon während der Eingabe des Codes sehen Sie sofort, welche Partner zusammengehören.

Am sichersten ist deshalb folgendes Verfahren, das Sie sich unbedingt angewöhnen sollten: Schreiben Sie nach einer öffnenden Klammer sofort den Partner und fügen Sie den Code dazwischen ein.

Wenn Sie „spaßeshalber“ einmal die öffnende Klammer entfernen, werden Sie mit vielen Fehlermeldungen bombardiert. Das untersuchen wir in späteren Kapiteln.

Speichern Sie die berichtigte Datei.

Kompilieren mit einer Warnung

Kompilieren Sie das Programm erneut. Es sollte keine Fehler mehr aufweisen, liefert aber eine Warnung:

// bei C# und C++
Die Variable input ist deklariert, wird aber nie verwendet.
' bei VB 
Nicht verwendete lokale Variable: input.

Warnungen können theoretisch ignoriert werden; das Programm kann trotzdem ablaufen. In aller Regel ist damit aber eine Unsauberkeit im Code enthalten; deshalb sollten Sie sich immer um die Beseitigung von Warnungen kümmern. Hier wurde sie provoziert: Kopieren Sie den gesamten noch fehlenden Programmtext in den vorhandenen Text.

Hinweis: Als dieser Text im April 2011 geschrieben wird, hat MonoDevelop Probleme.

• Fügen Sie Text aus der Zwischenablage nur nach der ersten von drei Leerzeilen ein, nicht direkt an vorhandenen Text.
• Vor dem Kompilieren muss der Text sauber formatiert werden: Markieren Sie mit Strg + A den gesamten Text und wählen Sie Bearbeiten > Format > Dokument formatieren.

Danach speichern Sie den geänderten Text.

Kompilieren mit weiteren Fehlern

Kompilieren Sie erneut. Nun gibt es eine Menge gleichartiger Fehlermeldungen:

// bei C#
Der Typ- oder Namespacename Car konnte nicht gefunden werden.
(Fehlt eine using-Direktive oder ein Assemblyverweis?)
' bei VB
Der Typ Car ist nicht definiert (BC30002)

Nun ja, die Definition der Klasse Car fehlt noch völlig. Also erstellen wir eine weitere Quelldatei:

• Für C# mit Rechtsklick auf Car.cs mit der Auswahl "Ziel speichern unter" dem Namen Car.cs im Quellverzeichnis
• Für VB mit Rechtsklick auf Car.vb mit der Auswahl "Ziel speichern unter" dem Namen Car.vb im Quellverzeichnis

Diese Quelldatei fügen wir unserem Projekt hinzu: im Projektmappen-Fenster nach Rechtsklick auf den Projektnamen über Hinzufügen > Dateien hinzufügen die gerade gespeicherte Datei auswählen. Sofern diese Datei nicht sofort angezeigt wird, können Sie sie mit Doppelklick öffnen und überprüfen.

Um eine weitere Fehlermeldung zu vermeiden, die wir erst später besprechen wollen, gehen Sie im Projektmappen-Fenster mit Rechtsklick auf Verweise und wählen über Referenzen bearbeiten im Bereich "Pakete" die Assembly System.Drawing aus – markieren und Haken setzen – und bestätigen dies mit OK.

Damit können wir erneut und endgültig kompilieren; es sollten keine Meldungen bleiben.

Das Ausführen

Jetzt können wir das Programm ablaufen lassen; es gibt wieder mehrere Möglichkeiten:

• durch Strg + F5
• über den Menü-Punkt Ausführen > Ausführen
• über den Menü-Punkt Ausführen > Debuggen
• über einen der Menü-Punkte Ausführen > Starten mit >
• über das Projektmappen-Fenster durch Rechtsklick auf den Projektnamen und Element ausführen
• über die Symbolleiste durch Klick auf das entsprechende Symbol (auch hier ist es am besten, Sie suchen es anhand der Beschreibung)

Der letzte Weg führt nicht immer direkt zum Ziel: Wenn die Projektmappe mehrere Projekte enthält, wird diejenige Anwendung gestartet, die als Startprojekt festgelegt wurde.

Ein fertiges Programm kann auch "normal" gestartet werden – wie jedes installierte Programm auch:

• in der Eingabeaufforderung direkt "Mein neues Auto" aufrufen (wegen des Leerzeichens sind die Gänsefüßchen notwendig)
• durch Doppelklick im Inhaltsverzeichnis z.B. des Windows-Explorers oder eines Commanders

Der Programmablauf öffnet ein Konsolenfenster:

Ausgabe

'"`UNIQ--syntaxhighlight-0000000C-QINU`"'

Darin werden Ausgabezeilen angezeigt, nämlich alles, was mit Write und WriteLine angegeben wurde, und es enthält verschiedene Eingaben, nämlich einmal ReadLine und einmal ReadKey.

Der letzte Befehl, der auf die Eingabe einer beliebigen Taste wartet, hat mit dem Programm selbst nichts zu tun. Er ist bei einer Console-Anwendung nützlich; wenn er fehlt, wird das Programm beendet, ohne dass Sie die letzte Ausgabe sehen oder gar lesen können. Aber das kann auch generell festgelegt werden über den Menü-Befehl Projekt > Einstellungen > Ausführen > Allgemein die Festlegung „Konsolenausgabe pausieren“ ausgewählt wird.

Fehlersuche mit Debugger

Dank der guten Vorarbeit (und der wenigen Arbeit, die erledigt wird) enthält unser Programm keine Fehler. Aber für den Fall der Fälle können wir es untersuchen. Sorgen Sie also dafür, dass das Programm nicht einfach durchläuft

• Setzen Sie einen Haltepunkt (Breakpoint), indem Sie in eine bestimmte Zeile gehen, z.B. in die Zeile mit ReadLine:
  • Klicken Sie in dieser Zeile in den Fensterrahmen links von der Zeilennummer.
  • Oder klicken Sie in dieser Zeile an eine beliebige Stelle und drücken dann F9.
• Starten Sie dann wieder Kompilieren und Ausführen – wie oben, aber mit Debuggen bzw. F5.

Das Programm wird zunächst mit der Console beginnen und dann in die IDE zurückspringen und an der betreffenden Stelle anhalten. Der Arbeitsablauf kann mit den Befehlen im Menü Ausführen bzw. mit F10 und F11 fortgesetzt werden. Gehen Sie dabei wie folgt vor:

• Im Fenster Lokale Variablen sehen Sie, dass für input noch kein Wert vorgegeben ist.
• Drücken Sie einmal F11. Das Programm geht nicht weiter, weil es auf eine Eingabe wartet.
• Wechseln Sie über die Taskleiste zum Programm, schreiben den gewünschten Eingabetext und drücken Return.
• Das Programm wartet in der IDE auf der nächsten Zeile.
• Im Fenster Lokale Variablen sehen Sie jetzt den von Ihnen eingegebenen Wert.

Mit F5 kann der Programmablauf bis zum nächsten Haltepunkt fortgesetzt werden. Bei uns kommt kein neuer Haltepunkt, aber das Programm wartet in der Console auf eine beliebige Taste. Wechseln Sie also dorthin und geben es frei.

Bei späteren Programmen sollten Sie das Debuggen intensiv mit Haltepunkten, den Funktionstasten und den Variablen ausprobieren.

Vergleich von Bezeichnungen

Betriebssysteme

Windows	Linux	MacOS
Konsole	Terminal	?

.NET und Mono

.NET Framework	Mono-Projekt
?	?

Die IDEs

MS Visual Studio	SharpDevelop	MonoDevelop
?	?

Namespace, Dateien, Klassen

Beschreibung	.NET Framework	Mono C#	Mono VB
Standards für ein neues Projekt
Programmdatei	Program.*	Main.cs	Application.vb
Programmklasse	Program	MainClass	Application

Zusammenfassung

Mit MonoDevelop steht eine vollwertige IDE zur Verfügung:

• Es können verschiedene Programmiersprachen verarbeitet werden.
• Der Code-Editor berücksichtigt die Anforderungen von Programmierern.
• Der passende Compiler und ein Debugger sind integriert.

Damit können wir umfangreiche .NET- oder Mono-Anwendungen erstellen.