CODEDOM

Nach Singleton, Memento und Prototype folgt auch schon der nächste Part der Design Patterns: Die Fassade. Sie ist das erste Entwurfsmuster aus dem Bereich der Structural Patterns (Strukturmuster) und dient als einheitliche und vereinfachte Schnittstellen zu einer beliebigen Menge von Schnittstellen eines Untersystems (Subsystems).

Die Fassade sollte also immer dann genutzt werden, wenn ein Untersystem viele Klassen enthält, die aber einzeln selten bzw. garnicht verwendet werden. Statt nun für eine gewisse Funktionalität sehr viele kleine Klassen ansprechen zu müssen, verwendet man eine Fassade, die diese Klassen vereint und Funktionalitäten weiter deligiert. Somit kann eine Fassade die Komplexität einer Implementierung erheblich senken, da das benutzte Untersystem nicht direkt sichtbar ist.

Um die Fassade korrekt zu implementieren benötigen wir als allererstes Subklassen. Diese Klassen enthalten jeweils Teil-Strukturen unserer Fassade, hier am Beispiel eines Kunden. Ein Kunde hat bei einer Bank ein Konto, ein Darlehen und eventuell eine Kreditkarte. Nun möchte er eine Hypothek abschließen. Dazu müssen wir prüfen, ob der Kunde kreditwürdig für eine solche Hypothek ist. Zuerst erstellen wir also unseren Kunden. Dazu dient folgende, sehr vereinfachte Klasse:

class Kunde
{
    public string Name { get; set; }
}

Diese dient nur der Veranschaulichung, denn die wichtigen Subklassen erstellen wir jetzt. Dazu gehören die Klassen Konto, Darlehen und Kreditkarte, welche später in der Fassade vereint werden:

class Konto
{
    public bool HatGenugGuthaben(Kunde k, int betrag)
    {
        Console.WriteLine(string.Format("Prüfe Guthaben für Kunde {0} {1}", k.Name));
        return true;
    }
}
 
class Darlehen
{
    public bool HatDarlehen(Kunde k)
    {
        Console.WriteLine(string.Format("Prüfe Darlehen für Kunde {0} {1}", k.Name));
        return false;
    }
}
 
class Kreditkarte
{
    public bool HatNichtUeberzogen(Kunde k)
    {
        Console.WriteLine(string.Format("Prüfe Dispo für Kunden {0} {1}", k.Name));
        return true;
    }
}

Nun stellen wir uns die Klasse Hypothek zusammen, welche aus den 3 Subklassen Konto, Darlehen und Kreditkarte besteht, auf die wir aber später von außen nicht mehr zugreifen möchten / brauchen.

class Hypothek
{
    private Konto _konto = new Konto();
    private Darlehen _darlehen = new Darlehen();
    private Kreditkarte _kreditkarte = new Kreditkarte();
 
    public bool IstGeeignet(Kunde k, int betrag)
    {
        Console.WriteLine("{0} möchte ein Darlehen über {1:C} haben", k.Name, betrag);
 
        bool geeignet = true;
 
        // Prüfe kreditwürdigkeit des Kunden
        if (!_konto.HatGenugGuthaben(k, betrag))
        {
            geeignet = false;
        }
        else if (_darlehen.HatDarlehen(k))
        {
            geeignet = false;
        }
        else if (!_kreditkarte.HatNichtUeberzogen(k))
        {
            geeignet = false;
        }
 
        return geeignet;
    }
}

Diese Fassade kann nun dazu benutzt werden, um die kreditwürdigkeit des Kunden zu prüfen, ohne dabei selbst auf die Subklassen zugreifen zu müssen. Das bietet den immensen Vorteil, dass die Prüfung nun in den jeweiligen Subklassen erweitert werden kann, ohne dass die Fassade oder die explizite Prüfung des Kunden an mehreren Stellen geändert werden muss. So können wir nun prüfen:

static void Main()
{
    var k = new Kunde { Name = "Max Mustermann" };
    var h = new Hypothek();
 
    bool geeignet = h.IstGeeignet(k, 250000);
    Console.WriteLine(k.Name + " wurde " + (geeignet ? "angenommen" : "abgelehnt"));
}

Und wie immer dürft ihr den Code verwenden und ändern wie ihr lustig seid!