3.2.1 定义

将抽象部分与它的实现部分分离，使它们都可以独立地变化

3.2.2 场景模拟

以电视遥控器的一个例子来引出桥接模式解决的问题，遥控器有开电视，关电视，以及更换节目的功能，电视机有多个品牌

3.2.3 场景代码实现

抽象类TV封装了遥控器功能的变化，具体实现交给具体型号电视机去完成：

  /// <summary>
    /// 电视机，提供抽象方法
    /// </summary>
    public abstract class TV
    {
        public abstract void TurnOn();
        public abstract void TurnOff();

        public abstract void ChangeChannel();
    }

    /// <summary>
    /// 长虹牌电视机，重写基类的抽象方法
    /// 提供具体的实现
    /// </summary>
    public class ChangHongTV : TV
    {
        public override void TurnOn()
        {
            Console.WriteLine("长虹电视打开了");
        }
        public override void TurnOff()
        {
            Console.WriteLine("长虹电视关闭了");
        }
        public override void ChangeChannel()
        {
            Console.WriteLine("长虹电视换节目");
        }
    }

    /// <summary>
    /// 熊猫牌电视机，重写基类的抽象方法
    /// 提供具体的实现
    /// </summary>
    public class PandaTV : TV
    {
        public override void TurnOn()
        {
            Console.WriteLine("熊猫电视打开了");
        }
        public override void TurnOff()
        {
            Console.WriteLine("熊猫电视关闭了");
        }
        public override void ChangeChannel()
        {
            Console.WriteLine("熊猫电视换节目");
        }
    }

抽象化部分的代码：

 /// <summary>
    /// 抽象概念中的遥控器，扮演抽象化角色
    /// </summary>
    public class RemoteControl
    {
        public TV Implementor { get; set; }

       

        public virtual void TurnOn()
        {
            Implementor.TurnOn();
        }

        public virtual void TurnOff()
        {
            Implementor.TurnOff();
        }

        public virtual void ChangeChannel()
        {
            Implementor.ChangeChannel();
        }

    }
    /// <summary>
    /// 具体遥控器
    /// </summary>
    public class ConcreteRemote : RemoteControl
    {
        public override void ChangeChannel()
        {
            Console.WriteLine("-------------------");
            base.ChangeChannel();
            Console.WriteLine("-------------------");
        }
    }

客户端调用：

class Program
    {
        static void Main(string[] args)
        {
            // 创建一个遥控器
            RemoteControl remoteControl = new ConcreteRemote();
            // 长虹电视机
            remoteControl.Implementor = new ChangHongTV();
            remoteControl.TurnOn();
            remoteControl.ChangeChannel();
            remoteControl.TurnOff();
            Console.WriteLine();

            // 熊猫牌电视机
            remoteControl.Implementor = new PandaTV();
            remoteControl.TurnOn();
            remoteControl.ChangeChannel();
            remoteControl.TurnOff();
            Console.Read();
        }
    }

3.2.4 桥接模式的结构图

3.2.5 桥接模式的基本代码

Implementor类：

public abstract class Implementor
    {
        public abstract void Operation();
}

 public class ConcreteImplementorA : Implementor
    {
        public override void Operation()
        {
            Console.WriteLine("具体实现A的方法执行");
        }
    }

    public class ConcreteImplementorB : Implementor
    {
        public override void Operation()
        {
            Console.WriteLine("具体实现B的方法执行");
        }
    }

Abstraction类：

 public class Abstraction
    {
        protected Implementor implementor;

        public void SetImplementor(Implementor implementor)
        {
            this.implementor = implementor;
        }

        public virtual void Operation()
        {
            implementor.Operation();
        }
    }
  public class RefindedAbstraction : Abstraction
    {
        public override void Operation()
        {
            implementor.Operation();
        }
    }

客户端调用：

class Program
    {
        static void Main(string[] args)
        {
            Abstraction ab = new RefindedAbstraction();
            ab.SetImplementor(new ConcreteImplementorA());
            ab.Operation();

            ab.SetImplementor(new ConcreteImplementorB());
            ab.Operation();
            Console.Read();
        }
    }

3.2.6 优缺点

优点：

把抽象接口与其实现解耦。

抽象和实现可以独立扩展，不会影响到对方。

实现细节对客户透明，对用于隐藏了具体实现细节。

缺点： 增加了系统的复杂度

 

3.2.7 使用场景

如果一个系统需要在构件的抽象化角色和具体化角色之间添加更多的灵活性，避免在两个层次之间建立静态的联系。

设计要求实现化角色的任何改变不应当影响客户端，或者实现化角色的改变对客户端是完全透明的。

需要跨越多个平台的图形和窗口系统上。

一个类存在两个独立变化的维度，且两个维度都需要进行扩展。

参考链接：https://www.cnblogs.com/zhaoshujie/p/9743429.html