Diese Reihenfolge gilt für den Lookup von sowohl Views als auch Partial Views. Das gilt für jedes (!) Lookup, auch innerhalb von Views (z.B. bei Html.RenderPartial()). Diesen Umstand kann man sich zu nutze machen um Polymorphie abzubilden. Gegeben ist folgendes Modell.

Damit bietet es sich an, eine Shared View für “Contact” zu erstellen. Aber was passiert mit den Eigenschaften, die nur in den spezialisierten Klassen “Person” und “Company” existieren. Die ContactView ist für die “Contact” Basisklasse typisiert.

An dieser Stelle hilft die Lookup-Reihenfolge. Benutzt man in der Shared View ein RenderPartial(), kann man spezialisierten Views in den Controllern definieren.

Das Ergebnis ist, dass im CompanyController zusätzlich die CompanyView “SpecialView” gerendert wird und im PersonController die PersonView “SpezialView”. Es wird also automatisch zuerst in den Views für den Controller nachgeschaut. Einziges Problem mit RenderPartial() ist eine Exception, wenn in einem dritten Controller die “SpezialView” nicht implementiert ist, die ContactView aber gerendert wird.

Zu bemerken ist abschließend noch, dass die SpezialViews auf die spezialisierten Klassen typisiert ist, also Person bzw. Company. Das MVC2 Framework übernimmt (vereinfacht dargestellt) die Umwandlung von Contact in Person bzw. Company.

<%: Html.TextBoxFor(model => model.File, new { size = "30", type = "file" }) %>

Der vollständige Code sieht folgendermaßen aus.

    // Modell mit der Eigenschaft "File" für die hochgeladene Datei
    public class UploadPartModel
    {
        [Required()]
        public HttpPostedFileWrapper File { get; set; }

        [Required()]
        public string Name { get; set; }

        [Required()]
        public string Description { get; set; }
    }

Das Formular wird mittels “Html.___For()” Methodne zusammengebaut. Nicht vergessen im Formular das “enctype”-Attribut mit dem Wert “multipart/form-data” zu setzen, sonst gibt es nicht serverseitig viel zu sehen.

    <% Html.EnableClientValidation(); // used for client side validation with jQuery
       using (Html.BeginForm(null, null, FormMethod.Post, new { enctype = "multipart/form-data" }))
       {
           Html.ValidationSummary(true); %>
    <fieldset>
        <legend>Fields</legend>
        <div class="editor-label">
            <%: Html.LabelFor(model => model.Name) %>
        </div>
        <div class="editor-field">
            <%: Html.TextBoxFor(model => model.Name, new { size = "30" })%>
            <%: Html.ValidationMessageFor(model => model.Name) %>
        </div>
        <div class="editor-label">
            <%: Html.LabelFor(model => model.Description)%>
        </div>
        <div class="editor-field">
            <%: Html.TextBoxFor(model => model.Description, new { size = "30" })%>
            <%: Html.ValidationMessageFor(model => model.Description)%>
        </div>
         <div class="editor-label">
            <%: Html.LabelFor(model => model.File) %>
        </div>
        <div class="editor-field">
            <%: Html.TextBoxFor(model => model.File, new { size = "30", type = "file" }) %>
            <%: Html.ValidationMessageFor(model => model.File) %>
        </div>
        <p>
            <input type="submit" value="Upload" />
        </p>
    </fieldset>
    <% } %>

Das ASP.NET MVC2 Framework biete eine einfache Möglichkeit zur Validierung eines Modells: Data Annotations. Mit Attributen wird die Validierung für das Modell definiert. Im MVC2 Framework sind vier Validatoren enthalten: Required, StringLength, Range und RegularExpression. Eine Klasse “Contact” könnte also folgendermaßen annotiert werden.

public class Contact
{ 
    [Required(ErrorMessage = "Es muss ein Vorname angegeben werden.")]
    [StringLength(200)]
    public string Vorname { get; set; }

    [Required(ErrorMessage = "Es muss ein Nachname angegeben werden.")]
    public string Nachname { get; set; }

    [Range(0, 69, ErrorMessage = "Mit mehr als 69 Kindern halten sie den Weltrekord. Unwahrscheinlich!")]
    public int Kinder { get; set; }

    [RegularExpression(@"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}")]
    public string Email { get; set; }
}

Damit kann anschließend das Modell entsprechend der Attributierung validieren und die Fehlermeldungen an den Anwender ausgeben lassen. Zusätzlich kann man noch eigene Meldungen an die View mittels “ModelState.AddModelError(<Eigenschaft>, <Nachricht>)” durchreichen.

[HttpPost()]
public ActionResult Logon(LogonModel model, string returnUrl)
{
    // Validierung des Modells abfragen: “ModelState.IsValid” 
    if (!ModelState.IsValid) return View(model);

    // Alternativ Meldungen für das gesamte Modell ausgeben
    ModelState.AddModelError("", "Deine eingegebenen Daten sind falsch.");
    return View(model);
}

Benutzerdefinierte serverseitige Validierung

Diese vier Validatoren decken die häufigsten Fällt ab, leider aber nicht alle. Manchmal kommt man um eine eigene Validierung nicht herum. Dazu sieht das MCV2 Framework die Basisklasse “ValidationAttribute” vor. Erbt eine Klasse von dem ValidationAttribute kann die Methoden “IsValid” überschrieben werden. In dieser Methode wird die Validierungslogik implementiert. Hier ist ein kleines Beispiel für eine Validierung, welches die Komplexität eines Kennworts prüft (mindestens ein Buchstabe groß geschrieben).

    public class ComplexPasswordAttribute : ValidationAttribute
    {
        private readonly bool _capitalLetterRequired = true;

        public ComplexPasswordAttribute(bool capitalLetterRequired)
        {
            _capitalLetterRequired = capitalLetterRequired;
        }

        public override bool IsValid(object value)
        {
            if (value == null) return false;
            var valueString = value.ToString();

            if (_capitalLetterRequired)
                if (valueString.ToLower() == valueString)
                    return false;

            return true;
        }
    }

Der Validator kann nun wie die anderen Attribute verwendet werden. Das MVC2 Framework ruft automatisch die “IsValid()” Methode auf und gibt bei einem negativen Ergebnis die Fehlermeldung “ErrorMessage” an die View weiter.

public class LoginData

{ 
    [Required()]

    public string LoginName { get; set; }

    [ComplexPassword(true, ErrorMessage=”Kennwort ist zu einfach”)]

    public string Password { get; set; }

}

Es begab ich folgendes vereinfachtes Problem: Es war Tabelle mit Salaten, die Personen zum Grillen mitbringen. Das Ziel sollte ein Liste gruppiert nach dem Salat sein. Zusätzlich zur Zählung (COUNT) sollten noch alle Personen aufgelistet werden, die den entsprechenden Salat mitbringen (CONCAT).

Google hatte für dieses Problem verschiedene Lösungen. Die einen waren zu kompliziertes SQL (un-Wartbarkeit!) und funktionierten nur für endlich Anzahl von Zeilen bzw. nicht wiederverwendbare benutzerdefinierte Funktion. Die eleganteste aber aufwändigste Lösung im Bezug auf das Deployment schien das Entwickeln einer eigenen Aggregat-Funktion “Concat”. An Ende war die eigene Aggregatfunktion das einfachste und das Deployment überschaubar (Adminsicher ).

Vorgehen

1. Erstellen der Assembly
2. SQL Server anpassen
3. Aggregatfunktion verwenden

.NET Assembly erstellen

Visual Studio 2010 unterstützt bei der Erstellung von SQL Server Assemblys über den “Neues Projekt” Wizard.

Anschließen kann über “Hinzufügen” eine neues Aggregat angelegt werden.

Das Klasse der Aggregatfunktion in der .NET Assembly ist selbsterklärend. Die Methoden werden mittels Reflection aufgerufen, daher ist keine separate Schnittstelle zu implementieren. Die Schnittstelle “IBinarySerialize” dient dazu, das in dem Klassenattribut deklarierte “Format.UserDefined” (MSDN) zu implementieren.

using System;
using Microsoft.SqlServer.Server;
using System.Data.SqlTypes;
using System.IO;
using System.Text;

namespace SwkAggregates
{
    [Serializable]
    [SqlUserDefinedAggregate(
        Format.UserDefined, //use clr serialization to serialize the intermediate result
        IsInvariantToNulls = true, //optimizer property
        IsInvariantToDuplicates = false, //optimizer property
        IsInvariantToOrder = false, //optimizer property
        MaxByteSize = 8000) //maximum size in bytes of persisted value
    ]
    public class Concat : IBinarySerialize
    {
        /// <summary>
        /// The variable that holds the intermediate result of the concatenation
        /// </summary>
        private StringBuilder _intermediateResult;

        /// <summary>
        /// Initialize the internal data structures
        /// </summary>
        public void Init()
        {
            this._intermediateResult = new StringBuilder();
        }

        /// <summary>
        /// Accumulate the next value, not if the value is null
        /// </summary>
        /// <param name="value"></param>
        public void Accumulate(SqlString value)
        {
            if (value.IsNull)
            {
                return;
            }

            this._intermediateResult.Append(value.Value).Append(", ");
        }

        /// <summary>
        /// Merge the partially computed aggregate with this aggregate.
        /// </summary>
        /// <param name="other"></param>
        public void Merge(Concat other)
        {
            this._intermediateResult.Append(other._intermediateResult);
        }

        /// <summary>
        /// Called at the end of aggregation, to return the results of the aggregation.
        /// </summary>
        /// <returns></returns>
        public SqlString Terminate()
        {
            string output = string.Empty;
            //delete the trailing comma, if any
            if (this._intermediateResult != null
                && this._intermediateResult.Length > 1)
            {
                output = this._intermediateResult.ToString(0, this._intermediateResult.Length – 2);
            }

            return new SqlString(output);
        }

        public void Read(BinaryReader r)
        {
            _intermediateResult = new StringBuilder(r.ReadString());
        }

        public void Write(BinaryWriter w)
        {
            w.Write(this._intermediateResult.ToString());
        }
    }
}

Hinweis: Die Assembly muss keinen Strong Name besitzen. Es lassen sich auch eine nicht-signierte Assemblys in den SQL Server hochladen. Ob das Bestandteil der neuen Sicherheitspolitik von Microsoft ist wage ich zu bezweifeln.

Also bleibt nur noch das Kompilieren der DLL und anschließend das Integrieren in den SQL Server.

SQL Server Integration

Die SQL Server Integration besteht aus zwei Schritten.

1. Hochladen der Assembly in den SQL Server
2. Erstellen einer Aggregatfunktion mit einem “API-Call” auf die Klasse in der DLL

Das Script enthält auch die optionalen Schritte, wenn das Ausführen von Assemblys in der Datenbank noch nicht aktiviert wurde. Das Script ist durch die Kommentierung (hoffentlich) selbsterklärend.

– Add assembly to database
CREATE ASSEMBLY SwkUtilities FROM ‘d:\SwkAggregates.dll’
WITH PERMISSION_SET=SAFE;
GO

– Create aggregate function which calls the concrete "Concat" class
CREATE AGGREGATE Concat(@input nvarchar(4000))
RETURNS nvarchar(4000)
EXTERNAL NAME [SwkUtilities].[SwkAggregates.Concat];
GO

– Enable cls code execution. It is disabled by default
sp_configure ‘clr enabled’, 1;

GO

– Deploy the "clr enabled" setting in sql server
reconfigure
GO

Zu bemerken ist, dass die Assembly im SQL Server einen symbolischen Namen “SwkUtilities” erhält. Der API-Call erfolgt über diesen symbolischen Namen. Außerdem wird die DLL wird in den SQL Server hochgeladen und ist damit Bestandteil der Datenbank. Das hat natürlich Auswirkungen auf Backup und Restore Szenarien. Bei einem Backup werden die Assemblies mitgesichert d.h. es entfällt ein FileSystem Backup. Im Gegenzug werden mit einem Restore der Datenbank auch die Assemblies wiederhergestellt.

SQL Verwendung

Ab jetzt heißt es viel Spaß mit der neuen Aggregat Funktion und der geplanten Grillfete .

SELECT Salat, Count(*), dbo.Concat(Person)
FORM Grillfest
GROUP BY Salat

8:15 Mist! Viel zu spät losgefahren und in den Berufsverkehr geraten. Gehofft, dass alles noch klappt und es noch Frühstück gibt. Die Uhr rennt, der Verkehr steht.

9:25 Endlich da. Alle Parkplätze am Hotel waren leider besetzt. Also in Köln einen Parkplatz gesucht und zum Glück einen in der Nähe gefunden! Zeit für ein kleines Frühstück gehabt und die ersten bekannten Gesichter (wieder)gesehen wie Jan Welker und Gregor Biswanger. Besonders interessant waren die Gesichter hinter den Blogs die ich nur von Fotos kannte wie Thorsten Hans, Philip Proplesch und Gordon Breuer.

9:45 Begrüßung und Keynote durch die Organisatoren Roland Weigelt, Albert Weinert und Stefan Lange. Leider war der Raum viel zu voll um noch einen Platz zu ergattern. Also weiter gefrühstückt und gequatscht, dieses mal unter anderem mit Rainer Stropek über TimeCockpit und Windows Azure.

10:25 Der erste Vortrag beginnt: “Give Your Application a Triple Boost with Windows 7, Microsoft .NET 4.0, and Intel Multi-core” vom Rami Radi. Es ging nicht wie von mir erwartet um Windows 7 Applikationen und Multi-core Entwicklung sondern um Prozessorarchitektur und Auswirkungen auf den Entwickler. War man offen für dieses Thema, war der Vortrag sehr interessant und informativ. Besonders die Tick-Tock Vorgehensweise von Intel ist auch auf andere Projekte anwendbar und hat einen Hauch von “Red, Green, Refactor”.

11:40 Nicht nur draußen sondern auch im zweiten Vortrag war der Himmel blau…Azure-Blau. Rainer Stropek hat einen schönen Vortrag über die Migration einer lokalen Webapplikation in die Cloud gehalten. Dabei durften die Herausforderungen wie Datenbank und Dateisystem nicht fehlen. Pünktlich nach einer Stunde war die Applikation in der Cloud und lief.

12:55 Den dritten Vortrag habe ich sozusagen geschwänzt. Ich hätte sehr gerne den Vortrag von Oliver Sturm (Funktionale Programmierung in C#) oder von Thorsten Hans (MSBuild) gehört.Ich habe mich allerdings in den Sprecherraum zurückgezogen und bin noch einmal meine Präsentation durchgegangen.

13:55 Das Essen sah sehr lecker aus. Leider war mir der Andrang zu groß, also habe ich mich in die Sonne gelegt und abgewartet. Als ich mir dann die Mühe gemacht habe, Essen zu gehen war nur noch Nachtisch da. Als ich schließlich vom ganzen süßen Zeug satt war wurde neues Essen aufgelegt. Leider zu spät aber es war reichlich Essen da.

15:00 Es war endlich so weit, mein ASP.NET MVC2 Vortrag. Leider habe ich nur einen Teil von dem gezeigt, was ich zeigen wollte. 60 Minuten gingen viel zu schnell vorbei und habe mich viel zu lange an den Grundlagen aufgehalten. Es war viel zu wenig von den neuen tollen Features in ASP.NET MVC2.

16:15 Danach ging es dann zur “Konkurrenz”: ASP.NET 4.0 WebForms von Jan Welker. Es gab einen schönen Überblick über die neuen Features von ASP.NET 4.0. Die Beispiele waren sehr interessant und aufschlussreich. Sogar für mich als nicht WebForms Entwickler, da ASP.NET MVC2 auf WebForms aufsetzt.

17:30 Zu guter letzt ging es in den Vortrag “Warum sie JavaScript hassen sollten” “Warum sie nach diesem Vortrag JavaScript nicht mehr hassen können” von Andrè Krämer. Ich bin bekennender JavaScript verweigerer. Aber jQuery im Gegensatz dazu ist wieder schön und sogar ich kann dem inzwischen etwas abgewinnen. Keine Browser-Abfragen, kleine Helfer mit großer Auswirkungen und besonders das nachträgliche dynamisieren der (MVC)WebApplikation. Vielleicht hat Andrè aus mir einen jQuery Freund gemacht…wir werden sehen.

18:40 An der Verlosung habe ich als fauler Sprecher nicht teilgenommen. Für mich gab es nix zu gewinnen und so hatte ich Zeit für ein paar ruhige Gespräche abseits des Rahmenprogramms mit anderen Faulpelzen. Ich hatte auch ohne Feedbackbogen noch eine Tasse ergattert und das reicht als Preis . Einen großen Dank an die nette Tassen-Dame.

19:00 Endlich die Grillfete. Lange hinausgeschoben, lange angekündigt und endlich war es so weit. Ein riesen Dank an Jan Welker und die aktiven Mitglieder des dotnet Forums. Das Essen war lecker, das Wetter super und die Teilnehmer allesamt nett.

21:30 Der Tag war lang, die Nacht war kurz. Noch einen Strauß Blumen für meine Frau gekauft, die mich seit Wochen nur noch vor dem Notebook sitzen sah und nicht viel von mit hatte. Glotze an, Augen zu.

Ich freue mich schon jetzt auf die dotnet Cologne 2011 und vielleicht wieder als Sprecher. Noch einmal einen riesigen Dank an die Organisatoren und Helfer der dotnet Cologne 2010.

Area Support

In der zweite Version des MVC Frameworks für ASP.NET wurden sog. “Areas” eingeführt. Mit Areas können Controller thematisch gruppiert und als Unterprojekt verwaltet werden. Jede Area bekommt eine eigene Ordnerstruktur mit “Controllers”, “Models” und “Views” und enthält damit zu den Controllern die entsprechenden Views und Models. Eine Area kann als separates Modul betrachtet und entwickelt werden. Große und komplexe Projekte können in kleine überschaubare Module gegliedert werden.

Vorteile ergeben sich besonders, wenn Module tatsächlich unabhängig voneinander implementiert werden. So können wiederkehrende oder zentrale Komponenten wie “Blog”, “Wiki” oder “Benutzeradministration” zentral implementiert und weiterentwickelt werden. Projekte, welche diese Komponenten verwenden, können auf diese Module verweisen oder bei kundenspezifischen Anpassungen einen bestimmten Entwicklungsstand verwenden und anpassen.

Areas anlegen und verwenden

Areas werden im Visual Studio über das Kontextmenü “Hinzufügen” –> “Bereich/Area” hinzugefügt. Nach der Eingabe des Namens werden die Verzeichnisse und die Infrastruktur für das erweiterte Routing (“[Area-Name]AreaRegistration.cs”) angelegt. Die Area-Registration erbt von einer Klasse “AreaRegistration” um die Routen separiert pro Modul definieren zu können. Dadurch wird eine absolute Unabhängigkeit der Module realisiert.

Für Links innerhalb der Applikation kann weiterhin die “Html.ActionLink()” Methode verwendet werden. Es muss nur ein weiteres Routing-Schlüsselwort “Area” in den RouteValues für die Ziel-Area definiert werden. Zu beachten ist allerdings die polymorphe Signatur der Methode.

<li><%: Html.ActionLink("Admin", "Index", "Default", new {Area = "Admin"}) %></li>
<li><%: Html.ActionLink("Admin", "Index", "Default", new {Area = "Admin"}, new {}) %></li>

Die 2. Zeile scheint gleich zu sein, da der Parameter leer ist. Der leere Parameter bewirkt aber den Aufruf einer anderen Methode wegen einer anderen Methodensignatur. Im ersten Fall wird der Parameter mit der Area Definition als “HtmlAttributes” interpretiert. In zweiten Fall wird der leere Parameter als “HtmlAttributes” interpretiert und die Area Definition wird zu "RouteValues”.

Die Methode “ActionLink()” arbeitet relativ zu der aktuellen Area. Befindet man sich in der Root Area ist alles kein Problem. Befindet man sich allerdings innerhalb einer Area wird als Default die aktuelle Area verwendet. Wichtig wird das bei zentralen Menüs oder in der Masterpage. Die Masterpage eines Standard MVC2 Projektes enthält Links auf die Startseite (DefaultController –> Index) ohne Angabe einer Area. Innerhalb einer Area wird daraus der Link auf die Startseite der Area (Area/DefaultController –> Index). Der Link unabhängig von der Area auf die Startseite muss also mit leerer Area erfolgen:

<li><%: Html.ActionLink("Admin", "Index", "Default) %></li>
<li><%: Html.ActionLink("Admin", "Index", "Default", new {Area = ""}, new {}) %></li>

Zwei Controller, ein Name

Gibt es in einem Projekt zwei Controller mit dem gleichen Namen funktioniert die automatisch generierte Default-Route nicht mehr. Das MVC Framework ist nicht in der Lage ohne Angabe des Namespaces den richtigen Controller zu finden, das MVC nur den Kurznamen kennt. Der Default-Route muss in einem solchen Fall der Namespaces des Default-Controlles als Parameter mitgegeben werden.

routes.MapRoute(
    "Default", // Routenname
    "{controller}/{action}/{id}", // URL mit Parametern
    new { controller = "Home", action = "Index", id = UrlParameter.Optional }, // Parameterstandardwerte
    new [] {"SmartHome.Mvc"} // Namespace
);

Shared Views

Bei der Verwendung der Shared Views ist zu berücksichtigen, dass bei automatisch ermittelten Controls erst in der betreffenden Area und anschließend in der Root Area nachgeschlagen wird. Interessant werden diese Aspekte bei z.B. EditorTemplates oder DisplayTemplates. So können Views zentral bereitgestellt und für Areas separat überschrieben werden.

Fazit

Areas sind eine sehr gute Erweiterung des Frameworks. Sind die Stolpersteine bekannt können Areas intuitiv verwendet werden. Besonders im Hinblick auf die modulare Entwicklung von Komponenten bieten sich hier viele Möglichkeiten. Durch das Verwenden eines Team Foundation Servers und Workspacedefinitionen ist ein Zusammenstecken einer Applikation sehr einfach, da wirklich auf die Module innerhalb eines andern Ordners im TFS verwiesen werden kann.

Disclaimer: Diejenigen, die sich gerne unvorbelastet an die FizzBizz Coding Kata heranwagen möchten, sollten hier besser nicht weiterlesen. Der Artikel wird verschiedene Lösung zeigen

Einleitung

Unser firmeninternes Coding Dojo hatte eine relativ einfache Kata: FizzBuzz. Zwar ist die Aufgabe einfach und überschaubar, aber dafür sind die Erweiterungen vielfältig. Bei dieser Kata konnte man das Prinzip von Unit Test und Test Driven Development verdeutlichen. Erweitert man die Implementierung, kann die Implementierung der alten Anforderungen direkt getestet werden. Man merkt also, ob man über die neue Anforderung die alten Anforderungen vergessen hat. Als Organisator habe ich mir in Vorfeld Gedanken über die mögliche Implementierung gemacht, da ich einer der beiden Programmierer war. Bei der Kata musst ich dafür Sorgen, dass die Schnittstellen/Vorgaben so definiert sind dass der Test keine weiteren Vorgaben für die Implementierung macht als die Schnittstelle. Folgendes Klassengerüst war also vorgegeben:

public class FizzBuzzer
{
    public IEnumerable<string> FizzBuzz(int maxZahl)
    {
        throw new NotImplementedException();
    }
}

Das Pair-Programming-System ist auch in ein verändertes Ping-Pong geändert worden: Ich habe einen Test geschrieben, mein Co-Programmierer hat den Test implementiert und ich habe den nächsten Test geschrieben.

Dojo Lösung

Die Lösung im Dojo war die einfachste aller Möglichkeiten…eine Implementierung der Methode und das wars. Selbst als die Erweiterungen kamen wurde der FizzBuzzer höchstens um zwei Konstruktor-Parameter erweitert. Und damit die Tests laufen gabe es einen Default-Konstruktor mit dem Standard “3″ und “5″.

public class FizzBuzzer
{
    #region Felder
    private int _n;
    private int _m;
    #endregion

    #region Konsturktor: (), (n, m)
    public FizzBuzzer() : this(3,5)
    {
    }

    public FizzBuzzer(int n, int m)
    {
        _n = n;
        _m = m;
    }
    #endregion

    public IEnumerable<string> FizzBuzz(int maxNumber)
    {
        //Plausibilitäts prüfung
        if (maxNumber < 1)throw new ArgumentException("Nur Zahlen größer 0 sind erlaubt");
        if (maxNumber > 100000) throw new ArgumentException("Nur Zahlen kleiner oder gleich 100000 sind erlaubt");

        //Liste anlegen
        List<string> words = new List<string>();

        //Alle Zahlen durchlaufen und prüfen
        for (int curNumber = 1; curNumber <= maxNumber; curNumber++)
        {
            //Zahl durch n und m teilbar?
            if ((curNumber % _n) == 0 && (curNumber % _m) == 0)
                words.Add("FizzBuzz");
            else if ((curNumber % _m) == 0)
                words.Add("Buzz");
            else if ((curNumber % _n) == 0)
                words.Add("Fizz");
            else
                words.Add(curNumber.ToString());
        }

        //Ergebniss zurückliefern
        return words;
    }
}

Das ist natürlich nur eine von vielen Varianten einen FizzBuzz zu implementieren. Der Ansatz bei dieser Implementierung ist eine Klasse mit einer Funktion, die alle Varianten enthält. Versucht man eine Erweiterung mit beliebig vielen Fizz-Buzz-Zahlen und Wörtern, würde man die Zahl/Wort Kombination wahrscheinlich in einem Dicitonary ablegen und den zusammengesetzten String (FizzBuzz) für jeden Key des Dictionarys erweitern. Diese Lösung funktioniert nur, weil der Alorithmus zum Ermitteln des FizzBuzz gleich ist und nur durch eine Zahl parametrisiert ist. Ändert sich der Algorithmus oder ist der Algorithmus zum Zeitpunkt der Implementierung unbekannt, ist diese Lösung ungünstig oder funktioniert gar nicht mehr.

Delegaten als Parametrierung

Die Lösung, über die Werte zu Parametrieren reicht also nicht aus, da auch der Algorithmus und die Anzahl der Funkionen (Delegaten)variabel sein kann. Damit muss es eine Lösung geben, mit der ich Funktionen übergeben kann. Und von diesen Möglichkeiten gibt es in C# viele.

Schnittstellen

Der Klassiker ist eine Schnittstelle IFizzBuzz oder eine abstrakte Basisklasse mit unterschiedlichen Implementierungen für die verschiedenen Algorithmen. Mehr oder weniger parametrisierte Implementierungen dieser Schnittstelle werden an eine “Add” Methode des FizzBuzzers übergeben.

public class InterfaceFizzBuzzer
{
    private List<IFizzBuzz> buzzList = null;

    public InterfaceFizzBuzzer()
    {
        buzzList = new List<IFizzBuzz>();
    }

    public void Add(IFizzBuzz aBuzz)
    {
        buzzList.Add(aBuzz);
    }

    public IEnumerable<string> FizzBuzz(int maxNumber)
    {
        IList<string> result = new List<string>();

        for (int i = 1; i <= maxNumber; i++)
        {
            // Result ermitteln
            var numberResult = string.Empty;
            foreach (var item in buzzList)
                currentRes += item.GetForNumber(i);

            // Ergebnis hinzufügen
            if (string.IsNullOrEmpty(numberResult))
                result.Add(i.ToString());
            else
                result.Add(numberResult);
        }

        return result;
    }

Die Schnittstelle mit einer entsprechenden Implementierung sieht dann wie folgt aus:

public interface IFizzBuzz
{
    string GetForNumber(int number);
}
class SimpleFizzBuzzImpl : IFizzBuzz
{
    private int _baseNumber;
    private string _word;

    public SimpleFizzBuzzImpl(int baseNumber, string word)
    {
        _baseNumber = baseNumber;
        _word = word;
    }

    public string GetForNumber(int number)
    {
        if (number % _baseNumber == 0) return _word;
        return string.Empty;
    }
}

Lamba Expressions

Lamba Expressions finde ich für kleinen Aufgaben genial. Man kann Logik an eine Funktion übergeben, ohne dafür entsprechende Schnittstellen, Delegaten oder abstrakte Basisklassen zu definieren. Der besondere Charme liegt dabei in der Übergabe in Logik, die nur einmal benutzt wird, wie bei “where” in LINQ. Die Lamba-Version des FizzBuzzer hat auch eine “Add” Methode, nimmt aber einen Parameter vom Typ Func<int, string> statt des Interfaces an.

public class LambdaFizzBuzzer
{
    private List<Func<int, string>> buzzList = null;

    public LambdaFizzBuzzer()
    {
        buzzList = new List<Func<int, string>>();
    }

    public void Add(Func<int, string> aBuzz)
    {
        buzzList.Add(aBuzz);
    }

    public IEnumerable<string> FizzBuzz(int maxNumber)
    {
        for (int i = 1; i <= maxNumber; i++)
        {
            var currentRes = string.Empty;
            foreach (var item in buzzList)
                currentRes += item.Invoke(i);
            yield return string.IsNullOrEmpty(currentRes) ? i.ToString() : currentRes;
        }
    }
}

Die Verwendung des FizzBuzzer ist dann entsprechend mit Lambda-Expressions.

LambdaFizzBuzzer fb = new LambdaFizzBuzzer();
fb.Add(i => (i % 3 == 0) ? "Fizz" : string.Empty);
fb.Add(i => (i % 5 == 0) ? "Buzz" : string.Empty);

Fazit

Es gibt unterschiedliche Varianten, Code als Parameter an eine Methode zu übergeben. Interfaces und Lambda Expressions habe ich hier gezeigt. Delegaten und abstrakte Basisklasse sind hier zwar nicht vorgestellt, unterscheiden sich aber konzeptionell nicht großartig von Interfaces und Lambda Expressions. Der architekturelle Unterschied oder Frage ist, ob man den Code wiederverwenden möchte und die Algorithmen Teil der Architektur sind oder ob es “flüchtiger Code” wie Lambda Expressions sind.

    public class Program
    {
        static void Main(string[] args)
        {
            // NULL-String deklarieren
            string str = null;
            // Funktioniert NICHT, da es eine Klassenmethode ist
            var bar = str.Contains("elo");

            // Funktioniert, da es eine Extension Method ist
            var foo = str.IfIsNull("Hello");
            // Funktioniert auch! isFoo == "foo"
            var isFoo = ((string)null).IfIsNull("foo");
        }
    }

    internal static class StingExtension
    {
        public static string IfIsNull(this string hello, string alternateText)
        {
            if (hello == null) return alternate;
            return hello;
        }
    }

Aber warum funktioniert das? Weder erscheint eine Compiler Fehlermeldung, noch der ReSharper jammert und zur Laufzeit wird auch keine Exception geworfen. Der Grund liegt in der Übersetzung von Extension Methods durch den Compiler. Eine Extension Method erscheint zwar als Klassenmethode, wird aber durch den statischen Aufruf der Methode ersetzt. Und eine statischer Methodenaufruf ist für Null-Objekte möglich und die Prüfung innerhalb der Methode verhindert die Exception. Damit wirft der Aufruf einer Extension Method auf “Null”-Objekte keine NullReferenceException. Klingt komisch, ist aber so.

Mastermind

Das Spiel Mastermind hat mich eine Zeit begleitet. Der erste Anlauf mit Turbo Pascal hatte geschätzt 500 Zeilen Code um die Eingabe zu validieren und das Ergebnis zu präsentieren. Später habe ich dann mit VB 3 eine neue Version mit Control-Arrays und viel schlankerem Validierungscode geschieben, ca. 30 Zeilen. Leider konnte ich den SourceCode nicht finden, aber dafür könnt ihr hier das Programm herunterladen (incl. vbrun300.dll).

Client-Server-Chat

Das bis dahin größte Projekt war eine Client Server Applikation. Geschrieben habe ich das Programm mit Delphi 3, eine sehr lange Heimat für meine Programmierung. Mit Delphi habe ich die ersten multithreaded Applikationen entwickelt, Datenbankapplikationen geschrieben und Client Server Applikationen gebaut.
Das geniale an diesem Projekt war nicht der Chat, der über eine WinSock Client-Server TCP Verbindung statt fand sondern das “Malbrett”. Mit dieser Zeichenfläche konnten mehrere Benutzer an einem Bild malen. Falls jemand an dem Programm interessiert ist, könnt ihr die Sourcen und das Setup hier herunterladen.

Screenshots des IntraChat

Hier ist noch ein bißchen Turbo Pascal Code. Ich habe mal den Code des “Malfensters” eingefügt. Man sieht, dass die Kommunikation über ein WinSock Control funktioniert.

unit uniMalen;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Menus, Buttons, ExtCtrls, StdCtrls, Spin, ColorGrd;

type TMalen = class(TObject)
            x1, x2, y1, y2, Dicke: Integer;
            Farbe: TColor;
            Werkzeug: Char;
            Absender: ShortString;
     end;
type
  TfrmMalen = class(TForm)
    imgPapier: TImage;
    MainMenu1: TMainMenu;
    Fenster1: TMenuItem;
    Schliessen1: TMenuItem;
    spbRectangle: TSpeedButton;
    spbEllipse: TSpeedButton;
    speWidth: TSpinEdit;
    Label1: TLabel;
    cdbColor: TColorDialog;
    ShapeColor: TShape;
    Label2: TLabel;
    spbLine: TSpeedButton;
    N1: TMenuItem;
    Neu1: TMenuItem;
    spbPixel: TSpeedButton;
    tmrPuffer: TTimer;
    procedure Schliessen1Click(Sender: TObject);
    procedure imgPapierMouseMove(Sender: TObject; Shift: TShiftState; X,
      Y: Integer);
    procedure imgPapierMouseUp(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure GetPaint(text: ShortString);
    procedure Send(Text: ShortString);
    procedure imgPapierMouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure ShapeColorMouseUp(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure tmrPufferTimer(Sender: TObject);
    procedure Neu1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

procedure SendToPuffer(MyWerkzeug: Char);

var
  frmMalen: TfrmMalen;
  Startx, Starty, Currentx, Currenty: Integer;
  LMBGedruckt, MMBGedruckt, RMBGedruckt: Boolean;
  MPuffer: TList;
  Malen: TMalen;

implementation

uses uniMain;

{$R *.DFM}

procedure SendToPuffer(MyWerkzeug: Char);
// var text: String;
begin
        with Malen do begin
             x1 := Startx;
             y1 := Starty;
             x2 := Currentx;
             y2 := Currenty;
             Dicke := frmMalen.SpeWidth.Value;
             Farbe := frmMalen.ShapeColor.Brush.Color;
             Werkzeug := MyWerkzeug;
             Absender := frmMain.csoClient.Socket.LocalHost;
        end;
        MPuffer.Add(Malen);

{     Text := '%p%' + Malen.Werkzeug + '%' + IntToStr(Malen.x1) + '%' + IntToStr(Malen.y1) + '%' + IntToStr(Malen.x2) + '%' + IntToStr(Malen.y2) + '%' + IntToStr(Malen.Dicke) + '%';
     Text := Text + ColorToString(Malen.Farbe) + '%' + Malen.Absender + '%';
     frmMalen.Send(Text);
}end;

procedure TfrmMalen.Send(Text: ShortString);
begin
     frmMain.csoClient.Socket.SendText(Text);
end;

procedure TfrmMalen.GetPaint(Text: ShortString);
begin
     imgPapier.Canvas.Brush.Color := StringToColor(GetString('%', text, 7));
     imgPapier.Canvas.Pen.Color := imgPapier.Canvas.Brush.Color;
     imgPapier.Canvas.Pen.Width := GetInteger('%', Text, 6);
     imgPapier.Canvas.Brush.Style := bsClear;
     Case text[2] of
          'n': Begin
               imgPapier.Canvas.Brush.Color := clWhite;
               imgPapier.Canvas.Pen.Color := imgPapier.Canvas.Brush.Color;
               imgPapier.Canvas.Pen.Width := 1;
               imgPapier.Canvas.Brush.Style := bsSolid;
               frmMalen.imgPapier.Canvas.Rectangle(0, 0, imgPapier.Width, imgPapier.Height);
               end;
          'p': Begin
               frmMalen.imgPapier.Canvas.Pixels[GetInteger('%', Text, 2), GetInteger('%', Text, 3)] := imgPapier.Canvas.Brush.Color;
          end;
          'r': Begin
               frmMalen.imgPapier.Canvas.Rectangle(GetInteger('%', Text, 2), GetInteger('%', Text, 3), GetInteger('%', Text, 4), GetInteger('%', Text, 5));
          end;
          'e': Begin
               frmMalen.imgPapier.Canvas.Ellipse(GetInteger('%', Text, 2), GetInteger('%', Text, 3), GetInteger('%', Text, 4), GetInteger('%', Text, 5));
          end;
          'm': Begin
               frmMalen.imgPapier.Canvas.MoveTo(GetInteger('%', Text, 2), GetInteger('%', Text, 3));
               frmMalen.imgPapier.Canvas.LineTo(GetInteger('%', Text, 4), GetInteger('%', Text, 5));
          end;
     end; //Case
end;

procedure TfrmMalen.Schliessen1Click(Sender: TObject);
begin
     frmMalen.hide;
end;

procedure TfrmMalen.imgPapierMouseMove(Sender: TObject; Shift: TShiftState;
  X, Y: Integer);
begin
     Currentx := x; Currenty := y;
     If LMBGedruckt then begin
      frmMalen.Canvas.Pen.Width := speWidth.Value;
      If spbRectangle.Down then begin
         frmMalen.ImgPapier.Refresh;
         frmMalen.Canvas.Brush.Style := bsClear;
         frmMalen.Canvas.Rectangle(Startx + frmMalen.ImgPapier.Left, Starty + frmMalen.ImgPapier.Top, Currentx + frmMalen.ImgPapier.Left, Currenty + frmMalen.ImgPapier.Top);
      end;
      If spbEllipse.Down then begin
         frmMalen.ImgPapier.Refresh;
         frmMalen.Canvas.Brush.Style := bsClear;
         frmMalen.Canvas.Ellipse(Startx + frmMalen.ImgPapier.Left, Starty + frmMalen.ImgPapier.Top, Currentx + frmMalen.ImgPapier.Left, Currenty + frmMalen.ImgPapier.Top);
      end;
      if spbLine.Down then begin
         frmMalen.ImgPapier.Refresh;
         frmMalen.Canvas.Brush.Style := bsClear;
         frmMalen.Canvas.MoveTo(Startx + frmMalen.ImgPapier.Left, Starty + frmMalen.ImgPapier.Top);
         frmMalen.Canvas.LineTo(Currentx + frmMalen.ImgPapier.Left, Currenty + frmMalen.ImgPapier.Top);
      end;
     end;
end;

procedure TfrmMalen.imgPapierMouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
   Currentx := x; currenty := y;
   IF LMBGedruckt then begin
      If spbRectangle.Down then SendToPuffer('r');
      If spbEllipse.Down then SendToPuffer('e');
      if spbLine.Down then SendToPuffer('m');
   end;
   LMBGedruckt := false;
   MMBGedruckt := false;
   RMBGedruckt := false;
end;

procedure TfrmMalen.imgPapierMouseDown(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
   Startx :=  X; Starty := Y;
   If Button = mbLeft then LMBGedruckt := true;
   If Button = mbMiddle then MMBGedruckt := true;
   If Button = mbRight then RMBGedruckt := true;
end;

procedure TfrmMalen.FormCreate(Sender: TObject);
begin
   frmMalen.imgPapier.Canvas.Create;
   LMBGedruckt := false;
   MMBGedruckt := false;
   RMBGedruckt := false;
end;

procedure TfrmMalen.FormClose(Sender: TObject; var Action: TCloseAction);
begin
     MPuffer.Free;
     Malen.Free;
end;

procedure TfrmMalen.ShapeColorMouseUp(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
     frmMalen.cdbColor.Execute;
     frmMalen.ShapeColor.Brush.Color := frmMalen.cdbColor.Color;
     frmMalen.Canvas.Brush.Color := frmMalen.cdbColor.Color;
     frmMalen.Canvas.Pen.Color := frmMalen.cdbColor.Color;
end;

procedure TfrmMalen.tmrPufferTimer(Sender: TObject);
var Text: ShortString;
begin
   If MPuffer.Count > 0 then begin
     Malen := MPuffer.Items[0];
     Text := '%p%' + Malen.Werkzeug + '%' + IntToStr(Malen.x1) + '%' + IntToStr(Malen.y1) + '%' + IntToStr(Malen.x2) + '%' + IntToStr(Malen.y2) + '%' + IntToStr(Malen.Dicke) + '%';
     Text := Text + ColorToString(Malen.Farbe) + '%' + Malen.Absender + '%';
     frmMalen.Send(Text);
     MPuffer.Delete(0);
   end else begin
       MPuffer.Clear;
   end;
end;

procedure TfrmMalen.Neu1Click(Sender: TObject);
begin
     SendToPuffer('n');
end;

begin
     MPuffer := TList.Create;
     Malen := TMalen.Create;
end.

Im Jahr 1997 habe ich mir die Mühe gemacht, nicht “nur” die Aufgaben zu lösen sondern auch die Lösungen schriftlich auszuarbeiten. Die Rede ist von meiner Teilnahme am 16. Bundeswettbewerb Informatik. Meine Ausarbeitung war leider so schlecht, dass ich noch nicht einmal die erste Runde geschafft habe. Für alle, die sich den Aufgaben auch einmal stellen möchten, sind hier die Aufgaben.

Das erste Programm oder der erste Algorithmus, an den ich mich erinnern kann war -wie könnte es anders sein- ein Programm zum Berechnen von Primzahlen. Es war 1993(!) auf einem C64 und die Berechnung hat echt lange gedauert. Der Nadel-Drucker hat mich Nacht um Nacht wach gehalten, um alle paar Minuten eine Zeile mit 5 oder 6 Primzahlen zu drucken…auf Endlospapier -Gott hab es seelig.
Ich werde wohl die nächsten Tage mal meine alten Disketten vom Speicher holen und mal schauen, was sich dort alles findet.

1. Visual Studio 2008 SP1 (hier)
2. Hotfix für TFS 2010 (hier)

Nun gibt es nur noch eine Sache zu berücksichtigen, die mich mehrere Stunden gekostet hat: Der Team Explorer 2008 kann nicht mit Team Project Collections umgehen. Also muss zum einen die URL vollständig angegeben werden und zusätzlich der Name der Team Project Collection angehängt werden.

Visual Studio 2008 Konfiguration

Beispiel

Das folgende Beispiel zeigt eine klassische “if…then..else” Abfrage mit vielen Zeilen Code um lediglich den Standardtext “leer” zurück zu geben, falls die Eigenschaft “Name” des Objekt NULL ist, ansonsten die Eigenschaft “Name” des Objektes.

if (myObject.Name == null)
{
    return "leer";
}
else
{
    return myObject.Name;
}

Variante 1

if (myObject.Name == null)
    return "leer";
else
    return myObject.Name;

Variante 2

// entweder so ...
myObject.Name == null ? return "leer" : return myObject.Name;
// oder so ...
return myObject.Name == null ? "leer" : myObject.Name;

Variante 3

return myObject.Name ?? "leer";

Der erste Schritt liegt auf der Hand. Mittels eines Proof Of Concept wird die neue Technologie getestet und verifiziert, ob die Technologie zur Architektur passt. Aber wie geht es weiter? Die folgenden fünf Fragen geben eine Entscheidungshilfe für die Entscheidung.

• Erfüllt die Technologie die Anforderungen an die Architektur?
• Will der Kunde diese Technologie haben?
• Wollen die Entwickler diese Technologie einsetzen?
• Wie groß ist der Einfluss der Technologie auf den bestehenden Code?
• Wie leicht lässt sich diese Technologie bei einer Fehlauswahl wieder entfernen?

Zu guter letzt muss wieder der Architekt entscheiden, aber doch bitte bewusst und nach objektiven Kriterien und nicht nach Bauchgefühl.

Zeit für Sauberkeit. Wenn du etwas machst, mache es direkt ordentlich. Später wirst du keine Lust zum Aufräumen haben. Wer hat schon Lust tausende Zeilen von Code nachträglich zu kommentieren und aufzuräumen.

Geh’ in kleinen Schritten. Definiere genau dein Ziel und teile es sinnvoll in möglichst kleine Schritte ein. Gestalte erst ein Formular und schreibe anschließend die Logik. Programmier die Logik in kleinen aber abgeschlossenen Schritten und nicht alles auf einmal.

Erst denken, dann programmieren. Wenn du nicht in der Lage bist, dein Programm auf Papier zu formulieren, wirst du es erst recht nicht schaffen, dieses dann in Code umzusetzen.

Buy it, don’t make it. Bevor du ein Modul programmierst, überlege ob es nicht bereits etwas Fertiges auf dem Markt gibt. Goggle ist dein Orakel: Frag was du suchst und Google wird dir mit OpenSource und kommerziellen Projekten antworten…ganz sicher!

Fragen kostet nix. Es gibt immer jemanden, den man fragen kann. Also wenn du dir mit irgend etwas nicht sicher bist frag nach. 10 Minuten fragen bringt dich weiter als 3 Stunden ‘try and error’.

Halte dich an Coding Guidelines. Coding Guidelines dienen dem allgemeinen Verständnis von Code. Jede Programmiersprache hat ein grundsätzliches Verständnis von “schönem Code”. Halte dich daran. Falls es in deinem Projekt keine Coding Guidelines gibt berufe dich auf allgemein gültige Regeln.

Code muss verständlich sein-für alle. Du entwickelst zwar den Code, aber normalerweise mit anderen zusammen oder andere übernehmen unter Umständen deinen Code. Jeder muss verstehen können was du gemacht hast und warum du es gemacht hast. Sogar du musst noch nach Monaten oder Jahren den Code warten und erweitern können. Und bedenke immer: Je mehr du dokumentierst und deinen Code verständlich programmierst, umso weniger (blöde) Fragen muss man zum Code beantworten.

Logging nicht vergessen. Du musst jederzeit die Möglichkeit haben, dein Programm auch nach der Auslieferung (intern fürs Testen oder beim Kunden in Produktion) verfolgen und debuggen zu können. Fehler müssen immer Persistiert werden. Das erste was der Anwender vergessen hat ist, was er gemacht hat und wie die Fehlermeldung lautete.

Testen, testen, testen. Jeder würde jetzt schreiben, “Unit Testes sind das wichtigste” oder “Test Driven Development ist essentiell”. Es ist viel wichtiger, dass du Bestandteile deiner Applikation isoliert testen und dabei alle Variationen verifizieren kannst. Und wenn es nur eine Test-GUI ist, ist es immerhin ein Test und besser als nichts. (@Stefan Lieser: Sorry )

Mehrmals täglich einchecken. Wenn du kleine Arbeitspäckchen schnürst, kannst du auch mehrmals täglich diese nach dem Implementieren einchecken. Spätestens aber wenn du abends nach Hause gehst. Wichtig sind folgende Punkte für ein gutes und sicheres Einchecken:

• Code zuerst aktualisieren und kompilieren und erst dann einchecken.
• Nur kompilierbaren Code einchecken.
• Immer einen Kommentar für das Einchecken angeben.
• Immer mit einem personalisierten Benutzerkonto Code einchecken.

Events statt Attach/Detach

Das Observer Pattern nach GOF war den meisten (oder allen) Zuhörern bereits bekannt, also konnte direkt mit der ersten .NET Modifikation begonnen werden. Die Logik des Attach und Detach von Beobachtern lässt sich wunderbar durch Events und EventHandler ersetzen. Events implementieren genau diese Funktionalität: Eine Liste von Funktionen zu verwalten und letztlich diese aufzurufen. Durch diesen Umbau ist der Code deutlich schlanker geworden und der Verwaltungscode wurde aus dem Subjekt entfernt.

Statusänderungen im größeren Kontext

Das Observer Pattern bietet eine sehr gute Möglichkeit, Statusänderungen an betroffene Ansichten durchzureichen. Dabei wird das Hollywood Prinzip (“Don’t call us, we call you”) beachtet, nachdem das Subjekt die Beobachter informiert und nicht die Beobachter regenmäßig das Subjekt überprüfen. Ein Problem entsteht, wenn mehrere Subjekte zu unterschiedlichen Zeitpunkten angezeigt werden sollen. Ein gutes Beispiel ist eine Liste aus Subjekten mit verschiedenen Vorschau-Ansichten. Nun wird es schwierig, das neue Subjekt an die unbekannte Anzahl an Ansichten zu senden.

Die Lösung hierfür ist ein SubjectNotifier mit statischen Events zum Verteilen von Nachrichten an alle Beobachter. Jeder Beobachter kann mittels SubjectStateChanged eine auf Statusänderung und mittels SubjectSelected auf eine Subjektänderung reagieren. Über die Raise* Methoden können beliebige Ansichten die entsprechenden Event auslösen, falls sich der Status oder das Subjekt geändert hat.

Fazit

Diese Variante, Statusänderungen eines Subjekts über einen SubjectNotifier zu publizieren, hat mehrere Vorteile. Alle Subjekte (auch neue Instanzen) können über einen zentralen Dispatcher publiziert werden. Es erweitert das Hollywood Prinzip aus dem klassischen Observer Pattern insoweit, dass nicht nur der Beobachter mit DEM Subjekt verbunden ist, sondern das der Beobachter noch nicht einmal das Subjekt kennt sondern von irgendwelchen Subjekten benachrichtigt wird. Ein weiterer Vorteil ist, dass das Subjekt absolut keine Logik zum Verteilen und Verwalten von Statusänderungen enthält. Das Subjekt ist unabhängig von interner Verwaltungslogik die nur einzelne Applikationen betrifft und z.B. in Konsolenanwendung nicht benötigt wird.

… dieses war der erste Streich, doch der zweite folgt sogleich!

Da ich aber von anderen immer zunächst nur das beste denke habe ich mal in die Registry geschaut und siehe an, die GUID ist wirklich ein Internet Explorer Active X.

Jetzt bleibt nur noch offen, ob die “Read Exception” direkt und unmittelbar damit zusammen hängt (bestimmt! ) und was ich da gegen machen kann.

PostSharp ist ein Framework zum Implementieren von Aspekt Orientierter Programmierung (AOP). Das Ziel ist eine nachträgliche und separate Implementierung von Aspekten in eine Applikation. Klassische Beispiele hierfür sind Logging und Security. PostSharp ist so implementiert, dass die Aspekte mittels Attribut an Methoden, Eigenschaften usw. gehangen werden. Der Post-Compiler von PostSharp ändert nach dem Kompilieren durch Visual Studio die Assembly. PostSharp kann hier heruntergeladen werden. Zum Abschluss noch ein interessanter Hinweis. PostSharp kopiert die Assemblies in das Ausgabeverzeichnis die auf dem Client benötigt werden. PostSharp muss auf den Client nicht installiert werden.

Funktionsweise von PostSharp (Bild: PostSharp)

Das folgende Beispiel zeigt eine DoSomething Methode, welche über einen Logging-Aspect nachträglich geloggt wird. Der Code der LoggingAspect Klasse zeigt die Implementierung der Aspects über das PostSharp Framework. Dem Projekt müssen die Referenzen auf die Assemblies “PostSharp.Laos” und “PostSharp.Public” hinzugefügt werden.

    public class Program
    {
        public static int Main(string[] args)
        {
            DoSomething();

            Console.Read();
            return 0;
        }

        [LogAcpect()]
        private static void DoSomething()
        {
            Console.WriteLine("Hello World");
        }
    }

    [Serializable()]
    public class LogAcpect : OnMethodBoundaryAspect
    {
        public override void OnEntry(MethodExecutionEventArgs eventArgs)
        {
            Console.WriteLine("--- Calling: {0} ---", eventArgs.Method);
        }

        public override void OnExit(MethodExecutionEventArgs eventArgs)
        {
            Console.WriteLine("--- Leaving: {0} ---", eventArgs.Method);
        }

        public override void OnSuccess(MethodExecutionEventArgs eventArgs)
        {
            Console.WriteLine("--- Success: {0} ---", eventArgs.Method);
        }

        public override void OnException(MethodExecutionEventArgs eventArgs)
        {
            Console.WriteLine("--- Exception: {0} @ {1} ---", eventArgs.Exception.Message, eventArgs.Method);
        }
    }

An dieser Stelle noch einen paar Hinweise. Die Klasse LogAspect muss als Serializable deklariert werden, ansonsten gibt es beim Starten einen Fehler. Weiterhin ist die Klasse LogAspect eine Attribut-Klasse und kann wie eine solche mit Eigenschaften und überladenen Konstruktoren implementiert werden. Der folgende Code zeigt eine disassemblierte Version der Funktion. Hier sieht man genau, welche Methoden an welcher Stelle aufgerufen werden und das man mittels FlowBehaviour eine Methode kontrolliert abbrechen kann und das eine Exception in der Aspect-Klasse nach “oben” durchgereicht wird.

private static void DoSomething()
{
    MethodExecutionEventArgs ~laosEventArgs~1;
    try
    {
        ~laosEventArgs~1 = new MethodExecutionEventArgs(~PostSharp~Laos~Implementation.~targetMethod~1, null, null);
        ~PostSharp~Laos~Implementation.LogAcpect~1.OnEntry(~laosEventArgs~1);
        if (~laosEventArgs~1.FlowBehavior != FlowBehavior.Return)
        {
            Console.WriteLine("Hello World");
            ~PostSharp~Laos~Implementation.LogAcpect~1.OnSuccess(~laosEventArgs~1);
        }
    }
    catch (Exception ~exception~0)
    {
        ~laosEventArgs~1.Exception = ~exception~0;
        ~PostSharp~Laos~Implementation.LogAcpect~1.OnException(~laosEventArgs~1);
        switch (~laosEventArgs~1.FlowBehavior)
        {
            case FlowBehavior.Continue:
            case FlowBehavior.Return:
                return;
        }
        throw;
    }
    finally
    {
        ~PostSharp~Laos~Implementation.LogAcpect~1.OnExit(~laosEventArgs~1);
    }
}

Die Implementierung eines Security-Aspect hängt von den Bedürfnissen der Applikation ab. In meinem aktuellen Projekt haben wir in einer Datenbank einem Benutzer eine oder mehrere Funktionen zugewiesen. Der SecurityAspect prüft gegen eine IFunctionProvider-Schnittstelle, ob dem Benutzer die entsprechenden Funktion zugeordnet wurde. Die Funktion wird über den Konstruktor der SecurityAspect-Attibutes angegeben. Besteht der Anwender die Sicherheitsabfrage nicht, wird eine SecurityException geworfen. Diese Exception kann mittels Try-Catch abgefangen werden. Eine solche Implementierung stellt sicher, dass Methoden nur dann ausgeführt werden, wenn die Sicherheitsrichtlinien erfüllt werden. Die GUI stellt selbstverständlich a priori sicher, dass eine solche Methode nicht aufgerufen werden kann, wenn der Anwender keine hinreichenden Berechtigungen besitzt.

        [SecurityAcpect(FunctionEnumeration.DoSomething)]
        private static void DoSomething()
        {
            Console.WriteLine("Hello World");
        }

Die aspektorientierte Programmierung ist nur ein Aspekt des Postsharp Frameworks. Die Stärke des Frameworks liegt in der, wie auch immer gearteten, nachträglichen Modifizierung des Codes.

Dieses Beispiel ist in der Lage, eine Seite rekursiv zu löschen, da das “deleteweb” Command ist nicht in der Lage ist, ein SPWeb mit Unterseiten zu löschen.

    /// <summary>
    /// Klasse für die Schnittstelle ISPStsadmCommand zum Bereitstellen des stsadm Befehls.
    /// </summary>
    public class RDeleteWeb : ISPStsadmCommand
    {
        #region ISPStsadmCommand Members

        /// <summary>
        /// Anzeigen der Hilfe
        /// </summary>
        public string GetHelpMessage(string command)
        {
            StringBuilder res = new StringBuilder();
            Assembly asm = Assembly.GetAssembly(this.GetType());
            res.AppendLine("Thomas Mentzel - (C) 2007 Softwareküche");
            res.AppendLine("STSADM Extensions Version " + asm.ToString());
            res.AppendLine();
            res.AppendLine("usage:");
            res.AppendLine("   -url <URL>");
            res.AppendLine("");
            return res.ToString();
        }

        /// <summary>
        /// Einstiegspunkt üfr das STSADM
        /// </summary>
        public int Run(string command, System.Collections.Specialized.StringDictionary keyValues, out string output)
        {
            Assembly asm = Assembly.GetAssembly(this.GetType());
            output = "Thomas Mentzel - (C) 2007 Softwareküche";
            output += "STSADM Extensions Version " + asm.ToString();

            //Wenn kein Parameter, dann Infofenster
            if (keyValues.Count <= 1)
            {
                output = GetHelpMessage(command);
                return 0;
            }

            // Nur Command "RemoveInheritedPermissions" durchführen
            if (String.Compare(command, "RDeleteWeb", true) == 0)
            {
                output += DoRDeleteWeb(keyValues);
                return 0;
            }
            else
            {
                throw new InvalidOperationException("Funktion wird nicht unterstützt. " + command);
            }
        }

        #endregion

        #region DoRDeleteWeb

        /// <summary>
        /// Recursive deletes then web and all subwebs.
        /// </summary>
        private string RDeleteAWeb(SPWeb web)
        {
            StringBuilder res = new StringBuilder();
            res.AppendLine("Deleting " + web.Url);

            if (web.Webs.Count > 0)
            {
                foreach (SPWeb subweb in web.Webs)
                {
                    res.Append(RDeleteAWeb(subweb));
                }
            }
            web.Delete();

            return res.ToString();
        }

        /// <summary>
        /// Recursive deletes then web and all subwebs.
        /// </summary>
        private string DoRDeleteWeb(System.Collections.Specialized.StringDictionary keyValues)
        {
            SPSite site = new SPSite(keyValues["url"]);
            SPWeb web = site.OpenWeb();
            StringBuilder res = new StringBuilder();
            res.AppendLine(RDeleteAWeb(web));
            return res.ToString();
        }

        #endregion
    }

Der nächste Schritt ist das Erzeugen einer signierten Assembly und das Erzeugen der XML Datei mit folgender Beispieldaten:

<?xml version="1.0" encoding="utf-8" ?>
<commands>  

    <command class="StsadmCommand.RDeleteWeb, StsadmCommand, Version=1.0.0.0, Culture=neutral, PublicKeyToken=affe000020021980" name="RDeleteWeb" />  

</commands>

Der .NET Reflector hilft dabei, die vollständigen Assembly-Informationen auszulesen.

Schließlich muss die Assembly nach “%CommonProgramFiles%Microsoft SharedWeb Server Extensions12bin” und das XML nach “%CommonProgramFiles%Microsoft SharedWeb Server Extensions12conf” kopiert werden.

Nun sollte beim Aufruf von “stsadm.exe” ohne Parameter eine Liste die Operation des “stsadm.exe” inklusive “rdeleteweb” erscheinen.

    /// <summary>
    /// Erweiterungsfunktionen für Strings
    /// </summary>
    public static class StringExtensions
    {
         /// <summary>
         /// Wandelt einen String in eine Zahl um.
         /// ExtensionMethod für den Datentyp "String"
         /// </summary>
         /// <param name="s">Erweiterter Datentyp</param>
         /// <returns></returns>
         public static int ToInt32(this string s)
         {
             int res;

             // Umwandeln des String, sonst default zurück geben
             if (int.TryParse(s, out res))
                 return res;
             else
                 return default(int);
         }
    }

Die anschließende Verwendung ist denkbar einfach. Im IntelliSense des Visual Studio erscheint die Methode als ganz normale Methode der String Klasse. Diese kann wie jede andere Funktion z.B. “.ToString()” ausgewählt und benutzt werden.

    class Program
    {

        static void Main(string[] args)
        {
            string aNumberAsString = Console.ReadLine();

            Console.WriteLine("IsOdd: " + IsOdd(aNumberAsString.ToInt32()));
            Console.WriteLine("IsEven: " + IsEven(aNumberAsString.ToInt32()));

            Console.ReadKey();
        }

        public static bool IsEven(int number)
        {
            return (number % 2 == 0);
        }

        private static bool IsOdd(int number)
        {
            return (number % 2 == 1);
        }
    }