image.png

Bridge 模式

建立类的功能层次结构和类的实现层次结构之间的关系。

类的层次结构

希望增加新功能时

image.png image.png

类的功能层次结构：父类具有基本功能；在子类中增加新的功能。
【Tip】类的层次不要嵌套过深。

希望增加新的实现时

image.png image.png

类的实现层次：父类通过声明抽象方法来定义接口；子类通过实现具体方法来实现接口。

类的层次结构的混杂与分离

当类的层次结构只有一层时，功能层次结构与实现层次结构是混杂在一个层次结构中的。这样会很容易使类的层次结构变得复杂，以及难以理解。
这里通过 Bridge 把两种独立分离的类层次建立联系。

Show me the codes

namespace BridgePattern
{
    /// <summary>
    /// 显示
    /// </summary>
    internal class Display
    {
        private readonly DisplayImpl _displayImpl;

        public Display(DisplayImpl displayImpl)
        {
            _displayImpl = displayImpl;
        }

        /// <summary>
        /// 打开
        /// </summary>
        public void Open()
        {
            _displayImpl.RawOpen();
        }

        /// <summary>
        /// 打印
        /// </summary>
        public void Print()
        {
            _displayImpl.RawPrint();
        }

        /// <summary>
        /// 关闭
        /// </summary>
        public void Close()
        {
            _displayImpl.RawClose();
        }

        /// <summary>
        /// 显示
        /// </summary>
        public void Show()
        {
            Open();
            Print();
            Close();
        }
    }
}

namespace BridgePattern
{
    /// <summary>
    /// 按次数显示
    /// </summary>
    internal class CountDisplay : Display
    {
        public CountDisplay(DisplayImpl displayImpl) : base(displayImpl)
        {
        }

        /// <summary>
        /// 循环显示 times 次数
        /// </summary>
        /// <param name="times"></param>
        public void MultiDisplay(int times)
        {
            Open();
            for (var i = 0; i < times; i++)
            {
                Print();
            }

            Close();
        }
    }
}

namespace BridgePattern
{
    /// <summary>
    /// 显示
    /// </summary>
    internal abstract class DisplayImpl
    {
        /// <summary>
        /// 打开
        /// </summary>
        public abstract void RawOpen();

        /// <summary>
        /// 打印
        /// </summary>
        public abstract void RawPrint();

        /// <summary>
        /// 关闭
        /// </summary>
        public abstract void RawClose();
    }
}

using System;

namespace BridgePattern
{
    /// <summary>
    /// 字符串显示
    /// </summary>
    internal class StringDisplayImpl : DisplayImpl
    {
        private readonly string _str;

        public StringDisplayImpl(string str)
        {
            _str = str;
        }

        public override void RawOpen()
        {
            PrintLine();
        }

        public override void RawPrint()
        {
            Console.WriteLine($"|{_str}|");
        }

        public override void RawClose()
        {
            PrintLine();
        }

        /// <summary>
        /// 打印行
        /// </summary>
        private void PrintLine()
        {
            Console.Write("+");
            for (var i = 0; i < _str.Length; i++)
            {
                Console.Write("-");
            }

            Console.WriteLine("+");
        }
    }
}

namespace BridgePattern
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var d1 = new Display(new StringDisplayImpl("Hello, China."));
            Display d2 = new CountDisplay(new StringDisplayImpl("Hello, World."));
            var d3 = new CountDisplay(new StringDisplayImpl("Hello, https://360json.cn."));

            d1.Show();
            d2.Show();
            d3.Show();
            d3.MultiDisplay(5);
        }
    }
}

角色梳理

image.png

Abstraction：抽象化

该角色位于“类的功能层次结构”的最上层。使用了 Implementor 角色的方法定义基本的功能。对应示例中的 Display 类。

RefinedAbstraction：改善后的抽象化

在 Abstraction 橘色的基础上增加了新功能的角色。对应示例的 CountDisplay。

Implementor：实现者

该角色位于“类的实现层次结构”的最上层。它定义了用于实现 Abstraction 角色的接口的方法。对应示例的 DisplayImpl 类。

ConcreteImplementor：具体实现者

该角色负责实现在 Implementor 角色中定义的接口。对应示例的 StringDisplayImpl 类。

要点 & 思路

1.实现层次结构和功能层次结构分开后方便扩展；
2.继承是强关联，委托是弱关联

相关模式

Template Method 模式

Abstract Factory 模式

Adapter 模式