Facade Pattern C# | Komplexe Systeme vereinfachen

Einführung in das Facade Pattern

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 Facade Pattern in C# ins Spiel – ein Entwurfsmuster, das dabei hilft, komplexe Systeme zu vereinfachen, indem es eine klare und vereinheitlichte Schnittstelle für den Zugriff auf interne Subsysteme bereitstellt.

‍

Funktion des Facade Patterns

Das Facade Pattern 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.

‍

Beispiel: Online-Shopping-Plattform

Subsystem-Klassen

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

1// Subsystem class
2internal class InventorySystem
3{
4    Random rnd = new Random();
5
6    public bool UpdateInventory(int productId, int quantity)
7    {
8        int existed = rnd.Next(0, 12);
9        var canUpdate = existed >= quantity;
10
11        if (canUpdate)
12            Console.WriteLine("Inventory updated for product ID " + productId + " with quantity " + quantity);
13
14        return canUpdate;
15    }
16}
17
18internal class PaymentSystem
19{
20    Random rnd = new Random();
21
22    public bool ProcessPayment(double amount)
23    {
24        int existed = rnd.Next(0, 10000);
25        var canPay = existed >= amount;
26
27        if (canPay)
28            Console.WriteLine("Payment processed for amount: $" + amount);
29
30        return canPay;
31    }
32}
33
34internal class ShippingSystem
35{
36    public void ShipOrder(int orderId)
37    {
38        Console.WriteLine("Order with ID " + orderId + " has been shipped");
39    }
40}

Direkter Zugriff durch den Client

In diesem Beispiel muss der Client direkt auf die Methoden der einzelnen Subsysteme zugreifen, um eine Bestellung zu verarbeiten.
‍
Dies führt zu einer erhöhten Kopplung zwischen dem Client und den Subsystemen sowie zu einem komplexeren und schwer wartbaren Code.

1private static void Main(string[] args)
2{
3    InventorySystem inventorySystem = new InventorySystem();
4    PaymentSystem paymentSystem = new PaymentSystem();
5    ShippingSystem shippingSystem = new ShippingSystem();
6
7    // Aufgabe einer Bestellung mit Produkt-ID 123, Menge 2, Betrag $50 und Bestell-ID 456
8    int productId = 123;
9    int quantity = 2;
10    double amount = 50.00;
11    int orderId = 456;
12
13    if (inventorySystem.UpdateInventory(productId, quantity))
14        if (paymentSystem.ProcessPayment(amount))
15            shippingSystem.ShipOrder(orderId);
16
17    Console.ReadLine();
18}

‍

Verwendung des Facade Patterns

In diesem Beispiel liegt der Wartbarkeitsindex des Clients bei 62.

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

1// Facade class
2internal class OrderProcessingFacade
3{
4    private InventorySystem inventorySystem = new InventorySystem();
5    private PaymentSystem paymentSystem = new PaymentSystem();
6    private ShippingSystem shippingSystem = new ShippingSystem();
7
8    public void ProcessOrder(int productId, int quantity, double amount, int orderId)
9    {
10        if (inventorySystem.UpdateInventory(productId, quantity))
11            if (paymentSystem.ProcessPayment(amount))
12                shippingSystem.ShipOrder(orderId);
13    }
14}
15
16// Client
17private static void Main(string[] args)
18{
19    OrderProcessingFacade orderProcessor = new OrderProcessingFacade();
20
21    // Aufgabe einer Bestellung mit Produkt-ID 123, Menge 2, Betrag $50 und Bestell-ID 456
22    int productId = 123;
23    int quantity = 2;
24    double amount = 50.00;
25    int orderId = 456;
26
27    orderProcessor.ProcessOrder(productId, quantity, amount, orderId);
28    Console.ReadLine();
29}

Vorteile des  Facade Patterns

• Reduzierte Komplexität: Der Client muss nicht direkt mit den Subsystemen interagieren, was den Code übersichtlicher und wartbarer macht.
• Verbesserte Wartbarkeit: Der Wartbarkeitsindex des Clients steigt durch die Verwendung der Fassade um 6 Punkte, von 62 auf 68.

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.

‍

Fazit

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

‍