seeseekey.net - Invictus Deus Ex Machina

In den letzten Tagen habe ich für ein Projekt einen REST-Server geschrieben. Der Server läuft unter .NET bzw. Mono – also war ich auf der Suche nach einer passenden Bibliothek bzw. einem Framework, welches mich bei dem Aufsetzen eines solchen Servers unterstützt. Nach einem Blick auf Nancy und einigen anderen Frameworks bin ich schlussendlich bei Grapevine gelandet.

sukona.github.io

sukona.github.io

Dabei handelt es sich um eine Bibliothek, welche neben einem REST-Client auch einen REST-Server bereitstellt. Das Hauptaugenmerk der Entwicklung wird dabei auf den REST-Server gelegt. Mit Hilfe des Frameworks lässt sich ein REST-Server mittels weniger Zeilen Quellcode aufsetzen:

ServerSettings settings = new ServerSettings();
settings.Host = "localhost";
settings.Port = "1111";

RestServer server = new RestServer(settings);
server.Start();

In diesem Beispiel werden die Einstellungen für den Server angelegt und anschließend dem Server übergeben. Danach wird der Server mit der Methode Start hochgefahren. Damit verfügt man zwar über einen REST-Server, dieser verfügt allerdings über keinerlei Methoden was die praktische Verwendung eher erschwert. Ressourcen für den Server werden mittels des Attributes RestResource markiert:

[RestResource(BasePath = "/time/")]
public class TimeModule
{
    [RestRoute(PathInfo = "date")]
    public IHttpContext GetDate(IHttpContext context)
    {
        context.Response.SendResponse(Grapevine.Util.HttpStatusCode.Accepted, getDate());
        return context;
    }
}

Über das Attribut RestRoute wird eine Methode für Grapevine gekennzeichnet – das Pathinfo definiert dabei den Pfad über welchen diese aufgerufen werden kann. Durch den über das Attribut RestResource festgelegten BasePath lautet die vollständige URL für die Ressource:

http://localhost:1111/time/date

Wird diese Methode per GET aufgerufen, so wird das aktuelle Datum zurückgegeben. Damit ist ein minimaler REST-Server mit einer Ressource implementiert. Grapevine selbst ist unter der Apache Lizenz lizenziert und damit freie Software. Der Quelltext der Bibliothek befindet sich auf GitHub.

Vor einiger Zeit stellte ich die Software FocusWriter (als Alternative zum iaWriter) für das ablenkungsfreie Schreiben vor. Daneben gibt es weitere Alternativen – einer dieser Alternativen ist WriteMonkey. Im Gegensatz zum FocusWriter wirkt WriteMonkey aufgeräumter, was der Schreiberfahrung zu gute kommt. Außerdem unterstützt WriteMonkey Markdown und ermöglicht so das Schreiben von strukturierten Texten.

WriteMonkey im Einsatz

WriteMonkey im Einsatz

Im Gegensatz zum FocusWriter steht der WriteMonkey leider nicht unter einer freien Softwarelizenz; sondern wird als Freeware vertrieben. Zu finden ist WriteMonkey auf der offiziellen Seite unter writemonkey.com.

Wer den Weltraum betrachten möchte, kann sich ein Teleskop kaufen – wem das zu kostenintensiv ist, der kann es mit dem Wordwide Telescope von Microsoft probieren. Dabei handelt es sich um eine Windows- und Webanwendung, in welcher unterschiedliche Teleskopaufnahmen miteinander kombiniert und welche wie durch ein virtuelles Teleskop betrachtet werden können.

worldwidetelescope.org

worldwidetelescope.org

Microsoft hat die Anwendung unter der MIT-Lizenz freigegeben, damit ist das Wordwide Telescope freie Software. Der Quelltext für das ist auf GitHub zu finden – die offizielle Seite des Projektes unter worldwidetelescope.org.

Unter Xamarin Studio ist es wie in vielen IDEs möglich den Quelltext automatisch zu formatieren. Allerdings unterscheidet sich das Konzept etwas, von anderen C#/.NET IDEs wie dem Visual Studio. Xamarin Studio kennt hierbei einmal Benutzerrichtlinien und normale Einstellungen. In den Einstellungen kann die Codeformatierung für den entsprechenden Nutzer angelegt und modifiziert werden.

Die Einstellungen im Xamarin-Studio

Die Einstellungen im Xamarin Studio

Möchte man bestimmte Einstellungen allerdings auf mehreren Rechnern nutzen, so sollte man lieber eine Benutzerrichtlinie anlegen. Wenn die passenden Einstellungen in der Benutzerrichtlinie definiert sind, können sie auch als Datei exportiert und auf dem anderen Rechner importiert werden. Damit die Nutzerrichtlinie Wirkung zeigt, muss sie in den Einstellungen ausgewählt werden – damit werden die aktuellen Einstellungen mit denen der Richtlinie überschrieben. Ändert man die Richtlinie muss dieser Prozess wiederholt werden. Nachdem die Einstellungen angepasst wurden, kann die geöffnete Datei mittels Ctrl + I neu formatiert werden.

Ein Quelltext wird während der Entwicklung gewöhnlich kommentiert. Unter C# bzw. .NET gibt es dafür Kommentare nach einem bestimmen Schema. Über einer Methode könnte ein solcher Kommentar z.B. aussehen:

/// <summary>
/// Distance between a and b.
/// </summary>
/// <param name="a">The first vector.</param>
/// <param name="b">The second vector.</param>

Diese Kommentare kann die freie Software Doxygen auswerten und daraus eine Dokumentation erzeugen. Im Gegensatz zu anderen Lösungen wie Sandcastle ist Doxygen betriebsystemübergreifend verfügbar und kann somit – wie in diesem Beispiel – unter Mac OS X genutzt werden. Im ersten Schritt sollte Doxygen installiert werden. Unter Mac OS X kann dies einfach über MacPorts geschehen:

sudo port install doxygen

Nachdem Doxygen installiert ist, sucht man im Terminal den Ordner des Entwicklungsprojektes heraus und gibt dort ein:

doxygen -g projektname.doxygen

Damit wird eine Standard-Doxygen-Konfiguration erzeugt. In dieser Datei werden nun ein paar Änderungen vorgenommen:

PROJECT_NAME = "Testprojekt"
PROJECT_NUMBER = "Release Candidate 1"
OUTPUT_DIRECTORY = docs
RECURSIVE  = YES

Über den Aufruf:

doxygen projektname.doxygen

kann nun die HTML-Dokumentation des Quelltextes erzeugt erzeugt werden und diese anschließend im Browser genutzt werden.

Manchmal ruft man eine Methode unter .NET aus einem anderen Thread heraus auf. Je nachdem wie die Methode aufgerufen wird, kann es notwendig sein die Methode über Invoke aufzurufen. Mit folgendem Pattern geschieht dies nach Notwendigkeit automatisch:

private void MakeSomeFoo()
{
	MethodInvoker method=delegate
	{
		//Do some foo
		DoSomeFoo();
	};

	if(InvokeRequired) BeginInvoke(method);
	else method.Invoke();
}

Im MethodInvoker-Delegate ist der eigentliche Quellcode der Funktion zu finden. Dieser wird je nach Notwendigkeit im korrekten Thread aufgerufen.

Wenn man in einem .NET Property Grid ein DateTime-Objekt bearbeitet, so klappt ein Kalender auf, in welchem das Datum eingestellt werden kann. Anschließend kann umständlich die Uhrzeit eingestellt werden. Möchte man dieses Prozedere etwas vereinfachen, kann man für das DateTime-Objekt einen neuen UITypeEditor schreiben:

public class DateTimePickerEditor : UITypeEditor
{
	IWindowsFormsEditorService windowsFormsEditorService;
	DateTimePicker dateTimePicker=new DateTimePicker();

	public DateTimePickerEditor()
	{
		dateTimePicker.Format=DateTimePickerFormat.Custom;
		dateTimePicker.CustomFormat=String.Format("{0} {1}",
                 Application.CurrentCulture.DateTimeFormat.ShortDatePattern,
                 Application.CurrentCulture.DateTimeFormat.ShortTimePattern);
	}

	public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
	{
		return UITypeEditorEditStyle.DropDown;
	}

	public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
	{
		if(provider!=null)
		{
			windowsFormsEditorService=provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
		}

		if(this.windowsFormsEditorService!=null)
		{
			dateTimePicker.Value=(DateTime)value;
			windowsFormsEditorService.DropDownControl(dateTimePicker);
			value=dateTimePicker.Value;
		}

		return value;
	}
}

Nachdem der Editor fertiggestellt ist muss beim entsprechenden DateTime-Objekt noch der passende der Editor per Attribut definiert werden:

[EditorAttribute(typeof(DateTimePickerEditor), typeof(UITypeEditor))]
public DateTime DateAndTime;
{
	get
	{
		return dateAndTime;
	}
	set
	{
		dateAndTime=value;
	}
}

Damit verfügt man nun über einen Editor im Property Grid, welcher die Bearbeitung von Datum und Zeit komfortabel erlaubt.

Unter .NET gibt es einige Eigenschaften, welche mit Formatierungsstrings gefüttert werden, so z.B. die Eigenschaft:

picker.CustomFormat="dd/MM/yyyy HH:mm:ss";

Die Herangehensweise den Formatierungsstring von Hand einzutragen ist dabei gefährlich – spätestens wenn es an die Lokalisierung der Anwendung geht. Glücklicherweise kann man diese Date Pattern anhand der aktuellen Kultureinstellung (CurrentCulture) ermitteln:

Application.CurrentCulture.DateTimeFormat.LongDatePattern
Application.CurrentCulture.DateTimeFormat.LongTimePattern
Application.CurrentCulture.DateTimeFormat.ShortDatePattern
Application.CurrentCulture.DateTimeFormat.ShortTimePattern

Neben den hier gezeigten Pattern, gibt es noch eine Reihe weiterer wie z.B. MonthDayPattern. Obige Definition würde nun wie folgt aussehen:

picker.CustomFormat=String.Format("{0} {1}", Application.CurrentCulture.DateTimeFormat.ShortDatePattern, Application.CurrentCulture.DateTimeFormat.LongTimePattern);

Vor ein paar Tagen war ich auf der Suche nach einer .NET Bibliothek zum Lesen und Schreiben von ePub Dateien. Bei ePub handelt es sich um einen offenen Standard für eBooks. Möchte man ePub-Dateien nur lesen, so dürfte sich die Bibliothek ePubReader anbieten, welche auf CodePlex zu finden ist.

epubreader.codeplex.com

epubreader.codeplex.com

Ist man auch auf das Schreiben von ePub-Dateien angewiesen, gibt es die Bibliothek DotNetEpub. An zweiter Stelle wäre die Bibliothek epubsharp.net zu nennen, allerdings existiert zu dieser Bibliothek kein Quelltext.

Manchmal möchte man private Variablen und Eigenschaften einer Klasse mittels NUnit testen. Im Normalfall lautet die Antwort auf diese Fragestellung – Nein. Stattdessen soll nur das öffentliche Interface getestet werden. Möchte bzw. muss man trotzdem ein privates Mitglied einer Klasse testen, so muss man sich der Reflection bedienen. Das könnte dann so aussehen:

string[] lines=(string[])typeof(MyClass).GetField("Lines",BindingFlags.NonPublic|BindingFlags.Static).GetValue(null);

In diesem Fall wird sich das statische String Array Lines aus der Klasse MyClass geholt. Je nachdem, wie man die entsprechenden BindingFlags einstellt, ist es auch möglich Instanzvariablen zu ermitteln.