Schlagwort: Netzwerk

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 [217.160.176.125] ü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 [217.160.176.125]
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).

Darstellung von IP-Adressen 👍 👎

Vorweg sei erwähnt, dass ich mich im weiteren Verlauf des Artikels der Übersicht wegen auf IPv4 beschränken werde. Das vorgestellte Konzept funktioniert prinzipiell jedoch auch bei IPv6 in ähnlicher Form.

Jeder hat bestimmt schon einmal IP-Adressen der Form "127.0.0.1" (lokale Adresse), "192.168.1.1" (private Adresse) oder "217.160.176.125" (öffentliche Adresse) gesehen. Das ist eine für den Menschen bequeme Schreibweise, jedoch nur bedingt zur automatisierten Verarbeitung (z. B. für Vergleiche bei Sortierungen) geeignet.

Eine IPv4-Adresse besteht aus vier Segmenten, die jeweils 8 Bit (≙ 4 * 1 Byte = 32 Bit, bzw. 4 Byte) umfassen. Insofern verwendet eine IPv4-Adresse dieser Schreibweise ("dotted decimal") eine Art Stellenwertsystem wie unser gebräuchliches Dezimalsystem, wobei die einzelnen Stellen jedoch mehrere Ziffern umfassen und daher durch ein Trennzeichen (in diesem Fall ein ".") getrennt werden.

Die Wertigkeit der Stelle einer Zahl unseres Dezimalsystems ergibt sich bekanntermaßen aus dessen Position:
Stellenwertsystem von Dezimalzahlen
01020304050607
  1 =                     1 * 100  5 =                     5 * 100
10 = 1 * 101 + 0 * 100 15 = 1 * 101 + 5 * 100
123 = 1 * 102 + 2 * 101 + 3 * 100
Ähnlich verhält es sich nun bei einer IPv4-Adresse, jedoch mit entsprechend anderen Wertigkeiten:
Stellenwertsystem von IP-Adressen
0102030405
127.  0.  0.  1 = 127 * 224 +   0 * 216 +   0 * 28 +   1 * 20 = 2 130 706 433
192.168. 1. 1 = 192 * 224 + 168 * 216 + 1 * 28 + 1 * 20 = 3 232 235 777
82.165. 40.206 = 82 * 224 + 165 * 216 + 40 * 28 + 206 * 20 = 1 386 555 598
In Anbetracht dieser Tatsache können wir einer IPv4-Adresse also einen ein-eindeutigen ganzzahligen Wert zuordnen, indem wir – analog zu unserem Dezimalsystem – die Summe der einzelnen Stellen bilden. Durch diese Darstellungsweise sind nun beispielsweise sehr einfach "größer"- und "kleiner"-Relationen zu ermitteln.

Die zu dieser Thematik passende Eigenschaft Address der IPAddress-Klasse des .NET-Frameworks ist als veraltet gekennzeichnet. Solltet ihr diese Funktionalität dennoch benötigen, so lässt sich dies selbstverständlich auch schnell selbst schreiben – wobei zu berücksichtigen gilt, dass das nur für IPv4-Adressen in dieser Form verwendet werden kann:
Vorgehensweise zur ganzzahligen Darstellung von IPv4-Adressen
010203040506
IPAddress ipAddress = IPAddress.Parse("217.160.176.125");byte[] segmentList = ipAddress.GetAddressBytes();
long ip2long = Convert.ToInt64((segmentList[0] * Math.Pow(2, 24)) + (segmentList[1] * Math.Pow(2, 16)) + (segmentList[2] * Math.Pow(2, 8)) + segmentList[3]); // – oder auch -long ip2long = (((long) segmentList[0] << 24) | ((long) segmentList[1] << 16) | ((long) segmentList[2] << 8) | (long) segmentList[3]);
PHP bietet hier beispielsweise die Funktion ip2long (und deren Gegenstück long2ip) an.

Projektverweise

Kategorien / Archiv  |  Übersicht RSS-Feed

Schlagworte

Suche