Konsolenausgabe in C# verwenden (Ergänzung) 👍 👎

In meinem Beitrag zur Verwendung der Konsolenausgabe in C# hatte ich aus naheliegenden Gründen eine asynchrone Verarbeitung gewählt. Mich hat nun jedoch die Frage erreicht, wie die komplette Ausgabe auf einmal abzugreifen geht. Auch das ist selbstverständlich kein Problem – man könnte sogar sagen, noch einfacher.

Wir wollen dazu ein Beispiel wählen, welches uns sehr zügig eine vollständige Antwort liefern sollte. Wir rufen dazu die integrierte Hilfe von ipconfig auf. Die grafische Oberfläche besteht nunmehr nur noch aus einer TextBox output und einer Schaltfläche, für die wir die entsprechende Ereignisbehandlung implementieren:
Ereignisbehandlung implementieren
01020304050607080910111213141516
  // Prozessdaten festlegenProcess process = new Process() {    StartInfo = new ProcessStartInfo() {        Arguments = "/?",               // Parameter für Hilfe-Anzeige        CreateNoWindow = true,          // Konsolenanzeige unterbinden        FileName = "ipconfig",          // Programm        RedirectStandardOutput = true,  // Ausgabe umleiten        UseShellExecute = false         // Betriebssystemshell deaktivieren    }};
// Prozess startenprocess.Start();
// Ausgabe verarbeitenoutput.Text = process.StandardOutput.ReadToEnd();
Ihr solltet jedoch in jedem Fall beachten, dass dieses Vorgehen zur Blockierung der Benutzeroberfläche führt, wenn das externe Programm nicht schnell genug liefern kann. Dies ist daher nur begrenzt zu empfehlen.

Konsolenausgabe in C# verwenden 👍 👎

Manchmal kann es erforderlich sein, in eigenen Projekten auf bestehende Konsolenanwendungen zurückgreifen zu müssen. Meist benötigt man dann jedoch auch Zugriff auf die Ausgabe des Programms, z. B. um diese in einer grafischen Benutzeroberfläche mit Windows Forms – ggf. aufbereitet – darzustellen.

Dies lässt sich ganz einfach mit C# lösen. Als kleines Beispiel zeigen wir dazu die Ausgabe des tracert-Befehls in einer entsprechenden Anwendung an. Diese besteht dabei lediglich aus einer TextBox "targetHost", einer ListBox "output" und einem Button – mit Visual Studio sicherlich kein Problem soweit. Smiley: winking

Jetzt müssen wir lediglich noch die Ereignisbehandlung für einen Klick auf die Schaltfläche implementieren:
Ereignisbehandlung implementieren
0102030405060708091011121314151617181920212223
  // Prozessdaten festlegenProcess process = new Process() {    StartInfo = new ProcessStartInfo() {        Arguments = targetHost.Text,    // Eingabe aus TextBox        CreateNoWindow = true,          // Konsolenanzeige unterbinden        FileName = "tracert",           // Programm        RedirectStandardOutput = true,  // Ausgabe umleiten        UseShellExecute = false         // Betriebssystemshell deaktivieren    }};
// Ereignisbehandlung registrierenprocess.OutputDataReceived += (s, eventArgs) => { if(eventArgs.Data != null) { this.Invoke(new Action(() => { this.output.Items.Add(eventArgs.Data); })); }};
// Prozess startenprocess.Start();process.BeginOutputReadLine();
Nun werden alle Ausgaben des Konsolenprogramms asynchron als neue Zeile zu output hinzugefügt. Durch dieses Vorgehen blockiert unsere Oberfläche nicht, so dass damit problemlos weitergearbeitet werden kann. In meinem Fall sieht der Inhalt der ListBox für coders-online.net beispielsweise wie folgt aus:
Ausgabe
01020304050607
Routenverfolgung zu coders-online.net [80.78.81.19] über maximal 30 Abschnitte:
1 <1 ms <1 ms <1 ms Router [192.168.2.1] ( … gekürzt … ) 9 17 ms 16 ms 17 ms coders-online.net [80.78.81.19]
Ablaufverfolgung beendet.
Beachtet zuletzt bitte ggf. auch noch einmal meinen Beitrag zur Freigabe von Ressourcen in C#. Um die Beispiele nicht aufzublähen verzichte ich meist darauf (wie auch auf eine umfassende Fehler- und Ausnahmebehandlung).

NULL für Werttypen in C# 👍 👎

Oftmals stolpern Entwickler anderer Sprachen darüber, dass Werttypen (z.B. int, double oder bool) in C# null nicht direkt zugewiesen werden kann, was insbesondere bei der Arbeit mit Datenbanken schnell notwendig wird.

Es gibt jedoch mit Hilfe der Nullable-Struktur eine elegante Lösung hierfür. Dazu wird ganz einfach der gewünschte Werttyp als Typparameter von Nullable angegeben:
Werttyp ohne und mit "Nullable"
0102030405060708091011
  // Werttyp ohne "Nullable"bool isValid;
isValid = true; // "true" zuweisenisValid = null; // Fehler: "null" kann nicht zugewiesen werden!
// Werttyp mit "Nullable"Nullable<bool> isValid;

isValid = true; // "true" zuweisenisValid = null; // "null" zuweisen
Außer der Zuweisbarkeit von null fügt Nullable auch noch Funktionalität zu unserem Objekt hinzu, mit der wir prüfen können, ob ein Wert vorhanden (bzw. das Objekt null) ist:
Nullable-Funktionalität
010203040506
if(isValid.HasValue) {  /**   * "isValid.Value" enthält den Wert;   * dieser ist ohne Nullable deklariert.  **/}
Zusätzlich gibt es noch die Methode GetValueOrDefault(…), deren Nutzen selbsterklärend sein dürfte.

Meiner Meinung nach könnte man nun durchaus auf die Idee kommen, dass diese Schreibweise etwas umständlich ist, "nur" um null zuweisen zu dürfen. Das sah Microsoft offensichtlich ähnlich, weswegen es eine äußerst kompakte Alternative gibt, indem man dem entsprechenden Werttyp schlicht ein "?" anhängt:
Werttyp mit "Nullable" (Kurzschreibweise)
01020304
bool? isValid;
isValid = true; // "true" zuweisenisValid = null; // "null" zuweisen
Dies ist identisch zur oben beschriebenen "ausführlichen" Variante und stellt somit lediglich eine syntaktische Bequemlichkeit dar, die ich jedoch sehr gerne verwende und auch anderen empfehle, das so zu halten.

Weitere Informationen zu diesem Thema finden sich selbstverständlich im MSDN.

Zeichenketten-Konkatenierung in C# 👍 👎

Ein leider immer noch häufig vorzufindendes "Problem" in vielen C#-Anwendungen ist die vielen Entwicklern aus Sprachen wie PHP vertraute Verknüpfung von Zeichenketten per entsprechendem Operator ("." in PHP, "+" in C#):
Konkatenierung per Operator
0102030405
string tmp = "";
tmp += "ersteZeichenkette";tmp += "zweiteZeichenkette";tmp += "dritteZeichenkette";
Dies ist unter C# aus Sicht der Performanz besonders problematisch, da Zeichenketten in C# unveränderbar ("immutable") sind und demnach bei jeder solchen Verknüpfung ein neues Objekt erzeugt wird. Die Lösung für dieses Problem ergibt sich jedoch elegant durch Verwendung der StringBuilder-Klasse:
Konkatenierung per StringBuilder
0102030405060708
StringBuilder tmpBuilder = new StringBuilder();{    tmpBuilder.Append("ersteZeichenkette");    tmpBuilder.Append("zweiteZeichenkette");    tmpBuilder.Append("dritteZeichenkette");}
string tmp = tmpBuilder.ToString();
Dies ist bei C# üblicherweise bereits bei unter drei entsprechenden Vorgängen deutlich schneller als per Operator. Bei sehr vielen – jedoch durchaus praxisrelevanten – Vorgängen wird dieser Unterschied schnell so groß, dass mit der Verknüpfung per StringBuilder bis zu zwei Größenordnungen mehr Vorgänge in der gleichen Zeit wie per Operator möglich sind. Zudem wird selbstverständlich deutlich weniger Arbeitsspeicher benötigt. Insbesondere bei umfangreichen Schleifen ergibt sich hier also sehr schnell ein ernstzunehmendes Einsparpotential. Es handelt sich keinesfalls um "Mikrooptimierung" und wird auch von Microsoft selbst betont.

Bei ganz einfachen Verknüpfungen mit zwei Zeichenketten verwende ich durchaus die Operator-Variante, da sie etwas kompakter ist und der Unterschied minimal. Sobald mehrere Verknüpfungen notwendig werden, setze ich für gewöhnlich jedoch bereits auf einen StringBuilder.

Die intern erzeugte Zeichenkette des StringBuilder kann zur weiteren Verwendung wie im Beispiel ersichtlich jederzeit per ToString() abgerufen werden. Darüber hinaus stellt diese Klasse auch noch ein paar komfortable Methoden wie beispielsweise AppendLine(…) zur Verfügung.

Versionierung 👍 👎

Zu meiner Ergänzung zur Darstellung von IP-Adressen hat mich die Frage erreicht, ob ich vielleicht noch ein paar Sätze dazu schreiben möchte, wie ich es mit der Versionierung konkret halte.

Das möchte ich mit diesem Beitrag gerne machen, jedoch gehe ich da ziemlich traditionell und wenig spektakulär vor, so dass ich keine allzu großen Hoffnungen auf bahnbrechende Erkenntnisse machen möchte. Smiley: winking

Vor der Fertigstellung der initial zu veröffentlichenden Version verwende ich lediglich die internen Versions- bzw. Buildnummern. Zur öffentlichen Versionsnummerierung halte ich mich üblicherweise an folgendes Schema:

  x.y.z
  • x: Hauptversion

    Diese Nummer wird bei einer kompletten Neuentwicklung, bzw. einem Technologiewechsel erhöht. Dies ist z. B. bei einem Wechsel der Programmiersprache der Fall, oder aber wenn strukturelle/inkompatible Änderungen (insbesondere an öffentlichen Schnittstellen) stattfinden. Damit einher geht jedoch neben der – durchaus einschneidenden – Änderung an sich auf jeden Fall auch eine Neuentwicklung wesentlicher Bestandteile des gesamten Projektes.

  • y: Funktionalitätserweiterung

    Diese Nummer wird bei Erweiterungen der Funktionalität einer Anwendung erhöht. Dazu werden einige – im Allgemeinen überschaubare – zu erledigende Aufgaben gesammelt und dann mit dieser Version veröffentlicht. Bei besonders umfangreichen Ergänzungen kann diese Veröffentlichung durchaus auch nur einen einzelnen Aspekt betreffen, andererseits aber eben auch sehr viele kleinere.

  • z: Fehlerbehebung, Optimierung

    Diese Nummer wird bei der Behebung von Fehlern einer Anwendung erhöht. Dazu werden im Allgemeinen einige (insbesondere weniger dramatische) Probleme gesammelt und dann mit dieser Veröffentlichung behoben. Bei kritischen Fehlern, die die Funktionsfähigkeit des gesamten Programmes verhindern, oder aus Sicherheitsgründen schnellstmöglich behoben werden müssen, kann eine solche Version auch nur für einige wenige Änderungen für ein einzelnes Problem veröffentlicht werden.

    Sofern bestehende Funktionalität zwar erwähnenswert optimiert wird, jedoch nicht grundlegend erweitert, erscheint mir diese Stelle ebenfalls angemessen.

Zusätzliche Unterscheidungen oder ergänzende Begriffe verwende ich für gewöhnlich nicht. Zur Versionsverwaltung an sich setze ich auf Git per GitLab. Ein aus meiner Sicht gutes Dokument mit weitestgehend sinnvollen Vorschlägen ist außerdem Semantic Versioning

Projektverweise

Kategorien / Archiv  |  Übersicht RSS-Feed

Schlagworte

Suche