C#设计模式之【结构型设计模式：装饰器模式】

一.装饰器模式简述

  概念： 装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
  就增加功能而言，装饰器模式比直接生成子类更加灵活。装饰器模式使用继承+组合的方式解决问题。
  下面我们以给汽车改装的例子进行代码示例，假如我新买了一部奥迪A8，我想给它进行改装发动机（必选项，先改装），改轮毂、车身喷漆、改排气管作为可选项（假设每个改装顺序和改装组合的不同，都会使得改装效果不同），那么，我应该怎么办？
  首先想到最传统的办法，就是方法的继承，先写一个父类，有改装发动机的方法，然后：
  子类A继承父类+改轮毂
  子类B继承父类+改轮毂+车身喷漆
  子类C继承父类+改轮毂+改排气管
  子类D继承父类+改轮毂+车身喷漆+改排气管
  子类E继承父类+改轮毂+改排气管+车身喷漆
  子类F继承父类+车身喷漆
  子类G继承父类+车身喷漆+改轮毂
  子类H继承父类+车身喷漆+改排气管
  子类I继承父类+车身喷漆+改轮毂+改排气管
  子类J继承父类+车身喷漆+改排气管+改轮毂
  子类K继承父类+改排气管
  子类L继承父类+改排气管+改轮毂
  子类M继承父类+改排气管+车身喷漆
  子类N继承父类+改排气管+改轮毂+车身喷漆
  子类O继承父类+改排气管+车身喷漆+改轮毂

  学过排列组合都知道，子类一共有 A31+A32+A33种，假如我要改装的东西更多，使用传统继承的方式那岂不是子类爆炸boom？？
  所以，我们通过装饰器模式代码示例，解决以上问题

  UML图：

二.代码示例

    /// <summary>
    /// 抽象类
    /// </summary>
   public abstract class AbstractCar
    {
        /// <summary>
        /// 车型
        /// </summary>
        public string CarType { get; set; }

        /// <summary>
        /// 车主
        /// </summary>
        public string UserName { get; set; }

        /// <summary>
        /// 改装
        /// </summary>
        public abstract void Refit();

    }
    
    /// <summary>
    /// 需要被改装（装饰）的汽车类
    /// </summary>
    public class Car : AbstractCar
    {

        public override void   Refit()
        {
            Console.WriteLine("改装发动机");//必改项目：
        }
    }

  基础装饰器：

    /// <summary>
    /// 汽车装饰器基类
    /// </summary>
    public class BaseCarDecorator : AbstractCar
    {

        private AbstractCar _Car = null;

        public BaseCarDecorator(AbstractCar abstractCar)
        {
            _Car = abstractCar;
        }

        public override void Refit()
        {
            //基类装饰器必须是个空的行为 ,不要做任何装饰
            _Car.Refit();//直接调用被装饰的对象的原始方法         
        }
    }

  其他装饰器

    /// <summary>
    /// 排气管装饰器
    /// </summary>
    public class CarVentpipeDecorator : BaseCarDecorator
    {
        public CarVentpipeDecorator(AbstractCar abstractCar)
            :base(abstractCar)//传给父类构造函数
        {

        }
        public override void Refit()
        {
            base.Refit();//调用父类的方法
            Console.WriteLine("改装排气管");//开始改装排气管逻辑
        }
    }
   


    /// <summary>
    /// 车身喷漆装饰器
    /// </summary>
   public class CarBodyDecorator:BaseCarDecorator
    {
        public CarBodyDecorator(AbstractCar abstractCar):base (abstractCar)
        {

        }

        public override void Refit()
        {
            base.Refit();
            Console.WriteLine("全车喷漆");//喷漆车身逻辑
        }
    }


    /// <summary>
    /// 轮毂装饰器
    /// </summary>
  public  class CarWheelhubDecorator:BaseCarDecorator
    {
        public CarWheelhubDecorator(AbstractCar abstractCar) : base(abstractCar)
        {

        }

        public override void Refit()
        {
            base.Refit();
            Console.WriteLine("改成大轮毂");//改轮毂业务逻辑
        }
    }

  问题来了，为什么需要装饰器基类？直接装饰也是可以的啊！
  其实，如果没有装饰器基类，假如AbstractCar有10个抽象方法，你的其他所有装饰器都继承了顶层AbstractCar，那10个方法都得重写，这是没得说的。即使你只想对其中的某个方法增加功能。其他的9个方法也必须得重写，岂不是挺麻烦？
  如果先写类装饰器基类，基类把AbstractCar的所有方法先实现一遍（但是没有写任何装饰逻辑，而是直接调用被装饰类的原始方法）。其他的子类装饰器想对某个方法增加功能，就只重写它就行了。

三.总结

意图： 动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

主要解决： 一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用： 在不想增加很多子类的情况下扩展类的功能。动态增加类功能、动态撤销类的功能。

优点： 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点： 多层装饰比较复杂。