Schlagwort: .NET

Aufzählungswert per Zeichenkette ermitteln 👍 👎

Vor sehr langer Zeit habe ich bereits einen Artikel zu Enumerationen in C# geschrieben, an welchen ich indirekt anknüpfen möchte. Oftmals steht man im Bereich der Softwareentwicklung vor dem Problem der Interoperabilität, da mehrere – bisweilen äußerst unterschiedliche – Systeme zusammenarbeiten müssen.

Ein klassischer Fall im Bereich der Webentwicklung ist die Zusammenarbeit aus Anwendung und Datenbank, beispielsweise hier im Blog zwischen der Programmiersprache C# mit ASP.NET MVC-Framework und MySQL-Datenbank. Etwas konkreter soll es darum gehen, C#-Aufzählungstypen zusammen mit MySQL-ENUMs zu verwenden, welche grundsätzlich erst einmal als bloße Zeichenketten zu behandeln sind. Für das folgende Beispiel nehmen wir an, dass eine Tabelle user existiert, die eine Spalte state vom Typ ENUM('ACTIVE','INACTIVE','LOCKED') enthält.

Unter Verwendung des ADO.NET Entity Framework würde beim Database First-Ansatz eine entsprechende Klasse user mit der Eigenschaft state vom Typ string erzeugt. Da es sich um eine partielle Klasse handelt, erweitern wir diese um eine neue Eigenschaft State. Diese soll anschließend die automatische Konvertierung für state übernehmen und ermöglicht uns im Programmcode einen typsicheren Zugriff auf den Status des Benutzers:
Aufzählungstyp UserState anlegen
0102030405
public enum UserState {    Active,    Inactive,    Locked}
Erweiterung der Klasse user
010203040506070809
public partial class user {    public UserState State {        get {            return (UserState) Enum.Parse(typeof(UserState), this.state, true);        }        set {            this.state = value.ToString().ToUpper();        }    }
Die Verwendung gestaltet sich nun – mit beiden Eigenschaften – wie gewohnt komfortabel:
Verwendung
0102030405060708091011121314151617
user dbUser = new user() {    State = UserState.Active};  // üblicherweise aus Datenbank ermittelt

string state = dbUser.state; // "ACTIVE"UserState userState = dbUser.State; // Active
dbUser.State = UserState.Inactive;

state = dbUser.state; // "INACTIVE"userState = dbUser.State; // Inactive
dbUser.state = "LOCKED";

state = dbUser.state; // "LOCKED"userState = dbUser.State; // Locked
Weitere Informationen zu den Enum.Parse-Methoden finden sich wie üblich im MSDN. Es lohnt sich außerdem ein Blick auf die Enum.TryParse(…)-Methoden mit generischem Typ-Parameter.

DNS-Blacklisten mit C# abfragen 👍 👎

Im früheren Beitrag zur DNS-Auflösung mit C# haben wir eine grundlegende Möglichkeit kennengelernt, IP-Adressen zu Domains zu ermitteln. Dies möchten wir uns zu Nutze machen, um DNS-Blacklisten abzufragen, welche von vielen eMail-Systemen genutzt werden, um potentiellen Spam zu erkennen (und ggf. abzuweisen).

Zu den bekannten Anbietern entsprechender Dienste gehören beispielsweise: Diese setze ich auch selbst ein und habe jeweils gute Erfahrungen damit gemacht. Bitte informiert euch jedoch vor einem Einsatz beim jeweiligen Anbieter über die genauen Konditionen, der kommerzielle Einsatz ist beispielsweise oftmals kostenpflichtig. Ebenso verhält es sich je nach Anbieter ab einem gewissen Abfragevolumen.

Um nun eine IP-Adresse gegen die entsprechenden Dienste prüfen zu können, müssen wir diese dem oben angegebenen Hostnamen in umgekehrter Reihenfolge voranstellen und eine Namensauflösung durchführen.

Konkret fragen wir also beispielsweise bei einer Prüfung der IP-Adresse 217.160.176.125 auf Spam-Aktivität laut Spamhaus das Ergebnis der Domain 125.176.160.217.zen.spamhaus.org ab (welches hoffentlich negativ beschieden werden sollte). Per C# könnte man dies nun beispielsweise (durchaus verbesserungsfähig) wie folgt durchführen:
IP-Adresse auf Blacklisting prüfen
010203040506070809101112131415161718192021222324
public static bool CheckBlacklisting(IPAddress ipAddress, string blacklist = "zen.spamhaus.org") {    string ipAddressReversed = String.Join(".", ipAddress.GetAddressBytes().Reverse());    string hostName = String.Concat(ipAddressReversed, ".", blacklist);
try { foreach(IPAddress hostAddress in Dns.GetHostAddresses(hostName)) { /** * Achtung: Diese Implementierung ist naiv und sollte nicht direkt * übernommen werden. Je nach Anbieter, so beispielsweise auch bei * Spamhaus, gilt nicht der gesamte Loopback-Adressbereich als Spam. * Daher bitte vorher beim Anbieter informieren und konkretisieren! **/ if(IPAddress.IsLoopback(hostAddress)) { return true; } }
return false; } catch { return false; }}
bool checkResult = CheckBlacklisting(IPAddress.Parse("217.160.176.125")); // false
Das Ergebnis der Namensauflösung, also die erhaltene IP-Adresse, gibt darüber hinaus Aufschluss über den genaueren Status. Spamhaus liefert dazu beispielsweise in ihren FAQ weiterführende Informationen.

DNS-Auflösung mit C# 👍 👎

Das Domain Name System ist einer der wichtigsten Dienste in vielen IP-basierten Netzwerken, so insbesondere auch im Internet. Die Hauptaufgabe stellt dabei das Übersetzen von für die menschliche Nutzung praktischen Domains in technisch verarbeitbare IP-Adressen dar. Mit diesem Beitrag möchte ich jedoch gar nicht weiter auf diese Details eingehen, dazu lohnt sich stattdessen beispielsweise ein (empfehlenswerter) Blick in die Wikipedia.

Unser Hauptanliegen soll es nun sein, dieses System per C# zu befragen, um darauf aufbauend in einem späteren Beitrag eine konkrete Anwendung umzusetzen. Praktischerweise liefert das .NET-Framework mit System.Net.Dns eine Klasse mit entsprechender Funktionalität – zugegebenermaßen aber nur mit geringem Funktionsumfang, weshalb zur professionellen Arbeit mit den verschiedenen Resource Records das Einbinden externer Programmbibliotheken sinnvoll sein kann. Die Anwendung der Basisfunktionalität ist jedoch denkbar einfach:
IP-Adresse(n) zu Domain ermitteln
0102030405060708
IPAddress[] hostAddressList = Dns.GetHostAddresses("coders-online.net");
foreach(IPAddress hostAddress in hostAddressList) { /** * hostAddress enthält nun jeweils eine IP-Adresse zur Domain; * im Falle dieses Beispiels den einzigen Eintrag 217.160.176.125. **/}
Eine praktische Hilfsmethode ist außerdem Dns.GetHostName(), welche den Namen des lokalen Rechners liefert. Das MSDN liefert wie üblich weitere Informationen zur Dns-Klasse, u. a. mit Hinweisen zu den asynchronen Methoden. Weiterhin interessant im System.Net-Namespace ist bis dahin natürlich auch die Klasse IPAddress.

Benchmarking unter C# 👍 👎

Teilweise ist zu sehen, dass Entwickler unter C# Benchmarks mit Hilfe der DateTime-Struktur umsetzen. Diese ist für derartige Zwecke jedoch zu ungenau und es sollte stattdessen mit der etwas spezielleren Stopwatch-Klasse gearbeitet werden. Wie genau das nun aussehen kann, möchte ich gerne mit diesem Beitrag kurz aufzeigen:
Benchmark per Stopwatch durchführen
01020304050607080910
Stopwatch stopwatch = Stopwatch.StartNew();{      // Simulation einer längeren Ausführungszeit    for(int i = 0; i < 5; i++) {        Thread.Sleep(50);    }}stopwatch.Stop();
long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
Darüber hinaus ist für besonders präzise Messungen insbesondere die ElapsedTicks-Eigenschaft interessant.

Selbstverständlich benötigt ein umfassendes Benchmarking einer Anwendung etwas mehr Komfort als eine schnelle Messung, es bietet sich daher beispielsweise auch eine entsprechende Suche im NuGet-Verzeichnis an.

GET- und POST-Anfragen mit C# 👍 👎

Für viele APIs – aber auch so manchen Test – ist es hilfreich, GET- und POST-Anfragen per HTTP senden zu können. Selbstverständlich ist das auch per C# sehr einfach möglich, wobei je nach gewünschtem Grad der Kontrollierbarkeit der Anfragen verschiedene Abstrahierungen zur Verfügung gestellt werden:

Die umfangreichsten Möglichkeiten (und geringen Abstraktiongrad) bietet HttpWebRequest:
GET per HttpWebRequest
01020304050607
HttpWebRequest webRequest = HttpWebRequest.CreateHttp("…/?key1=val1&key2=val2");
using(HttpWebResponse webResponse = (HttpWebResponse) webRequest.GetResponse()) { using(StreamReader streamReader = new StreamReader(webResponse.GetResponseStream())) { string response = streamReader.ReadToEnd(); }}
POST per HttpWebRequest
010203040506070809101112131415161718
HttpWebRequest webRequest = HttpWebRequest.CreateHttp("…");{    byte[] data = Encoding.UTF8.GetBytes("key1=val1&key2=val2");
webRequest.Method = "POST"; webRequest.ContentType = "application/x-www-form-urlencoded"; webRequest.ContentLength = data.Length;
using(Stream stream = webRequest.GetRequestStream()) { stream.Write(data, 0, data.Length); }}
using(HttpWebResponse webResponse = (HttpWebResponse) webRequest.GetResponse()) { using(StreamReader streamReader = new StreamReader(webResponse.GetResponseStream())) { string response = streamReader.ReadToEnd(); }}
Deutlich kompakter lassen sich entsprechende Anfragen per WebClient formulieren:
GET per WebClient
010203
using(WebClient webClient = new WebClient()) {    string response = webClient.DownloadString("…/?key1=val1&key2=val2");}
POST per WebClient
010203040506
using(WebClient webClient = new WebClient()) {    string response = Encoding.UTF8.GetString(webClient.UploadValues("…", new NameValueCollection() {        {"key1", "val1"},        {"key2", "val2"}    }));}
Die aktuellste Möglichkeit mit Fokus auf asynchrone Vorgänge stellt HttpClient dar:
GET per HttpClient
010203
using(HttpClient client = new HttpClient()) {    string response = await client.GetStringAsync("…/?key1=val1&key2=val2");}
POST per HttpClient
01020304050607080910
using(HttpClient httpClient = new HttpClient()) {    HttpResponseMessage responseMessage = await httpClient.PostAsync("…",        new FormUrlEncodedContent(new Dictionary<string, string>() {            {"key1", "val1"},            {"key2", "val2"}        })    );
string response = await responseMessage.Content.ReadAsStringAsync();}
Grundsätzlich bestünde auch noch die Möglichkeit, auf TCP-Ebene unter Anwendung des HTTP-Protokolls vorzugehen – aber das wird man kaum benötigen. Abschließend sei noch erwähnt, dass diese Möglichkeiten nicht für fragliche Aktionen genutzt werden sollte – dazu gehört im Übrigen auch schlicht unnötiger Traffic.

Projektverweise

Kategorien / Archiv  |  Übersicht RSS-Feed

Schlagworte

Suche