Facade pattern

From Wikipedia, the free encyclopedia
  (Redirected from Façade pattern)
Jump to: navigation, search

The facade pattern (also spelled façade) is a software design pattern commonly used with object-oriented programming. The name is an analogy to an architectural façade.

A facade is an object that provides a simplified interface to a larger body of code, such as a class library. A facade can

  • make a software library easier to use, understand, and test, since the facade has convenient methods for common tasks,
  • make the library more readable, for the same reason,
  • reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system,
  • wrap a poorly designed collection of APIs with a single well-designed API.

The Facade design pattern is often used when a system is very complex or difficult to understand because the system has a large number of interdependent classes or its source code is unavailable. This pattern hides the complexities of the larger system and provides a simpler interface to the client. It typically involves a single wrapper class that contains a set of members required by client. These members access the system on behalf of the facade client and hide the implementation details.


The Facade [1] design pattern is one of the twenty-three well-known GoF design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.

What problems can the Facade design pattern solve? [2]

  • To make a complex subsystem easier to use, a simple interface should be provided for a set of interfaces in the subsystem.
  • The dependencies on a subsystem should be minimized.

Clients that access a complex subsystem directly refer to (depend on) many different objects having different interfaces (tight coupling), which makes the clients hard to implement, change, test, and reuse.

What solution does the Facade design pattern describe?

Define a Facade object that

  • implements a simple interface in terms of (by delegating to) the interfaces in the subsystem and
  • may perform additional functionality before/after forwarding a request.

This enables to work through a Facade object to minimize the dependencies on a subsystem.
See also the UML class and sequence diagram below.


A Facade is used when an easier or simpler interface to an underlying object is desired.[3] Alternatively, an adapter can be used when the wrapper must respect a particular interface and must support polymorphic behavior. A decorator makes it possible to add or alter behavior of an interface at run-time.

Pattern Intent
Adapter Converts one interface to another so that it matches what the client is expecting
Decorator Dynamically adds responsibility to the interface by wrapping the original code
Facade Provides a simplified interface

The facade pattern is typically used when

  • a simple interface is required to access a complex system,
  • a system is very complex or difficult to understand,
  • an entry point is needed to each level of layered software, or
  • the abstractions and implementations of a subsystem are tightly coupled.


UML class and sequence diagram[edit]

A sample UML class and sequence diagram for the Facade design pattern. [4]

In the above UML class diagram, the Client class doesn't access the subsystem classes directly. Instead, the Client works through a Facade class that implements a simple interface in terms of (by delegating to) the subsystem classes (Class1, Class2, and Class3). The Client depends only on the simple Facade interface and is independent of the complex subsystem.
The sequence diagram shows the run-time interactions: The Client object works through a Facade object that delegates the request to the Class1, Class2, and Class3 instances that perform the request.

UML class diagram[edit]

Example of Facade design pattern in UML.png

The facade class abstracts Packages 1, 2, and 3 from the rest of the application.
The objects are using the Facade Pattern to access resources from the Packages.


This is an abstract example of how a client ("you") interacts with a facade (the "computer") to a complex system (internal computer parts, like CPU and HardDrive).



namespace DesignPattern.Facade
    class SubsystemA
        public string OperationA1()
            return "Subsystem A, Method A1\n";
        public string OperationA2()
            return "Subsystem A, Method A2\n";

    class SubsystemB
        public string OperationB1()
            return "Subsystem B, Method B1\n";

        public string OperationB2()
            return "Subsystem B, Method B2\n";

    class SubsystemC
        public string OperationC1()
            return "Subsystem C, Method C1\n";

        public string OperationC2()
            return "Subsystem C, Method C2\n";

    public class Facade
        private readonly SubsystemA a = new SubsystemA();
        private readonly SubsystemB b = new SubsystemB();
        private readonly SubsystemC c = new SubsystemC();
        public void Operation1()
            Console.WriteLine("Operation 1\n" +
                a.OperationA1() +
                b.OperationB1() +
        public void Operation2()
            Console.WriteLine("Operation 2\n" +
                a.OperationA2() +
                b.OperationB2() +

Sample code[edit]

namespace DesignPattern.Facade.Sample
    // The 'Subsystem ClassA' class
    class CarModel
        public void SetModel()
            Console.WriteLine(" CarModel - SetModel");

    /// <summary>
    /// The 'Subsystem ClassB' class
    /// </summary>
    class CarEngine
        public void SetEngine()
            Console.WriteLine(" CarEngine - SetEngine");

    // The 'Subsystem ClassC' class
    class CarBody
        public void SetBody()
            Console.WriteLine(" CarBody - SetBody");

    // The 'Subsystem ClassD' class
    class CarAccessories
        public void SetAccessories()
            Console.WriteLine(" CarAccessories - SetAccessories");

    // The 'Facade' class
    public class CarFacade
        private readonly CarAccessories accessories;
        private readonly CarBody body;
        private readonly CarEngine engine;
        private readonly CarModel model;

        public CarFacade()
            accessories = new CarAccessories();
            body = new CarBody();
            engine = new CarEngine();
            model = new CarModel();

        public void CreateCompleteCar()
            Console.WriteLine("******** Creating a Car **********");

            Console.WriteLine("******** Car creation is completed. **********");

    // Facade pattern demo
    class Program
        static void Main(string[] args)
            var facade = new CarFacade();




/* Complex parts */

class CPU {
    public void freeze() { ... }
    public void jump(long position) { ... }
    public void execute() { ... }

class HardDrive {
    public byte[] read(long lba, int size) { ... }

class Memory {
    public void load(long position, byte[] data) { ... }

/* Facade */

class ComputerFacade {
    private CPU processor;
    private Memory ram;
    private HardDrive hd;

    public ComputerFacade() {
        this.processor = new CPU();
        this.ram = new Memory();
        this.hd = new HardDrive();

    public void start() {
        ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));

/* Client */

class You {
    public static void main(String[] args) {
        ComputerFacade computer = new ComputerFacade();


# Complex Parts
class CPU
  def freeze; end
  def jump(position); end
  def execute; end

class Memory
  def load(position, data); end

class HardDrive
  def read(lba, size); end

# Facade
class ComputerFacade

  def initialize
    @processor = CPU.new
    @ram = Memory.new
    @hd = HardDrive.new

  def start
    @ram.load(BOOT_ADDRESS, @hd.read(BOOT_SECTOR, SECTOR_SIZE))

# Client
computer_facade = ComputerFacade.new


 * The complicated, underlying logic.
class CPU
  public function freeze() {/* ... */}
  public function jump($position) {/* ... */}
  public function execute() {/* ... */}

class Memory
  public function load($position, $data) {/* ... */}

class HardDrive
  public function read($lba, $size) {/* ... */}

 * The facade that users would be interacting with.
class ComputerFacade
  protected $cpu;
  protected $memory;
  protected $hd;

  public function __construct()
    $this->cpu = new CPU;
    $this->ram = new Memory;
    $this->hd = new HardDrive;

  public function start()
    $this->ram->load(BOOT_ADDRESS, $this->hd->read(BOOT_SECTOR, SECTOR_SIZE));

 * How a user could start the computer.
$computer = new ComputerFacade;


Facade pattern example.

# Complex computer parts
class CPU(object):
    Simple CPU representation.
    def freeze(self):
        print("Freezing processor.")

    def jump(self, position):
        print("Jumping to:", position)

    def execute(self):

class Memory(object):
    Simple memory representation.
    def load(self, position, data):
        print("Loading from {0} data: '{1}'.".format(position, data))

class SolidStateDrive(object):
    Simple solid state drive representation.
    def read(self, lba, size):
        return "Some data from sector {0} with size {1}".format(lba, size)

class ComputerFacade(object):
    Represents a facade for varius computer parts.
    def __init__(self):
        self.cpu = CPU()
        self.memory = Memory()
        self.ssd = SolidStateDrive()

    def start(self):
        self.memory.load("0x00", self.ssd.read("100", "1024"))

computer_facade = ComputerFacade()


Freezing processor.
Loading from 0x00 data: 'Some data from sector 100 with size 1024'.
Jumping to: 0x00


  1. ^ Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley. pp. 185ff. ISBN 0-201-63361-2. 
  2. ^ "The Facade design pattern - Problem, Solution, and Applicability". w3sDesign.com. Retrieved 2017-08-12. 
  3. ^ Freeman, Eric; Freeman, Elisabeth; Sierra, Kathy; Bates, Bert (2004). Hendrickson, Mike; Loukides, Mike, eds. "Head First Design Patterns" (paperback). 1. O'Reilly: 243, 252, 258, 260. ISBN 978-0-596-00712-6. Retrieved 2012-07-02. 
  4. ^ "The Facade design pattern - Structure and Collaboration". w3sDesign.com. Retrieved 2017-08-12. 

External links[edit]