8.Bridge 桥接模式(结构型模式)

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

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

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

【4】抽象B 不稳定?

思考问题:一个变化是平台(抽象B)的变化,另一个变化是型号(实现细节b)的变化。

【抽象部分B】

cs 复制代码
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();
}
cs 复制代码
public abstract class TankPlatformImplementation
{
    public abstract void MoveTankTO(Point to);//移动到某个点
    public abstract void DrawTank();          //画一个Tank
    public abstract void DoShot();            //播放声音,画出轨迹,特效等
}

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

cs 复制代码
public class T50:Tank { }
public class T75:Tank { }
public class T90:Tank { }

各种平台不同的实现:

cs 复制代码
//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 { }

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

cs 复制代码
using System;

namespace ConsoleApp2
{
    internal class Tank_Factory
    {
        public static void Main() 
        {
            TankPlatformImplementation tankImpl = new MobileTankImplementation();
            T50 tank = new T50(tankImpl);
            tank.Show();
            
              
            tank.TankImpl = new MobileTankImplementation();
            tank.Show();


            Console.WriteLine(tank.ToString());

            Console.WriteLine("Tank_Factory01");
            Console.ReadLine();
        }

    }


    public class Point
    {
    }
    //--Tank------------
    public abstract class Tank
    {
        protected TankPlatformImplementation tankImpl;
        protected Tank(TankPlatformImplementation tankImpl)
        {
            this.tankImpl = tankImpl;
        }

        public TankPlatformImplementation TankImpl
        {
            get { return this.tankImpl; }
            set { this.tankImpl = value; }
         }
        public abstract void Show();
        public abstract void Run();
        public abstract void Stop();

    }
    //--TankPlatformImplementation------------
    public abstract class TankPlatformImplementation
    {
        public abstract void MoveTank(Point to);
        public abstract void DrawTank();
        public abstract void DoShot();
    }
    //--PCTankImplementation------------------
    public class PCTankImplementation : TankPlatformImplementation
    {
        public override void DoShot()
        {
            Console.WriteLine("PCTankImplementation");
        }

        public override void DrawTank()
        {
            
        }

        public override void MoveTank(Point to)
        {
            
        }
    }
    //--MobileTankImplementation--------------
    public class MobileTankImplementation : TankPlatformImplementation
    {
        public override void DoShot()
        {
            Console.WriteLine("MobileTankImplementation");
        }

        public override void DrawTank()
        {

        }

        public override void MoveTank(Point to)
        {

        }
    }



    //--T50-------------
    public class T50 : Tank
    {
        public T50(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
        }

        public override void Run()
        {
           tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }
    //--T75-------------
    public class T75 : Tank
    {
        public T75(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
        }

        public override void Run()
        {
            tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }
    //--T90--------------
    public class T90 : Tank
    {
        public T90(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
        }

        public override void Run()
        {
            tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }

    //--PCT50--------------
    public class PCT50 : T50
    {
        public PCT50(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
        }

        public override void Run()
        {
            tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }
    //--PCT75--------------
    public class PCT75 : T75
    {
        public PCT75(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
        }

        public override void Run()
        {
            tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }
    //--PCT90--------------
    public class PCT90 : T90
    {
        public PCT90(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
        }

        public override void Run()
        {
            tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }


    //--MobileT50-------------
    public class MobileT50 : T50
    {
        public MobileT50(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
            
        }

        public override void Run()
        {
            tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }

    //--MobileT75-------------
    public class MobileT75 : T75
    {
        public MobileT75(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
        }

        public override void Run()
        {
            tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }

    //--MobileT90-------------
    public class MobileT90 : T90
    {
        public MobileT90(TankPlatformImplementation tankImpl) : base(tankImpl)
        {
        }

        public override void Run()
        {
            tankImpl.MoveTank(new Point());
        }

        public override void Show()
        {
            tankImpl.DoShot();
        }

        public override void Stop()
        {
            tankImpl.DrawTank();
        }
    }
cs 复制代码
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(); //调用实现类代码
        }
    }

}

struct:


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


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

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

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

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

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

组合优于继承。

相关推荐
吾与谁归in25 分钟前
【C#设计模式(23)——模板方法模式(Template Method Pattern)】
设计模式·c#·模板方法模式
C66668883 小时前
C#格式化输出
开发语言·c#
玉面小君3 小时前
C#图表性能的巅峰之选:LightningChart®.NET
信息可视化·c#·.net
CodeCraft Studio3 小时前
利用.NET版Word处理控件Aspose.Words,使用 C# 在 Word 中创建图表
c#·word·.net
步、步、为营4 小时前
C# 将 List 转换为只读的 List
windows·c#·list
我曾经是个程序员4 小时前
C#委托(Delegate)基本用法
开发语言·c#
步、步、为营5 小时前
Moq与xUnit在C#单元测试中的应用
单元测试·c#·log4j
时光追逐者7 小时前
在 .NET 9 中使用 Scalar 替代 Swagger
开源·c#·.net·.netcore·微软技术
军训猫猫头7 小时前
43.Textbox的数据绑定 C#例子 WPF例子
java·c#·wpf