Share
VIDEOS 1 TO 50
Facade Design Pattern
Facade Design Pattern
Published: 2012/09/29
Channel: Derek Banas
Facade Pattern – Design Patterns (ep 9)
Facade Pattern – Design Patterns (ep 9)
Published: 2017/08/13
Channel: Christopher Okhravi
Facade Design Pattern
Facade Design Pattern
Published: 2015/03/23
Channel: in28minutes
Facade Pattern
Facade Pattern
Published: 2017/08/09
Channel: BBarters
Facade Pattern – Design Patterns (with real world example/use case)
Facade Pattern – Design Patterns (with real world example/use case)
Published: 2017/05/01
Channel: SS Infotainment Ltd.
Design Pattern for beginners -  FACADE
Design Pattern for beginners - FACADE
Published: 2017/02/11
Channel: Learn Share Anything Anyone
Facade design pattern
Facade design pattern
Published: 2016/04/16
Channel: Shri Ram Programming Academy
JAVA: Facade Design Pattern
JAVA: Facade Design Pattern
Published: 2012/01/08
Channel: zaneacademy
The Facade Pattern
The Facade Pattern
Published: 2012/07/10
Channel: Michael
Design Patterns: Adapter and Façade
Design Patterns: Adapter and Façade
Published: 2017/08/22
Channel: Microsoft Visual Studio
Facade design pattern in .net,C#
Facade design pattern in .net,C#
Published: 2011/09/29
Channel: DotNetIQ
Facade Design Pattern   Tamil tutorial
Facade Design Pattern Tamil tutorial
Published: 2013/06/27
Channel: Guvi sharing
Programming Patterns. Facade, Adapter, Decorator
Programming Patterns. Facade, Adapter, Decorator
Published: 2017/02/02
Channel: Soshace
Patterns   Facade
Patterns Facade
Published: 2015/07/21
Channel: UTS Software Engineering
Proxy vs Adapter vs Facade Pattern | Code Walks 012
Proxy vs Adapter vs Facade Pattern | Code Walks 012
Published: 2016/07/16
Channel: Christopher Okhravi
Design Patterns in Java - Facade pattern example
Design Patterns in Java - Facade pattern example
Published: 2015/09/16
Channel: Ezer Sanbe
Mastering JavaScript: Introducing the Facade Design Pattern | packtpub.com
Mastering JavaScript: Introducing the Facade Design Pattern | packtpub.com
Published: 2015/09/03
Channel: Packt Video
PHP OOP Tutorial 20 | Facade Pattern
PHP OOP Tutorial 20 | Facade Pattern
Published: 2010/10/21
Channel: JREAM
Facade Pattern - PHP Design Patterns
Facade Pattern - PHP Design Patterns
Published: 2012/12/11
Channel: Easy Learn Tutorial
Facade Patterns in Revit Tutorial
Facade Patterns in Revit Tutorial
Published: 2017/09/29
Channel: Balkan Architect
Remote Facade Design Pattern
Remote Facade Design Pattern
Published: 2013/07/16
Channel: Ram N
The Facade Design Pattern in PHP
The Facade Design Pattern in PHP
Published: 2011/09/17
Channel: life michael
Facade (TypeScript Design Patterns)
Facade (TypeScript Design Patterns)
Published: 2017/04/19
Channel: Savjee
The API Facade Pattern: Overview - Episode 1
The API Facade Pattern: Overview - Episode 1
Published: 2012/03/08
Channel: apigee
Layered Architecture using the Facade Design Pattern
Layered Architecture using the Facade Design Pattern
Published: 2012/10/30
Channel: Shiv Kumar
Design Patterns Javascript : Facade Pattern
Design Patterns Javascript : Facade Pattern
Published: 2017/03/28
Channel: Abiam Velazquez
Using Facade Pattern With JSX, Olena Sovyn - React London June 2017
Using Facade Pattern With JSX, Olena Sovyn - React London June 2017
Published: 2017/06/29
Channel: Red Badger
Facade Design Pattern - Example using Java
Facade Design Pattern - Example using Java
Published: 2012/12/15
Channel: Hugo Ferro
The Facade Design Pattern
The Facade Design Pattern
Published: 2016/03/11
Channel: Fabio Lacerda
Facade Design Pattern C#
Facade Design Pattern C#
Published: 2014/05/01
Channel: Ripon Datta
06 Other Structural Patterns: 02 The Façade Pattern
06 Other Structural Patterns: 02 The Façade Pattern
Published: 2014/06/07
Channel: Clint Eastwood
Unity C# Tutorials: Part 46 - Facade Pattern
Unity C# Tutorials: Part 46 - Facade Pattern
Published: 2017/09/28
Channel: acem003
Design patterns| Facade Pattern | مشاكل برمجية مكررة وحلولها
Design patterns| Facade Pattern | مشاكل برمجية مكررة وحلولها
Published: 2015/11/17
Channel: TheNewBaghdad
Facade Design Pattern
Facade Design Pattern
Published: 2016/12/04
Channel: Techfritters Training
Factory vs Facade vs Observer Design Patterns
Factory vs Facade vs Observer Design Patterns
Published: 2017/05/17
Channel: Sandra Perera
Facade Design Pattern with Example
Facade Design Pattern with Example
Published: 2016/01/24
Channel: In28Minutes-Short-Tutorials
Design Patterns in Java - Facade pattern
Design Patterns in Java - Facade pattern
Published: 2015/09/16
Channel: Ezer Sanbe
facade design pattern with  real time example  - Part6 - Structural
facade design pattern with real time example - Part6 - Structural
Published: 2017/11/07
Channel: LrnWthR
Subsystem Facade Pattern Implementation in Action
Subsystem Facade Pattern Implementation in Action
Published: 2011/08/08
Channel: Lee Ackerman
Course Preview: Design Patterns in C++: Structural - Façade to Proxy
Course Preview: Design Patterns in C++: Structural - Façade to Proxy
Published: 2016/09/26
Channel: Pluralsight
Digital Facade Design Process
Digital Facade Design Process
Published: 2014/05/31
Channel: James Bernard
Facade - Design patterns in Swift 2
Facade - Design patterns in Swift 2
Published: 2016/02/12
Channel: Алексей Чечель
Revit+Dynamo: Random pattern facade
Revit+Dynamo: Random pattern facade
Published: 2014/03/10
Channel: Cristiano Piagnerelli
The API Facade Pattern: Technology - Episode 3
The API Facade Pattern: Technology - Episode 3
Published: 2012/03/23
Channel: apigee
Factory vs Facade vs Observer Design Patterns
Factory vs Facade vs Observer Design Patterns
Published: 2017/05/17
Channel: Sandra Perera
Facade Design for Fabrication
Facade Design for Fabrication
Published: 2015/08/23
Channel: Hector Camps
PHP Design Patterns: The Facade Pattern
PHP Design Patterns: The Facade Pattern
Published: 2016/02/24
Channel: IOLEARN Tutorials
PHP OOP Tutorial 20   Facade Pattern
PHP OOP Tutorial 20 Facade Pattern
Published: 2014/06/02
Channel: ProGrammEr Best
API Facade Pattern with Apache Synapse
API Facade Pattern with Apache Synapse
Published: 2013/05/06
Channel: Hiranya Jayathilaka
Bergbahn Facade Pattern EP Mediator Pattern Original Mix
Bergbahn Facade Pattern EP Mediator Pattern Original Mix
Published: 2009/08/12
Channel: orneliashlier87
NEXT
GO TO RESULTS [51 .. 100]

WIKIPEDIA ARTICLE

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 the client. These members access the system on behalf of the facade client and hide the implementation details.

Overview[edit]

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.

Usage[edit]

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.

Structure[edit]

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

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

Example[edit]

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).

C#[edit]

Implementation[edit]

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() +
                c.OperationC1());
        }
        public void Operation2()
        {
            Console.WriteLine("Operation 2\n" +
                a.OperationA2() +
                b.OperationB2() +
                c.OperationC2());
        }
    }
}

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 **********");
            model.SetModel();
            engine.SetEngine();
            body.SetBody();
            accessories.SetAccessories();

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

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

            facade.CreateCompleteCar();

            Console.ReadKey();
        }
    }
}

Java[edit]

/* 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() {
        processor.freeze();
        ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
        processor.jump(BOOT_ADDRESS);
        processor.execute();
    }
}

/* Client */

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

Ruby[edit]

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

class Memory
  def load(position, data); end
end

class HardDrive
  def read(lba, size); end
end

# Facade
class ComputerFacade

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

  def start
    @processor.freeze
    @ram.load(BOOT_ADDRESS, @hd.read(BOOT_SECTOR, SECTOR_SIZE))
    @processor.jump(BOOT_ADDRESS)
    @processor.execute
  end
end

# Client
computer_facade = ComputerFacade.new
computer_facade.start

PHP[edit]

/**
 * 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->cpu->freeze();
    $this->ram->load(BOOT_ADDRESS, $this->hd->read(BOOT_SECTOR, SECTOR_SIZE));
    $this->cpu->jump(BOOT_ADDRESS);
    $this->cpu->execute();
  }
}

/**
 * How a user could start the computer.
 */
$computer = new ComputerFacade;
$computer->start();

Python[edit]

"""
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):
        print("Executing.")


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.cpu.freeze()
        self.memory.load("0x00", self.ssd.read("100", "1024"))
        self.cpu.jump("0x00")
        self.cpu.execute()


computer_facade = ComputerFacade()
computer_facade.start()

Output:

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

References[edit]

  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]

Disclaimer

None of the audio/visual content is hosted on this site. All media is embedded from other sites such as GoogleVideo, Wikipedia, YouTube etc. Therefore, this site has no control over the copyright issues of the streaming media.

All issues concerning copyright violations should be aimed at the sites hosting the material. This site does not host any of the streaming media and the owner has not uploaded any of the material to the video hosting servers. Anyone can find the same content on Google Video or YouTube by themselves.

The owner of this site cannot know which documentaries are in public domain, which has been uploaded to e.g. YouTube by the owner and which has been uploaded without permission. The copyright owner must contact the source if he wants his material off the Internet completely.

Powered by YouTube
Wikipedia content is licensed under the GFDL and (CC) license