Facade Design Pattern

Introduction 

 

Let's understand why we need a facade design pattern. Take a sly look at an image below. Right-hand side class only needs to call four methods. But we'll likely need to examine and dig around in the internals of mud class (leftmost classA) to determine which four they are. or I can place a facade between my classes andn now the facade has an internal reference to the classA and orchestrates calls on behalf of our program. We're using a facade class to contain the classA and only expose the methods needed by our program. We can use more meaningful method names plus our program only talks to the facade without knowing about the classA at all.

 

 

 

The complex project obviously has hundreds of classes. This pattern assist our calling class by focusing on what is needed rather than going through everything, (abstraction-oops).

 

 

Assume we want to implement a smartphone class that has 3 specifications: Processor, Memory(RAM, ROM) & Display. Our implementation might look like this:

 

1st class Processor

namespace FacadeDesignPattern
{
    public class Processor
    {
        public void DisplayProcessor()
        {
            System.Console.WriteLine("Snapdragon 635");
        }

    }
}

2nd class Memory :

namespace FacadeDesignPattern
{
    public class Memory
    {
        public void AssembleMemory()
        {
            System.Console.WriteLine("8GB RAM + 128GB ROM");
        }
    }
}

3rd class Display:

namespace FacadeDesignPattern
{
    public class Display
    {
        public void AssembleDisplay()
        {
            System.Console.WriteLine("Retina Display");
        }
    }
}

Now our calling class SmartPhone:

using System;

namespace FacadeDesignPattern
{
    class SmartPhone
    {
        static void Main(string[] args)
        {
            Console.WriteLine("One Plus 8");
            //calling processor
            Processor processor = new Processor();
            processor.AssembleProcessor();

            //calling memory
            Memory memory = new Memory();
            memory.AssembleMemory();

            //calling display
            Display display = new Display();
            display.AssembleDisplay();
        }
    }
}

Let's first understand, this is a simple problem, but as smartphone needs to follow the latest trend and innovation you'll need to add more classes for every feature.

You'll have to go through all of the mud of classes to reImplement smartPhone. Here we only have 3 classes (Display, Memory, Processor) but in a real-life project, as I said there would be hundreds of classes which make it difficult to look for classes which are needed to implement a new smartPhone.we can add a middle layer which acts as a facade for our smartphone, which will take care of all the functionalities that needed to make a smartphone. To make our pattern more advance we can add one interface through which our smartPhone class will interact.

 

Why interface? Good question. This abstraction allows the calling program (smartPhone in our case) to work solely with the facade and simplifies the code. Introducing an interface here really tidies things up for the caller and allows easily adding new facade classes to the underlying service classes(more feature more classes) change in the future (more advanced smartphone classes in the future).

 

If tomorrow, I want to release new smartPhone for Android 10 with new high-end specifications, that can be achieved by interacting with an interface.

 

Having said that, let's start working with the Facade Design Pattern.

What if we put processor, memory, display behind the facade so smartphone doesn't have to worry about above complexity.

 

Step 1

 

Let's add interface ISmartPhoneFacade

namespace FacadeDesignPattern
{
    interface ISmartPhoneFacade
    {
       void ShowSmartPhoneSpecifications();
    }
}

Step 2

 

Now let's add class SmartPhoneFacade

namespace FacadeDesignPattern
{
    public class SmartPhoneFacade : ISmartPhoneFacade
    {
        private Display display;
        private Memory memory;
        private Processor processor;

        public SmartPhoneFacade() : this(new Display(), new Memory(), new Processor())
        {

        }
        public SmartPhoneFacade(Display display, Memory memory, Processor processor)
        {
            this.memory = memory;
            this.display = display;
            this.processor = processor;
        }
        public void ShowSmartPhoneSpecifications()
        {
            display.AssembleDisplay();
            memory.AssembleMemory();
            processor.DisplayProcessor();
        }
    }
}

Now a simpler look at our smartPhone class:

using System;

namespace FacadeDesignPattern
{
    class SmartPhone
    {
        static void Main(string[] args)
        {
            ISmartPhoneFacade smartPhone = new SmartPhoneFacade();
            smartPhone.ShowSmartPhoneSpecifications();
        }
    }
}

If tomorrow, the new smartPhone device comes all I have to do is create a new facade, specific to that smartPhone features and inherit from interface ISmartPhoneFacade. This is the power of ABSTRACTION in oops.

 

Note: this might feels like a headache to add an extra class, but this helps in the bigger picture.

 

I sincerely hope you enjoyed this blog and that you're inspired to apply what you've learned to your own applications.

 

Connect with me:

• Github 
• Linkedin