Bridge Pattern

Bridge pattern acts as an intermediary between two interfaces. Bridge Pattern falls under structural pattern of GOF (Gang of Four) pattern.

When to use –

Bridge pattern can be used to keep an abstraction separate from its implementation so you can change both abstraction and implementation independently without changing the client code.

Major components of Bridge pattern –

Abstraction – This is an abstract class provides abstraction to the clients.

Refined Abstraction – This class will implement the abstract class.

Implementer – This interface will act as bridge between abstraction and implementer classes and also define common functionality of implementer.

Concrete Implementer – Implements the implementer interface and defines its concrete implementation.

Let’s have a look on below code demonstrating bridge pattern.

Code –

//abstraction

public abstract class Switch

{

    public abstract void TurnOn();

    public abstract void TurnOff();

    protected IDevice device;

}

//refined abstraction

public class RemoteControl : Switch

{

    IDevice myDevice;

    public RemoteControl(IDevice device)

    {

        myDevice = device;

    }

    public override void TurnOn()

    {

        myDevice.TurnOn("Remote Control");

    }

    public override void TurnOff()

    {

        myDevice.TurnOff("Remote Control");

    }

}

//refined abstraction

public class ManualSwitchBoard : Switch

{

    IDevice myDevice;

    public ManualSwitchBoard(IDevice device)

    {

        myDevice = device;

    }

    public override void TurnOff()

    {

        myDevice.TurnOff("Manual Switch Board");

    }

    public override void TurnOn()

    {

        myDevice.TurnOn("Manual Switch Board");

    }

}

   

//implementer - Bridge interface

public interface IDevice

{

    void TurnOn(string input);

    void TurnOff(string input);

}

//concrete implementer

public class TV : IDevice

{

    public void TurnOff(string input)

    {

        Console.WriteLine("Turning off TV via {0}", input);

    }

    public void TurnOn(string input)

    {

        Console.WriteLine("Turning on TV via {0}", input);

    }

}

//concrete implementer

public class Fan : IDevice

{

    public void TurnOn(string input)

    {

        Console.WriteLine("Turning on Fan via {0}", input);

    }

    public void TurnOff(string input)

    {

        Console.WriteLine("Turning off Fan via {0}", input);

    }

}

//client

class Program

{

    static void Main(string[] args)

    {

        //Implementation objects

        IDevice TV = new TV();

        IDevice Fan = new Fan();

        //abstraction objects

        Switch TVSwitch = new RemoteControl(TV);

        Switch FanSwitch = new RemoteControl(Fan);

        //client calls abstration object methods to achieve functionality

        TVSwitch.TurnOn();

        FanSwitch.TurnOn();

        TVSwitch.TurnOff();

        FanSwitch.TurnOff();

        TVSwitch = new ManualSwitchBoard(TV);

        TVSwitch.TurnOn();

        TVSwitch.TurnOff();

        Console.ReadLine();

    }

}

Output –

Above example provides multiple ways to turn on and turn off multiple devices. You can add as many devices as you want and you can also implement more methods to turn on and turn off devices. As per above example, Switch is abstract class and inherited by multiple classes and IDevice is an interface and act as Bridge and multiple devices implemented IDevice interface to achieve implementation part of how device work. Client needs to call only abstraction objects to achieve its functionality. As per above code, TV can be turn on or off via remote control or manually via switch board. If TV/Fan turning on/off mechanism changed then it won’t impact client code.

Advantages –

• Abstraction and implementation can be changed independently.
• Abstraction and implementer hierarchies can be extended independently.
• Hides implementation details from Client.

Difference between Adapter Pattern and Bridge Pattern –

Adapter Pattern	Bridge Pattern
Adapter pattern used to work with two incompatible interfaces	Bridge pattern provides multiple ways to design different components with multiple implementation. It allows to change abstraction and implementation separately.
Adapter pattern can be used on already designed objects.	Bridge pattern can be used on objects at the time of design.

I hope this article helps you to know more about Bridge Pattern. Please leave your feedback in comments below.

References –

DoFactory

See Also –

Creational Patterns	Structural Patterns	Behavioral Patterns
Singleton Pattern	Adapter Pattern	Chain of Responsibility Pattern
Thread safe singleton pattern	Bridge Pattern	Command Pattern
Factory Pattern	Composite Pattern	Interpreter Pattern
Abstract Factory Pattern	Decorator Pattern	Iterator Pattern
Builder Pattern	Facade Pattern	Mediator Pattern
Prototype Pattern	Flyweight Pattern	Memento Pattern
	Proxy Pattern	Observer Pattern
		State Pattern
		Strategy Pattern
		Template Method Pattern
		Visitor Pattern