Vereinfachung komplexer Systeme mit dem Facade Pattern

Leon Diedrichs | Softwareentwickler | 26.04.2024

In der Welt der Softwareentwicklung stehen Entwickler oft vor der Herausforderung, komplexe Systeme zu entwerfen und zu implementieren. Diese Systeme bestehen aus einer Vielzahl von Komponenten und Subsystemen, die miteinander interagieren müssen. Hier kommt das Fassadenmuster ins Spiel – ein Entwurfsmuster, das dazu dient, die Komplexität eines Systems zu reduzieren und eine vereinfachte Schnittstelle für den Zugriff auf diese Subsysteme bereitzustellen.

Das Fassadenmuster fungiert als Vermittler zwischen dem Client und den verschiedenen internen Komponenten des Systems. Es versteckt die Komplexität der einzelnen Subsysteme und bietet dem Client eine einfache Schnittstelle zum Zugriff auf diese Funktionen. Dadurch wird der Code des Clients vereinfacht und die Abhängigkeit von den internen Strukturen des Systems verringert.

Ein anschauliches Beispiel für das Facade Pattern ist eine Online-Shopping-Plattform. Angenommen, wir haben ein komplexes System zur Verarbeitung von Bestellungen in einem Online-Shop. Dieses System besteht aus verschiedenen Subsystemen wie Lagerverwaltung, Zahlungsabwicklung und Versand. 

 

// Subsystem class
internal class InventorySystem
{
    Random rnd = new Random();
    public bool UpdateInventory(int productId, int quantity)
    {
        int existed = rnd.Next(0, 12);
        var canUpdate = existed >= quantity;
        if (canUpdate)
            Console.WriteLine("Inventory updated for product ID " +
productId + " with quantity " + quantity);
        return canUpdate;
    }
} 

internal class PaymentSystem
{
    Random rnd = new Random();

    public bool ProcessPayment(double amount)
    {
        int existed = rnd.Next(0, 10000);
        var canPay = existed >= amount;
        if (canPay)
            Console.WriteLine("Payment processed for amount: $" + amount);
        return canPay;
    }
} 

internal class ShippingSystem
{
    public void ShipOrder(int orderId)
    {
        Console.WriteLine("Order with ID " + orderId + " has been shipped");
    }
}

In diesem Beispiel muss der Client direkt auf die Methoden der einzelnen Subsysteme zugreifen, um eine Bestellung zu verarbeiten.

 

//Client
private static void Main(string[] args)
{
    InventorySystem inventorySystem = new InventorySystem();
    PaymentSystem paymentSystem = new PaymentSystem();
    ShippingSystem shippingSystem = new ShippingSystem();

    // Aufgabe einer Bestellung mit Produkt ID 123, Menge 2, Betrag $50 und Bestell ID 456
    int productId = 123;
    int quantity = 2;
    double amount = 50.00;
    int orderId = 456;

    if (inventorySystem.UpdateInventory(productId, quantity))
        if (paymentSystem.ProcessPayment(amount))
            shippingSystem.ShipOrder(orderId);

    Console.ReadLine();
}

Dies führt zu einer erhöhten Kopplung zwischen dem Client und den Subsystemen sowie zu einem komplexeren und schwerer wartbaren Code. In diesem Beispiel liegt der Wartbarkeitsindex vom Client bei 62 liegen.

 

Durch die Verwendung des Facade Patterns wird diese Komplexität reduziert und eine einfachere Schnittstelle für den Client bereitgestellt.

 

// Facade class
internal class OrderProcessingFacade
{
    private InventorySystem inventorySystem = new InventorySystem();
    private PaymentSystem paymentSystem = new PaymentSystem();
    private ShippingSystem shippingSystem = new ShippingSystem();

public void ProcessOrder(int productId, int quantity, double amount, 
int orderId)
    {
        if (inventorySystem.UpdateInventory(productId, quantity))
            if (paymentSystem.ProcessPayment(amount))
                shippingSystem.ShipOrder(orderId);
    }
}

//Client
private static void Main(string[] args)
{
    OrderProcessingFacade orderProcessor = new OrderProcessingFacade();

    // Aufgabe einer Bestellung mit Produkt ID 123, Menge 2, Betrag $50 und 
Bestell ID 456
    int productId = 123;
    int quantity = 2;
    double amount = 50.00;
    int orderId = 456;
    orderProcessor.ProcessOrder(productId, quantity, amount, orderId);
    Console.ReadLine();
}

Durch die Verwendung des Fassadenmusters können Entwickler die Wartbarkeit, Erweiterbarkeit und Testbarkeit ihres Systems verbessern.

Mit dem Einsatz der Fassade in dem Beispiel liegt der Wartbarkeitsindex des Clients bei 68 und ist damit um 6 Punkte gestiegen.

Die klare Trennung zwischen dem Client und den internen Komponenten erleichtert es, Änderungen vorzunehmen oder neue Funktionen hinzuzufügen, ohne den gesamten Code umstrukturieren zu müssen.

Insgesamt ist das Fassadenmuster ein leistungsstarkes Pattern, um komplexe Systeme zu vereinfachen und die Effizienz bei der Entwicklung zu steigern.

 

Leon Diedrichs | Softwareentwickler | 26.04.2024