Simplifying Complex Systems with the Facade Design Pattern in C#

What is the Facade Design Pattern? Facade pronounce as fuh-sahd (/fəˈsɑːd/) is a structural design pattern that provides a simplified interface to a complex system of classes, libraries, or APIs. It acts as a unified interface that hides the complexities of the underlying system and provides a more straightforward way to interact with it.

Why use the Facade Design Pattern?

• Simplifies complex systems by providing a more intuitive interface.
• Decouples client code from implementation details.
• Makes code easier to understand, maintain, and extend.
• Promotes code reusability, modularity, and flexibility by encapsulating complex logic behind a simple interface.

Key components of the Facade Design Pattern:

• Facade: The facade is a class that provides a simplified interface to the complex system. It delegates client requests to the appropriate subsystems.
• Subsystem: These are the classes or components that make up the complex system. The facade delegates requests to these subsystems to perform specific tasks.
• Client: The client is the code that interacts with the facade to access the system’s functionality. The client doesn’t need to know the details of the subsystems.

UML Class Diagram of the Facade Design Pattern:

How to implement the Observer Facade Pattern in C#?

using System;

namespace FacadePattern
{
    // Subsystem 1
    public class SubsystemA
    {
        public void OperationA()
        {
            Console.WriteLine("SubsystemA: OperationA executed.");
        }
    }

    // Subsystem 2
    public class SubsystemB
    {
        public void OperationB()
        {
            Console.WriteLine("SubsystemB: OperationB executed.");
        }
    }

    // Subsystem 3
    public class SubsystemC
    {
        public void OperationC()
        {
            Console.WriteLine("SubsystemC: OperationC executed.");
        }
    }

    // Subsystem 4
    public class SubsystemD
    {
        public void OperationD()
        {
            Console.WriteLine("SubsystemD: OperationD executed.");
        }
    }

    // Facade
    public class Facade
    {
        private SubsystemA _subsystemA;
        private SubsystemB _subsystemB;
        private SubsystemC _subsystemC;
        private SubsystemD _subsystemD;

        public Facade(SubsystemA subsystemA, SubsystemB subsystemB, 
            SubsystemC subsystemC, SubsystemD subsystemD)
        {
            _subsystemA = subsystemA;
            _subsystemB = subsystemB;
            _subsystemC = subsystemC;
            _subsystemD = subsystemD;
        }

        public void PerformOperation1()
        {
            Console.WriteLine("Operation 1\n" +
                              "-----------");
            _subsystemA.OperationA();
            _subsystemB.OperationB();
            _subsystemC.OperationC();
        }

        public void PerformOperation2()
        {
            Console.WriteLine("Operation 2\n" +
                              "-----------");
            _subsystemA.OperationA();
            _subsystemD.OperationD();
        }
    }


    // Client
    public class Program
    {
        static void Main(string[] args)
        {
            // Create subsystems
            var subsystemA = new SubsystemA();
            var subsystemB = new SubsystemB();
            var subsystemC = new SubsystemC();
            var subsystemD = new SubsystemD();

            // Create facade
            var facade = new Facade(subsystemA, subsystemB, subsystemC, subsystemD);

            // Use facade to perform operations
            facade.PerformOperation1();
            Console.WriteLine();
            facade.PerformOperation2();
        }
    }
}

Output

Operation 1
-----------
SubsystemA: OperationA executed.
SubsystemB: OperationB executed.
SubsystemC: OperationC executed.

Operation 2
-----------
SubsystemA: OperationA executed.
SubsystemD: OperationD executed.

Conclusion At the end of this article, you should have a good understanding of the Facade Design Pattern and how to implement it in C#. By using the Facade pattern, you can simplify complex systems, improve code readability, and make your codebase more maintainable and extensible. In the next article, I will discuss with some real-world examples of the Facade pattern.

Happy coding!

Source code