Bridge Pattern

The bridge pattern decouples an abstraction from its implementation so the two can vary independently. In other words we make a bridge between the abstraction and its implementation and therefore we won't have a binding between the two. The pattern helps us whenever we need to select or switch the implementation at runtime.

Example in C#
How does it work? Lets look at a small example.
    #region The Abstraction

    public class Abstraction
    {
        #region Members

        private Bridge _bridge;

        #endregion

        #region Ctor

        /// <summary>
        /// Construct a new Abstraction object with
        /// the given bridge
        /// </summary>
        /// <param name="bridge">The given bridge</param>
        public Abstraction(Bridge bridge)
        {
            _bridge = bridge;
        }

        #endregion

        #region Methods

        /// <summary>
        /// The method demonstrate the call for
        /// the bridge object by its abstraction
        /// </summary>
        public void Operation()
        {
            Console.Write("Using");
            _bridge.OperationImplementation();
        }

        #endregion
    }

    #endregion

    #region The Bridge And Its Implementations

    public interface Bridge
    {
        void OperationImplementation();
    }

    public class BridgeImplementationA : Bridge
    {
        #region Bridge Members

        /// <summary>
        /// Perform implementation A operation
        /// </summary>
        public void OperationImplementation()
        {
            Console.Write("BridgeImplementationA");
        }

        #endregion
    }

    public class BridgeImplementationB : Bridge
    {
        #region Bridge Members

        /// <summary>
        /// Perform implementation B operation
        /// </summary>
        public void OperationImplementation()
        {
            Console.Write("BridgeImplementationB");
        }

        #endregion
    }

    #endregion
You can see that the abstraction holds a bridge object and gets the bridge in the constructor. Therefore, whenever one of the implementation is needed you pass it in the constructor and you won't be coupled to the implementation.

UML Diagram

Summary
To sum up, use the bridge pattern whenever you identify that the operations
you write not always need to be implemented in the same way.
Another reason is not to bind the abstraction to its implementation.
Labels: