8.Bridge 桥接模式（结构型模式）

【1】抽象A==>实现细节b

【2】抽象A==>抽象B<==实现细节b

【3】【抽象B】==相对稳定，也可能变化   【实现细节b】==频繁变化

【4】抽象B 不稳定？

思考问题：一个变化是平台（抽象B）的变化，另一个变化是型号（实现细节b）的变化。

【抽象部分B】

public abstract class Tank
{
    protected TankPlatformImplementation tankImple;
    public Tank(TankPlatformImplementation tankImple){this.tankImple=tankImple;}

    public abstract void Shot();
    public abstract void Run(); 
    public abstract void Trun();
}

public abstract class TankPlatformImplementation
{
    public abstract void MoveTankTO(Point to);//移动到某个点
    public abstract void DrawTank();          //画一个Tank
    public abstract void DoShot();            //播放声音，画出轨迹，特效等
}

 【实现细节b】各种实际实现通过继承来实现

public class T50:Tank { }
public class T75:Tank { }
public class T90:Tank { }

各种平台不同的实现： 

//PC                                   //Mobile
public class PCT50:T50 { }             public class MobileT50:T50 { }
public class PCT75:T75 { }             public class MobileT75:T75 { }
public class PCT90:T90 { }             public class MobileT90:T90 { }

软件加上时间轴，随着时间的变化，动态的创作软件系统。

using System;

namespace 视频桥接模式
{
    class Program
    {
        static void Main(string[] args)
        {

            TankPlatFormImplementation tanImpl = new MobileTankImplementation();
            Tank t50_Tank = new T50(tanImpl);
            t50_Tank.Shot();
            t50_Tank.Stop();
            t50_Tank.Run();
            Console.WriteLine(" 桥接模式");
        }
    }

    public abstract class Tank 
    {
        //抽象的组合对象方法，继承纯碎的是is a 的关系。
        //继承就是一种紧耦合。

        protected TankPlatFormImplementation tanImpl;
        public Tank(TankPlatFormImplementation tanImpl) 
        {
            this.tanImpl = tanImpl;
        }
        public TankPlatFormImplementation TanImpl { get { return this.tanImpl; } set { this.tanImpl = value; } }
        public abstract void Shot();
        public abstract void Run();
        public abstract void Stop();
    }

    public class T50 : Tank
    {
        public T50(TankPlatFormImplementation tanImpl) : base(tanImpl)
        {
        }

        public override void Stop()
        {
            tanImpl.DoShot();
        }
        public override void Run()
        {
            tanImpl.MoveTankTo(new Point());
        }

        public override void Shot()
        {
            tanImpl.DoShot();
        }
    }

    public class T75 : Tank
    {
        public T75(TankPlatFormImplementation tanImpl) : base(tanImpl)
        {
        }

        public override void Stop()
        {
            tanImpl.DoShot();
        }
        public override void Run()
        {
            tanImpl.MoveTankTo(new Point());
        }

        public override void Shot()
        {
            tanImpl.DoShot();
        }
    }


    public class T90 : Tank
    {
        public T90(TankPlatFormImplementation tanImpl) : base(tanImpl)
        {
        }

        public override void Stop()
        {
            tanImpl.DoShot();
        }
        public override void Run()
        {
            tanImpl.MoveTankTo(new Point());
        }

        public override void Shot()
        {
            tanImpl.DoShot();
        }
    }

    public abstract class TankPlatFormImplementation
    {
        public abstract void MoveTankTo(Point to);
        public abstract void DrawTank();
        public abstract void DoShot();
    }

    public class PCTankImplementation : TankPlatFormImplementation
    {
        public override void DoShot()
        {
            Console.WriteLine("PCTankImplementation---Doshot()");
        }

        public override void DrawTank()
        {
            Console.WriteLine("PCTankImplementation---DrawTank()");
        }

        public override void MoveTankTo(Point to)
        {
            Console.WriteLine("PCTankImplementation---MoveTankTo(Point to)");
        }
    }

    public class MobileTankImplementation : TankPlatFormImplementation
    {
        public override void DoShot()
        {
            Console.WriteLine("MobileTankImplementation---Doshot()");
        }

        public override void DrawTank()
        {
            Console.WriteLine("MobileTankImplementation---DrawTank()");
        }

        public override void MoveTankTo(Point to)
        {
            Console.WriteLine("MobileTankImplementation---MoveTankTo(Point to)");
        }
    }



    public class Point
    {

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            ImageImp temp1 = new LinuxImp();
            ImageImp temp = new WindowImp();

            Image imp = new JPGImage();
            imp.SetImageImp(temp);
            imp.Show("zhongguo");

            Image imp1= new PNGImage();

            imp1.SetImageImp(temp1);
            imp1.Show("zhongguo");

            Console.WriteLine("Program02--------------");
            Console.ReadLine();
        }
    }
    //-----------------------------------------------
    public class Matix
    {
        public int x;
        public int y;

        public Matix(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    public abstract class ImageImp { public abstract void DoPaint(Matix m); }

    public class WindowImp : ImageImp
    {
        public override void DoPaint(Matix m)
        {
            Console.WriteLine("在window系统中显示图像。");
        }
    }
    public class LinuxImp : ImageImp
    {
        public override void DoPaint(Matix m)
        {
            Console.WriteLine("在Linux系统中显示图像。");
        }
    }
    public class UnixxImp : ImageImp
    {
        public override void DoPaint(Matix m)
        {
            Console.WriteLine("在Linux系统中显示图像。");
        }
    }

    public abstract class Image 
    {
        protected ImageImp imageImp;
        public void SetImageImp(ImageImp imageImp) { this.imageImp = imageImp; }

        public abstract void Show(string s);

    }

    public class JPGImage : Image
    {

        public override void Show(string s)
        {
            imageImp.DoPaint(new Matix(10, 20));
            Console.WriteLine("JpgImp---");
        }
    }
    public class PNGImage : Image
    {

        public override void Show(string s)
        {
            imageImp.DoPaint(new Matix(10, 30));
            Console.WriteLine("PNGImp---");
        }
    }



    


    //----------------------------------------------

    public abstract class Implemetor//实施者
    {
        public abstract void OperationImpl();//活动，业务
    }

    public class ConcreteImplementor : Implemetor
    {
        public override void OperationImpl()
        {
            throw new NotImplementedException();
        }
    }

    public abstract class Abstraction 
    {
        protected Implemetor impl; //定义实现类接口对象
        public void SetImpl(Implemetor impl) 
        {
            this.impl = impl;
        }

        public abstract void Operation();//声明抽象业务方法
    }

    public class RefinedAbstraction : Abstraction
    {
        public override void Operation()
        {
            impl.OperationImpl(); //调用实现类代码
        }
    }

}

using System;

namespace 视频桥接模式
{
    class Bridge_Demo
    {
        public static void Main()
        {
            Pencil p1 = new BigPen(new RedColor());
            p1.Draw();
            p1.SetColor();


            p1._SetColor = new BlueColor();
            p1.Draw();
            p1.SetColor();

            p1 = new SmallPen(new GreenColor());
            p1.Draw();
            p1.SetColor();
            Console.WriteLine("Bridge----");
            Console.ReadLine();
        }
    }


    public abstract class Pencil
    {
        public SetColor setColor;

        protected Pencil(SetColor setColor)
        {
            this.setColor = setColor;
        }

        public SetColor _SetColor { get { return setColor; } set { this.setColor = value; } }
        public abstract void Draw();
        public abstract void SetColor();
    }


    public class BigPen : Pencil
    {
        public BigPen(SetColor setColor) : base(setColor)
        {
        }

        public override void Draw()
        {
            setColor.ColorDraw();
            Console.WriteLine("大笔");
        }

        public override void SetColor()
        {
            setColor.Color();
            Console.WriteLine("大笔");
        }
    }
    public class SmallPen : Pencil
    {
        public SmallPen(SetColor setColor) : base(setColor)
        {
        }

        public override void Draw()
        {
            setColor.ColorDraw();
            Console.WriteLine("小笔");
        }

        public override void SetColor()
        {
            setColor.Color();
            Console.WriteLine("小笔");
        }
    }
    public class MiddlePen : Pencil
    {
        public MiddlePen(SetColor setColor) : base(setColor)
        {
        }
        public override void Draw()
        {
            setColor.Color();
            Console.WriteLine("中笔");
        }

        public override void SetColor()
        {
            setColor.Color();
            Console.WriteLine("中笔");
        }
    }

    public abstract class SetColor
    {
        public abstract void ColorDraw();
        public abstract void Color();
    }
    public class RedColor : SetColor
    {
        public override void Color()
        {
            Console.WriteLine("红色");
        }

        public override void ColorDraw()
        {
            Console.WriteLine("红色画图");
        }
    }
    public class GreenColor : SetColor
    {
        public override void Color()
        {
            Console.WriteLine("绿色");
        }

        public override void ColorDraw()
        {
            Console.WriteLine("绿色画图");
        }
    }
    public class BlueColor : SetColor
    {
        public override void Color()
        {
            Console.WriteLine("蓝色");
        }

        public override void ColorDraw()
        {
            Console.WriteLine("蓝色画图");
        }
    }
}

struct:

--------------------------------------------------------------------------------------------------------------------------------

桥接模式意图定义：将抽象部分与它他的实现部分解耦，使得两者都能够独立变化。--（GoF）

---------------------------------------------------------------------------------------------------------------------------------

桥接模式的 4 个要点：

将一个事务中多个维度的变化分离

【A】：使用对象间的组合关系，解耦了抽象和实现之间固有的绑定关系，使得抽象（tank）和实现（不同的平台）可以沿着各自的维度来变化。

【B】：所谓抽象和实现沿着各自的维度变化，即“子类化”他们，比如不同的Tank型号是子类变化，和不同的平台也是子类变化。得到各个子类之后，便可以任意组合它们，从而获得不同平台上的不同型号。

【C】：桥有时候类似于继承方案，但是多继承方案往往违背单一职责原则（即一个类只有一个变化的原因），复用性比较差。桥模式是比多继承方案更好的解决方法。

【D】：桥模式应用一般在两个非常强的变化维度，有时候即使有两个变化的维度，但是某一个方向的变化维度并不剧烈，换言之两个变化不会导致纵横交错的结果。并不一定要使用桥模式。

组合优于继承。