c#桥接模式详解

基础介绍：

  将抽象部分与它的实现部分分离，使它们都可以独立地变化。适用于不希望在抽象和实现部分之间有固定的绑定关系的情况，或者类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充的情况。

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

  其实两个都是抽象的部分，更准确的说，是将一个事物中多个维度的变化分离。

  比如不用软件运行在不同的操作系统上。

  操作系统是一个维度，分为ios、Android、Windows等。

  软件系统是一个维度，分别为微信、QQ、酷狗音乐等。

  一个维度可以认为是抽象部分，另一个维度可以认为是实现部分，而这两个维度可以独立扩充和维护。

  单独看起来比较复杂和难以理解，可以先大致看下基础结构，然后结合以下实例来解读。

  桥接模式的结构：

　　  Abstraction：定义抽象类的接口，一般为抽象类，规范RefinedAbstraction，并创建一个Implementor实例。主要靠这个类来进行桥接。

　　  RefinedAbstraction：Abstraction的子类，具体实现Abstraction里规定的方法。

　　  Implementor：定义实现类的接口，一般情况，Implementor接口仅为提供基本操作，而Abstraction则定义了基于基本操作的较高层次操作。

　　  ConcreteImplementor：Implementor的子类，具体实现Implementor接口 。

　　在桥接模式中，两个类Abstraction和Implementor分别定义了抽象与行为类型的接口，通过调用子类实现抽象与行为的动态组合。

应用场景：

  适用于不希望在抽象和实现部分之间有固定的绑定关系的情况，或者类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充的情况。

创建方式：

  桥接模式的实现方式是通过在抽象类中持有一个指向实现类的引用，从而将抽象类与实现类解耦。

  通常情况下，抽象类和实现类都需要定义自己的接口，以便彼此之间进行通信。

 

实例一：不用软件运行在不同的操作系统上。

   操作系统是一个维度，分为ios、Android、Windows等。

   软件系统是一个维度，分别为微信、QQ、酷狗音乐等。

   这两个维度可以独立扩充和维护，一个维度可以认为是抽象部分，另一个维度可以认为是实现部分。

   实现部分中的接口（Implementor）只需提供基本操作，抽象部分中的接口（Abstraction）来创建一个实现接口（Implementor）实例，用这个实例将两部分紧密连续在一起。

   抽象部分也是基于这个实例才做一些较高层次的操作。

   在这里可以把操作系统当做抽象部分，把软件系统当做实现部分。

   在抽象部分中创建一个抽象类（Abstraction），该类中创建一个软件系统的实例，即实现类的实例（Implementor），并规定抽象部分具体实现类（RefinedAbstraction）要实现哪些方法。

   注：抽象类和接口主要起桥梁作用和规范作用（Abstraction和Implementor），其具体实现都在其子类中（RefinedAbstraction和ConcreteImplementor）。

   在实现部分中创建一个接口（Implementor），该接口主要规范实现类（ConcreteImplementor）需要实现的方法。

   RefinedAbstraction和ConcreteImplementor分别继承自Abstraction和Implementor，并实现其规定的方法。

   即：

     Abstraction ---》操作系统抽象类

     RefinedAbstraction---》ios、Android、Windows等具体实现

     Implementor----》软件接口类

     ConcreteImplementor---》微信、QQ、酷狗音乐等具体实现

1、软件接口类

    /// <summary>
    /// 软件接口类
    /// </summary>
    public interface ISoftWare
    {
        /// <summary>
        /// 定义一个软件启动方法
        /// </summary>
        void Start();
    }

Implementor-实现类接口，只声明最基本的方法。

2、软件实现类

    /// <summary>
    /// 微信
    /// </summary>
    public class WeChat : ISoftWare
    {
        public void Start()
        {
            Console.WriteLine("启动微信");
        }
    }

    /// <summary>
    /// QQ
    /// </summary>
    public class TencentQQ : ISoftWare
    {
        public void Start()
        {
            Console.WriteLine("启动QQ");
        }
    }

ConcreteImplementor-继承自实现类接口，实现其基本方法。

3、系统抽象类

    /// <summary>
    /// 系统抽象类（桥接类）
    /// </summary>
    public abstract class SystemPlatform
    {
        //创建软件类实例
        public ISoftWare _softWare;

        //通过构造函数注入具体软件实例
        public SystemPlatform(ISoftWare softWare)
        {
            this._softWare = softWare;
        }

        //执行软件运行
        public abstract void Run();
    }

Abstraction-操作系统抽象类，创建一个实现类实例，用来访问实现类内的操作。

该类为实际的桥接类，其他还规范了更高一层的方法。

4、系统平台实现类

    /// <summary>
    /// ios系统
    /// </summary>
    public class IosSys : SystemPlatform
    {
        public IosSys(ISoftWare softWare) 
            : base(softWare)
        {
            Console.WriteLine("进入IOS系统");
        }
        public override void Run()
        {
            _softWare.Start();
        }
    }

    /// <summary>
    /// Android系统
    /// </summary>
    public class AndroidSys : SystemPlatform
    {
        public AndroidSys(ISoftWare softWare)
           : base(softWare)
        {
            Console.WriteLine("进入Android系统");
        }
        public override void Run()
        {
            _softWare.Start();
        }
    }

RefinedAbstraction-系统抽象具体实现类，实现了各个实际功能。

 5、客户端

    /// <summary>
    /// 客户端
    /// </summary>
    class Client
    {
        static void Main(string[] args)
        {
            //创建软件对象
            WeChat weChat = new WeChat();
            TencentQQ tencentQQ = new TencentQQ();

            //创建操作系统并安装软件
            SystemPlatform systemPlatform = new IosSys(weChat);
            systemPlatform.Run();

            systemPlatform = new AndroidSys(tencentQQ);
            systemPlatform.Run();

            Console.ReadKey();
        }
    }

这只是一个简单的实例，如果一个系统中预装载多个软件，可以将构造函数改为集合参数或者申明其他公开方法进行预安装。

 

实例二：不同形状的物体赋予不同颜色。

   不同形状的物体是一个维度，分别为长方形、矩形、圆形等。

   不同颜色是一个维度，分别为白色、黑色、红色等。

   即：

    Abstraction ---》形状抽象类

    RefinedAbstraction---》方形 圆形等具体实现

    Implementor----》颜色接口类

    ConcreteImplementor---》白色 黑色等具体实现

1、颜色接口类

    public interface Color
    {
        void Bepaint();
    }

规范颜色实现类，并供形状抽象类使用和维护。

2、颜色实现类

    public class White : Color
    {
        public void Bepaint()
        {
            Console.WriteLine("白色的");
        }
    }

    public class Gray : Color
    {
        public void Bepaint()
        {
            Console.WriteLine("灰色的");
        }
    }

    public class Black : Color
    {
        public void Bepaint()
        {
            Console.WriteLine("黑色的");
        }
    }

3、形状抽象类

    public abstract class Shape
    {
        public Color color;
        public void SetColor(Color color)
        {
            this.color = color;
        }
        public abstract void Draw();
    }

创建颜色实例供实现类使用，并规范实现类。

这个类主要是将形状和颜色两个维度的东西联系在一起，并制定高一级的操作规范。

4、形状实现类

    public class Circle : Shape
    {
        public override void Draw()
        {
            color.Bepaint();
            Console.WriteLine("圆形");
        }
    }
    public class Rectangle : Shape
    {

        public override void Draw()
        {
            color.Bepaint();
            Console.WriteLine("长方形");
        }
    }
    public class Square : Shape
    {
        public override void Draw()
        {
            color.Bepaint();
            Console.WriteLine("正方形");
        }
    }

具体实现类

5、客户端

    class Client
    {
        static void Main(string[] args)
        {
            //白色
            Color white = new White();
            //正方形
            Shape square = new Square();
            //白色的正方形
            square.SetColor(white);
            square.Draw();

            //长方形
            Shape rectange = new Rectangle();
            rectange.SetColor(white);
            rectange.Draw();

            Console.ReadKey();
        }
    }

其实颜色和形状两个维度的东西，各自维护和发展并不互相影响。

使用的时候也是将一个维度的东西加装的另一个维度上去，搭建一个桥梁供另一个维度去使用。

至于怎么加载就无所谓了，可以在构造函数中指定，也可以在方法参数中传递。

总结：

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

  桥接模式的实现方式是通过在抽象类中持有一个指向实现类的引用，从而将抽象类与实现类解耦。

  通常情况下，抽象类和实现类都需要定义自己的接口，以便彼此之间进行通信。