Blog | Holger Stehle

Benchmarking with 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 and POST Requests with 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

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

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.

Create Charts with C# 👍 👎

Häufig möchte man Statistiken grafisch aufbereitet darstellen. Mit diesem Beitrag möchte ich gerne zeigen, wie sich mit Hilfe einiger unter System.Web.UI.DataVisualization.Charting befindlichen Klassen sehr einfach dynamisch Diagramme erzeugen lassen. Der korrespondierende Namespace für klassische Anwendungen lautet System.Windows.Forms.DataVisualization.Charting.

Für unser Beispiel verwenden wir eine einfache Windows-Anwendung und folgende Datensammlung:

Daten (einige BMW-Modelle)

010203040506

Dictionary<string, double> data = new Dictionary<string, double>() {    {"125i", 160},    {"335i", 225},    {"550i", 330},    {"760i", 400}};

Die Schlüssel bezeichnen das jeweilige Modell und der entsprechende Wert die Leistung (in kW). Daraus erzeugen wir nun ein einfaches Balkendiagramm und speichern das Ergebnis als dia.png:

Diagramm erstellen und speichern

01020304050607080910111213141516171819202122232425262728293031323334353637

using(Chart chart = new Chart() {    Height = 345,    Width = 543}) {      // Konfiguration    chart.Titles.Add("BMW-Leistungsvergleich");
    chart.ChartAreas.Add(new ChartArea("statistic") {        AxisX = new Axis() {            MajorGrid = new Grid() {                Enabled = false            }        },        AxisY = new Axis() {            MajorGrid = new Grid() {                LineColor = Color.LightGray,                LineDashStyle = ChartDashStyle.Dot            },            Title = "kW"        }    });
    chart.Series.Add(new Series("data") {        ChartType = SeriesChartType.Column    });
      // Daten    foreach(KeyValuePair<string, double> entry in data) {        chart.Series["data"].Points.Add(new DataPoint() {            AxisLabel = entry.Key,            YValues = new double[] { entry.Value }        });    }
      // Ausgabe    chart.SaveImage("dia.png", ChartImageFormat.Png);}

Als grundlegende Konfiguration wurde in diesem Beispiel das Gitternetz im Hintergrund zur Orientierung auf horizontale Linien beschränkt und durch Farbänderung und Punktierung etwas subtiler gestaltet. Außerdem wurden ein paar Beschriftungen ergänzt und ansonsten die Standardkonfiguration belassen.

Wichtig zu verstehen ist das Konzept, welches zuerst eine ChartArea als Grundfläche und anschließend Series für die eigentlichen Daten erfordert. Es können jeweils mehrere davon in einem Diagramm untergebracht werden.

Selbstverständlich sind umfassende Optionen vorgesehen, die das Endergebnis praktisch völlig anders erscheinen lassen können – bis hin zum eigentlichen Diagrammtyp. Details zu den jeweiligen Klassen finden sich im MSDN.

Process XML Documents with LINQ to XML 👍 👎

Obwohl andere Formate wie beispielsweise JSON immer mehr Verbreitung gewinnen, bleibt es natürlich nötig, XML verarbeiten zu können – mit diesem Beitrag möchte ich zeigen, wie XML-Dokumente mit LINQ to XML besonders einfach verarbeitet werden können. LINQ selbst werde ich separat noch ausführlich behandeln.

Als Ausgangslage für unser Beispiel soll folgendes XML-Dokument dienen:

Persons.xml

010203040506070809101112131415161718

<personList>    <person id="1">        <firstName>Anders</firstName>        <lastName>Hejlsberg</lastName>    </person>    <person id="2">        <firstName>Bjarne</firstName>        <lastName>Stroustrup</lastName>    </person>    <person id="3">        <firstName>James</firstName>        <lastName>Gosling</lastName>    </person>    <person id="4">        <firstName>Rasmus</firstName>        <lastName>Lerdorf</lastName>    </person></personList>

Wir möchten daraus eine (generische) Liste von Person-Objekten erzeugen. Die Klasse soll auch gleich die Methode zur XML-Verarbeitung erhalten, welche mit LINQ to XML nun besonders einfach umzusetzen ist:

Person.cs

010203040506070809101112131415161718192021222324252627

public class Person {    public int PersonID {        get;        set;    }
    public string FirstName {        get;        set;    }
    public string LastName {        get;        set;    }

    public static List<Person> ParseXML(string xml) {        return XElement.Parse(xml)            .Descendants("person")            .Select(p => new Person() {                PersonID  = Int32.Parse(p.Attribute("id").Value),                FirstName = p.Element("firstName").Value,                LastName  = p.Element("lastName").Value            }).ToList();    }}

Das Vorgehen dürfte eigentlich weitestgehend selbsterklärend sein. Obwohl selbstverständlich mehr Funktionalität zur Verfügung steht, dürften mit diesem kleinen Beispiel bereits die wichtigsten Fälle abgedeckt sein. Weitere Informationen finden sich ausgehend von XDocument im MSDN.

Open and close Disk Tray with C# 👍 👎

In ein paar vorherigen Artikeln haben wir bereits externe Funktionalität per DllImport verwendet, was wir nun nochmals benötigen werden. Diesmal soll es darum gehen, den Laufwerksschacht zu öffnen und zu schließen.

Wir implementieren dazu folgende (sehr einfache) Klasse:

DiskTray.cs

010203040506070809101112131415161718

public static class DiskTray {    public static void Close() {        mciSendString("set CDAudio door closed", null, 0, IntPtr.Zero);    }
    public static void Open() {        mciSendString("set CDAudio door open", null, 0, IntPtr.Zero);    }

    [DllImport("winmm")]    private static extern int mciSendString(        string lpstrCommand,        string lpstrReturnString,        int uReturnLength,        IntPtr hwndCallback    );}

Die Verwendung – beispielsweise im Rahmen einer Fernwartung – gestaltet sich nun äußerst einfach:

Erweiterungsmethoden verwenden

DiskTray.Open();   // öffnenDiskTray.Close();  // schließen

Für interessierte Leser finden sich im MSDN weiterführende Informationen zu mciSendString.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Project links

BitStadt – Stadtportal
Berlin · Hamburg · Amsterdam
CCC – Fahrplan
Schedules for the CCCongress

Categories / Archive | Übersicht

General (22)
Society (5)
Projects (12)
Software development (94)
Technics (10)
Theory (9)

PHP functions in C# (136)
Dictionary (257)