Structural Design Patterns: Bridge

In the dynamic landscape of software development, adaptability and maintainability are crucial attributes of a well-designed system. As applications grow in complexity, managing dependencies and accommodating changes become increasingly challenging. This is where design patterns come to the rescue, offering proven solutions to recurring design problems. Among these patterns, the Bridge Pattern stands out as a versatile tool for decoupling abstraction from implementation, promoting flexibility and scalability.

The Need for the Bridge Pattern:

Consider a scenario where we have a remote control system that interacts with various electronic devices such as TVs, radios, and lights. Each device may have different functionalities and behaviors. Traditionally, developers might be tempted to create a hierarchy of subclasses for each device type, leading to a tightly coupled design. However, as the system evolves, accommodating new devices or extending functionalities becomes cumbersome and error-prone. Moreover, changes in one part of the hierarchy could ripple through the entire system, causing unintended consequences.

This is where the Bridge Pattern comes into play. It addresses these issues by separating the abstraction (the remote control) from its implementation (the electronic devices). By doing so, it allows both the abstraction and implementation to vary independently. This decoupling not only simplifies the design but also makes it easier to extend and maintain the system over time.

Common Implementation of the Bridge Pattern:

In a typical implementation of the Bridge Pattern, we define two hierarchies: the abstraction hierarchy and the implementation hierarchy. The abstraction hierarchy represents the high-level logic, while the implementation hierarchy encapsulates the low-level details. A bridge connects these two hierarchies, allowing them to work together seamlessly.

1. Identifying Conceptual Dimensions: Identify the independent concepts present within your classes, such as abstraction versus platform, domain versus infrastructure, front-end versus back-end, or interface versus implementation.
2. Creating Concrete Implementations: For each platform within your domain, create concrete implementation classes ensuring they adhere to the implementation interface.
3. Defining Client Operations: Examine the operations required by the client and specify them within the base abstraction class.
4. Creating Abstractions and Implementation Reference: Within the abstraction class, introduce a reference field for the implementation type. The abstraction primarily delegates its tasks to the implementation object referenced by this field.
5. Creating Refined Abstractions (Optional): If your system involves multiple variations of high-level logic, create refined abstractions for each variant by extending the base abstraction class.
6. Providing Implementation Association: In the client code, provide an implementation object to the abstraction’s constructor to establish their association. Subsequently, the client can disregard the implementation and solely interact with the abstraction object.

Example Implementation in C#:

Let’s illustrate the Bridge Pattern with a C# example. We have an abstraction interface IRemote representing a remote control system, and an implementation interface IDevice representing various electronic devices. Concrete implementations of IRemote and IDevice are provided by the Remote and device classes such as TV, Radio, and Light.

In the code snippet provided, we create instances of different devices (TV and Radio) and associate them with a remote control (Remote class). We then demonstrate various functionalities such as powering on/off, setting channels, and adjusting volume. The use of the Bridge Pattern allows us to extend the system easily by adding new device types or functionalities without modifying existing code.

interface IDevice
{
    int Volume { get; set; }
    void PowerOn();
    void PowerOff();
    void SetChannel(double channel);
}

// Concrete Device Implementations
class TV : IDevice
{
    public int Volume { get; set; } = 10;
    public void PowerOn() => Console.WriteLine("TV is powered on");
    public void PowerOff() => Console.WriteLine("TV is powered off");
    public void SetChannel(double channel) => Console.WriteLine($"TV channel set to {(channel % 1 == 0 ? channel.ToString() : channel.ToString("0.0"))}");
}

class Radio : IDevice
{
    public int Volume { get; set; } = 5;
    public void PowerOn() => Console.WriteLine("Radio is powered on");
    public void PowerOff() => Console.WriteLine("Radio is powered off");
    public void SetChannel(double channel) => Console.WriteLine($"Radio frequency set to {(channel % 1 == 0 ? channel.ToString() : channel.ToString("0.0"))}");
}

interface IRemote
{
    void PowerOn();
    void PowerOff();
    void SetChannel(double channel);
    void VolumeUp();
    void VolumeDown();
}

// Bridge Implementation: Concrete Remote Implementation
class Remote(IDevice device) : IRemote
{
    private IDevice _device { get; } = device;

    public void PowerOn() => _device.PowerOn();
    public void PowerOff() => _device.PowerOff();
    public void SetChannel(double channel) => _device.SetChannel(channel);
    public void VolumeUp()
    {
        _device.Volume++;
        PrintVolume();
    }
    public void VolumeDown()
    {
        _device.Volume--;
        PrintVolume();
    }

    private void PrintVolume() => Console.WriteLine($"The volume is: {_device.Volume}");
}

// Client
class Program
{
    static void Main(string[] args)
    {
        // TV Remote
        var tv = new TV();
        var tvRemote = new Remote(tv);

        tvRemote.PowerOn();
        tvRemote.SetChannel(5);
        tvRemote.VolumeUp();
        tvRemote.PowerOff();

        // Radio Remote
        var radio = new Radio();
        var radioRemote = new Remote(radio);

        radioRemote.PowerOn();
        radioRemote.SetChannel(95.5);
        radioRemote.VolumeDown();
        radioRemote.PowerOff();
    }
}

Link to the GitHub repo: design-patterns/02-BridgePattern at master · antonespo/design-patterns · GitHub

The output presented in the console window reflects the interactions between the remote control and the various devices.

TV is powered on
TV channel set to 5
The volume is: 11
TV is powered off
Radio is powered on
Radio frequency set to 95,5
The volume is: 4
Radio is powered off

In conclusion, the Bridge Pattern offers an elegant solution to the problem of coupling abstraction and implementation in software design. By decoupling these concerns, it enables systems to evolve gracefully, adapting to changing requirements with ease. Whether you’re building a remote control system or any other complex software application, the Bridge Pattern can be a valuable tool in your design arsenal, fostering flexibility, maintainability, and scalability.