seeseekey.net - Invictus Deus Ex Machina

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

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

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

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.

Pünktlich zu Beginn des neuen Jahres war ich auf der Suche nach einer dreistelligen .net Domain. Da es natürlich keinen Spaß macht alle möglichen Kombinationen von Hand auszuprobieren habe ich das ganze automatisiert und mir eine Liste von freien .net Domains zusammengestellt. Die Liste ist dabei erwartungsgemäß relativ kurz:

5q3.net
5sy.net
8q9.net
9b6.net
9g4.net
9h4.net
c0f.net
d9i.net
g6t.net
g7f.net
i8e.net
j3q.net
j8l.net
k0g.net
k1g.net
k1t.net
k6q.net
l0b.net
l2y.net
l5j.net
l5q.net
l6d.net
n0u.net
o0f.net
o3f.net
o6p.net
o6u.net
o8c.net
p3v.net
q8c.net
q8k.net
r9l.net
s8h.net
s9r.net
u7r.net
y5d.net
y9h.net
y9p.net
y9q.net
z5i.net
z7g.net

Wer also noch eine dreistellige Domain braucht, sollte sich ranhalten 😉

In den letzten Tagen habe ich nach einem Pattern für C#/.NET gesucht welches elegant einen Timer zur Verfügung stellt. Gestoßen bin ich dabei auf ein Pattern, welches sich die neuen Keywörter async und await aus den aktuellen C#-Versionen zu Nutze macht. Mit Hilfe dieser Schlüsselwörter lassen sich nebenläufige Funktionen ohne größeren Overhead entwickeln. Die Timer-Funktion sieht dabei so aus:

async void StartPollingTimer()
{
    while(true)
    {
        await Task.Delay(2000);

        //Do something
    }
}

Aufgerufen wird das ganze dabei einfach mittels:

StartPollingTimer();

Der Entwickler muss sich dabei nicht mehr um die Thread-/Task-Verwaltung kümmern und kann damit auf die Schnelle einen Timer implementieren, welcher asynchron läuft.