Gestern Abend habe ich mich mal wieder ein wenig mit Fluent NHibernate beschäftigt. Mein Ziel war es, eine Objektstruktur, die aus einer Basisklasse und zwei abgeleiteten Klassen besteht mittels Fluent NHibernate zu speichern.

Nach einigem Fehlversuchen bin ich dann zu folgendem Ergebnis gekommen:

public class KontaktMap : ClassMap<Kontakt>
    {
        public KontaktMap()
        {
            Id(x => x.KontaktId)
                .GeneratedBy
                .GuidComb()
                .WithUnsavedValue("00000000-0000-0000-0000-000000000000");
 
            Map(x => x.KontaktPerson);
 
            JoinedSubClass<Brief>("KontaktId", MapBrief);
            JoinedSubClass<Anruf>("KontaktId", MapAnruf);
        }
 
        private static void MapBrief(JoinedSubClassPart<Brief> part)
        {
            part.Map(x => x.Absender);
            part.Map(x => x.Text);
        }
 
        private static void MapAnruf(JoinedSubClassPart<Anruf> part)
        {
            part.Map(x => x.Telefonnummer);
            part.Map(x => x.Bemerkung);
        }  
    }

Hier das vollständige Beispiel: Download

Habt ihr Euch auch schon einmal darüber geärgert, wieder diese unschönen XML-Dateien für das Mapping von NHibernate schreiben zu müssen? Seit kurzem gibt es gegen diese Unschönheit eine Lösung. Fluent NHibernate bietet Euch die Möglichkeit Eure Mappings “strongly typed” zu definieren. Anstatt der hbm.xml-Datei gibt es mit Fluent NHibernate eine Mapping-Klasse.

Die Klasse Person mit einer Liste von Adressen

    public class Person
    {
        public virtual Guid PersonId { get; set; }
        public virtual string Vorname { get; set; }
        public virtual string Nachname { get; set; }
        public virtual IList<Adresse> Adressen { get; set; }
    }

kann dann wie folgt gemappt werden.

    public class PersonMap : ClassMap<Person>
    {
        public PersonMap()
        {
            Id(x => x.PersonId)
                .GeneratedBy
                .GuidComb()
                .WithUnsavedValue("00000000-0000-0000-0000-000000000000");
 
            Map(x => x.Vorname).WithLengthOf(50);
            Map(x => x.Nachname).WithLengthOf(50);
 
            HasMany<Adresse>(x => x.Adressen)
                .Access.AsProperty()
                .AsBag().WithKeyColumn("PersonId")
                .Cascade.All();
        }
    }

Aber welche Vorteile biete die Fluent-Variante?

1. Die XML-Mapping-Dateien können nicht vom Compiler geprüft werden. Fehlkonfigurationen fallen erst zu Laufzeit auf (Exception)
2. Mapping-Klassen werden wie alle anderen Klassen vom Compiler geprüft. Fehler fallen zu Entwurfszeit auf.
3. Beim Umbennen von Feldern in Klassen über die Refactoring-Möglichkeiten von Visual Studio bzw. Erweiterungen werden die Felder in den Mapping-Klassen ebenfalls umbenannt. Bei den XML-Mappings müsste das händisch gemacht werden.
4. Fluent-Mappings sind deutlich kürzer bzw. deutlich besser lesbar.

Auch die Konfiguration von NHibernate kann über eine FluentVariante realisiert werden.

    ISessionFactory sessionFactory = Fluently
        .Configure()
        .Database(SQLiteConfiguration.Standard.UsingFile("Beispiel.db"))
        .Mappings(m => m.FluentMappings.AddFromAssemblyOf<Person>())
        .BuildSessionFactory();

Unter http://fluentnhibernate.org/ kann man sich die aktuelle Version der NHibernate-Erweitung laden und mit der neuen XML-freien Variante von Mappings anfreunden.

Das komplette Beispiel gibt es hier.

Unsere Java-Truppe hat uns vor ein paar Tagen ihren Continuous Integretion Server Hudson gezeigt. Wir waren sehr davon angetan, wie einfach dieses System zu bedienen ist. Als sie uns sagten, das Hudson auch .net-Projekte bauen kann, wurden wir hellhörig.
Kurze Zeit später hatten wir auf einer VM ein Testsystem online, welches für erste Vergleichstest herhalten musste. Der erste Eindruck von der einfachen Bedienung bestätigte sich bei jedem neuen Projekt, das wir im System hinterlegten. Auch das Thema Unit-Test mit NUnit wird durch ein Add-In für Hudson unterstützt. Wer mal etwas tiefer in die Konfiguration von Jobs schauen möchte, kann ja mal hier gucken

Das einzige, was mir persönlich nicht so gut gefiel, war die Tatsache, das es keine brauchbare Tray-Anwendung zur Darstellung des Status gab. Ich persönlich bin kein großer Freund von Mail-Benachrichtigungen.

Nach kurzem Durchsuchen der Hudson-Seite wurde ich auf die bereitgestellt API aufmerksam… und ein paar Abende später, war die erste Version meiner Tray-Anwendung fertig.

Wer mehr sehen will, kann sich auch auf CodePlex die aktuelle Version oder auch den Source-Code runterladen.

Ich arbeitet zur Zeit in der Firma an einem Prototypen für eine neue Softwareversion. Eine Anforderung ist die transparente Darstellung von mehreren Werten in einem Balken-Diagramm. Leider gibt es für Wpf noch keine freien Komponenten, die für meine Aufgabe nutzbar wären.
Abends kam mir dann die Idee, das Problem selbst zu lösen. Gesagt getan… nach einigen kleinen oder auch großen Kämpfen mit Wpf und Xaml habe ich heute endlich eine in meinen Augen vorzeigbar Version fertiggestellt.

WpfSimpleChart – Source
WpfSimpleChart – Demo

Wer im Netz nach guten Komponenten für Wpf sucht, gibt schnell sehr viel Geld aus. Das es auch anders geht, beweist uns AvalonDock. Von der Docking-Komponente für Wpf ist heute eine neue Version herausgekommen. Diese kann auf Codeplex heruntergeladen werden.
Neben einigen Bugfixes gibt es nun auch eine Dokumentation. Neben der Komponente gibt es auch noch ein sehr schönes Beispiel, welches einem die wesentlichen Funktionen sehr veranschaulicht.

Ich kann nur sagen: Danke und weiter so!!!

Und wieder einmal musste ich “recht” lange suchen um eine vermeidlich einfache Problematik zu klären. Diesmal wollte ich per Button die Einträge einer WPF-ListBox aufwärts bzw. abwärts sortieren.
Hier das Formular:

Bei den Items der ListBox handelt es sich um eine ObservableCollection, die ich über die Eigenschaft ItemsSource an die ListBox gebunden habe.
Im Eventhandler der Buttons habe ich folgenden Code hinterlegt:

lbxProjects.Items.SortDescriptions.Clear();
lbxProjects.Items.SortDescriptions.Add(new SortDescription("ProjectName", ListSortDirection.Ascending));
lbxProjects.Items.SortDescriptions.Add(new SortDescription("Count", ListSortDirection.Ascending));

bzw.

lbxProjects.Items.SortDescriptions.Clear();
lbxProjects.Items.SortDescriptions.Add(new SortDescription("ProjectName", ListSortDirection.Descending));
lbxProjects.Items.SortDescriptions.Add(new SortDescription("Count", ListSortDirection.Descending));

Über die Eigenschaft “SortDescriptions” kann man sehr komfortabel festlegen, wie die Liste sortiert werden soll. In meinem Beispiel sortiere ich zuerst nach dem Projektnamen und dann nach der Anzahl, wodurch sich folgendes Bild ergibt:


Hier der Source für Visual Studio 2008: Download

Bei einem meiner WPF-Projekte ergab sich die Problematik, das ich ein Enum an mehrere RadioButtons binden wollte. Nach recht langer Suche und einigen Versuchen habe ich einen Lösungsweg gefunden, den ich hier an einem kleinen Beispiel zeigen will. Den Source für den ValueConverter habe ich mir nicht ausgedacht. Beim googlen nach der Lösung habe ich durch Zufall diese Seite gefunden und den darauf befindlichen Source verwendet.

Ausgangspunkt ist einen kleine Klasse und ein Enum

public enum ProjectStatus 
{
    InVorbereitung,
    InArbeit,
    Abgeschlossen
}
 
public class Project
{
    public string ProjectName { get; set; }
    public ProjectStatus Status { get; set; }
}

…weiterlesen…

Vor ein paar Tagen habe ich mich mal mit der Frage auseinandergesetzt, wie man mit Hilfe der DTE in einen vsPackage Einstellungen ändern kann. Auslöser dafür war der Wunsch meines Kollegen Tobi, die Einstellungen für das Debugging mit Hilfe des SourceServers von Microsoft auf einfache Art und Weise ein und ausschalten zu können. Die Einstellungen jedes Mal über die Tools -> Options anzupassen dauert einfach zu lange.

Einfach ein Visual Studio Integration Package über File->New…->Projects->Extensibility anlegen und in die Methode “MenuItemCallback” folgende Code schreiben bzw. kopieren:

bool? serverSupport = false;
 
DTE dte = GetService(typeof(DTE)) as DTE;
Properties properties = dte.get_Properties("Debugging", "General");
// suchen der richtigen Einstellungen
foreach (EnvDTE.Property prop in properties)
{
    if (prop.Name == "EnableJustMyCode")
    {
        prop.Value = !Convert.ToBoolean(prop.Value);
        serverSupport = !Convert.ToBoolean(prop.Value);
    }
    if (prop.Name == "EnableSourceServer")
    {
        if (serverSupport.HasValue)
        {
            prop.Value = serverSupport.Value;
            ((MenuCommand)sender).Checked = serverSupport.Value;
        }
    }
}

Beim Versuch mein vsPackage für die Implementierung von Interfaces ein wenig zu erweitern, bin ich auch ein seltsames Problem gestoßen.
Über die vom AddIn erzeugten Getter und Setter wollte ich ein Attribute per Code setzen. Hierfür gibt es eigentlich die Methode “AddAttribute”…Gesagt getan…hier der Code:

CodeFunction getter = prop.Getter;
getter.Attributes("MyAttribute", "myValue", -1);

Der Compiler erzeugt alles ganz brav und startet das vsPackage im Visual Studio Hive. Alles fein…naja vielleicht bis auf, wenn man das AddIn benutzen will.
An besagter Stelle kommt eine sehr aussagekräftige Exception mit der Meldung “Unbekannter Fehler”. Komisch ist nur, das die Methode wohl nur auf den Gettern bzw. Settern(CodeFunction) Probleme macht. Bei “CodeProperty” bzw. “CodeClass” funktioniert alles wunderbar….