23种设计模式之装饰器模式(Decorator Pattern)

 装饰器模式（Decorator Pattern）

允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

通过采用组合、而非继承的手法，Decorator模式实现了在运行时动态地扩展对象功能的能力，而且可以
根据需要扩展多个功能。避免了单独使用继承带来的“灵活性差"和"多子类衍生问题"。

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

缺点:多层装饰比较复杂

使用场景: 1、扩展一个类的功能。 2、动态增加功能，动态撤销   例如游戏装备,以及各层vip,商场的多重优惠等等

应用实例：不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体

装饰器模式主要组成部分：

Component：定义一个对象接口，可以给这些对象动态地添加职责

ConcreteComponent：定义一个对象，可以给这个对象添加一些职责

Decorator：维持一个指向Component的指针，并定义一个与Component接口一致的接口

ConcreteDecorator：负责向ConcreteComponent添加功能

假如我们需要为游戏中开发一种坦克，除了各种不同型号的坦克外，我们还希望在不同场合中为其增加以下一种或多种功能;比如红外线夜视功能，比如水陆两栖功能，比如卫星定位功能等等

按类继承的作法如下：

     //抽象坦克
     public abstract class Tank
     {
        public abstract void Shot();
        public abstract void Run();
     }

各种型号：

    //T50型号
    public class T50:Tank
     {
        public override void Shot()
         {
            Console.WriteLine("T50坦克平均每秒射击5发子弹");
         }
         public override void Run()
        {
             Console.WriteLine("T50坦克平均每时运行30公里");
         }
     }

     //T75型号 
     public class T75 : Tank
     {
         public override void Shot()
         {
             Console.WriteLine("T75坦克平均每秒射击10发子弹");
         }
         public override void Run()
         {
             Console.WriteLine("T75坦克平均每时运行35公里");
         }
     }

     //T90型号  
     public class T90 :Tank
     {
        public override void Shot()
        {
            Console.WriteLine("T90坦克平均每秒射击10发子弹");
         }
         public override void Run()
         {
             Console.WriteLine("T90坦克平均每时运行40公里");
         }
     }

各种不同功能的组合：比如IA具有红外功能接口、IB具有水陆两栖功能接口、IC具有卫星定位功能接口。

 //T50坦克各种功能的组合
 public class T50A:T50,IA
 {
   //具有红外功能
 }
 public class T50B:T50,IB
 {
  //具有水陆两栖功能
 }
 public class T50C:T50,IC
 {
 
 }
 public class T50AB:T50,IA,IB
 {}
 public class T50AC:T50,IA,IC
 {}
 public class T50BC:T50,IB,IC
 {}
 public class T50ABC:T50,IA,IB,IC
{}

     //T75各种不同型号坦克各种功能的组合
   public class T75A:T75,IA
   {
     //具有红外功能
   }
   public class T75B:T75,IB
   {
    //具有水陆两栖功能
   }
  public class T75C:T75,IC
  {
    //具有卫星定位功能
  }
  public class T75AB:T75,IA,IB
  {
   //具有红外、水陆两栖功能
 }
  public class T75AC:T75,IA,IC
 {
   //具有红外、卫星定位功能
 }
  public class T75BC:T75,IB,IC
  {
  //具有水陆两栖、卫星定位功能
 }
  public class T75ABC:T75,IA,IB,IC
  {
   //具有红外、水陆两栖、卫星定位功能
 }

     //T90各种不同型号坦克各种功能的组合
   public class T90A:T90,IA
   {
     //具有红外功能
   }
   public class T90B:T90,IB
   {
    //具有水陆两栖功能
   }
  public class T90C:T90,IC
  {
    //具有卫星定位功能
  }
  public class T90AB:T90,IA,IB
  {
   //具有红外、水陆两栖功能
 }
  public class T90AC:T90,IA,IC
  {
   //具有红外、卫星定位功能
 }
  public class T90BC:T90,IB,IC
  {
  //具有水陆两栖、卫星定位功能
 }
  public class T90ABC:T90,IA,IB,IC
  {
   //具有红外、水陆两栖、卫星定位功能
 }

由此可见，如果用类继承实现，子类会爆炸式地增长

装饰器模式实现代码：

namespace Decorator
 {
   public abstract class Tank
     {
        public abstract void Shot();
        public abstract void Run();
     }
 }

     public class T50:Tank
     {
         public override void Shot()
         {
             Console.WriteLine("T50坦克平均每秒射击5发子弹");
         }
         public override void Run()
         {
            Console.WriteLine("T50坦克平均每时运行30公里");
         }
     }

     public class T75 : Tank
     {
         public override void Shot()
         {
             Console.WriteLine("T75坦克平均每秒射击10发子弹");
         }
         public override void Run()
         {
             Console.WriteLine("T75坦克平均每时运行35公里");
         }
     }

     public class T90 :Tank
     {
         public override void Shot()
         {
             Console.WriteLine("T90坦克平均每秒射击10发子弹");
         }
         public override void Run()
         {
             Console.WriteLine("T90坦克平均每时运行40公里");
         }
     }

    public abstract class Decorator :Tank //Do As 接口继承 非实现继承
     {
        private Tank tank; //Has a  对象组合
        public Decorator(Tank tank)
        {
            this.tank = tank;
        }
        public override void Shot()
        {
            tank.Shot();
        }
        public override void Run()
        {
            tank.Run();
        }
     }

    public class DecoratorA :Decorator
    {
        public DecoratorA(Tank tank) : base(tank)
        {
        }
       public override void Shot()
       {
          //Do some extension //功能扩展 且有红外功能
          base.Shot();
       }
       public override void Run()
       {
 
         base.Run();
       }
     }

    public class DecoratorB :Decorator
     {
       public DecoratorB(Tank tank) : base(tank)
        {
        }
       public override void Shot()
       {
          //Do some extension //功能扩展 且有水陆两栖功能
          base.Shot();
       }
      public override void Run()
      {
        base.Run();
      }
    }

    public class DecoratorC :Decorator
     {
        public DecoratorC(Tank tank) : base(tank)
        {
       }
       public override void Shot()
       {
         //Do some extension //功能扩展 且有卫星定位功能
          base.Shot();
       }
       public override void Run()
       {
 
         base.Run();
       } 
          
    }

前端调用：

         static void Main(string[] args)
         {
             Tank tank = new T50();
             DecoratorA da = new DecoratorA(tank); //且有红外功能
             DecoratorB db = new DecoratorB(da);   //且有红外和水陆两栖功能
            DecoratorC dc = new DecoratorC(db);   //且有红外、水陆两栖、卫星定们三种功能
             dc.Shot();
             dc.Run();
         }

Decorator在.NET(Stream)中的应用：

BufferedStream和CryptoStream其实就是两个包装类，这里的Decorator模式省略了抽象装饰角色（Decorator），示例代码如下：

     public static void Main(string[] args)
     {
         MemoryStream ms =
             new MemoryStream(new byte[] { 100,456,864,222,567});
         //扩展了缓冲的功能
         BufferedStream buff = new BufferedStream(ms);
 
         //扩展了缓冲，加密的功能
          CryptoStream crypto = new CryptoStream(buff);
     }

   public sealed class BufferedStream : Stream
  {
    // Methods
     private BufferedStream();
     public BufferedStream(Stream stream);
     public BufferedStream(Stream stream, int bufferSize);
     // Fields
     private int _bufferSize;
     private Stream _s;
   }

通过反编译，可以看到BufferedStream类的代码（只列出部分），它是继承于Stream类

本文参考文档：

https://www.cnblogs.com/abcdwxc/archive/2007/09/06/884495.html

https://www.runoob.com/design-pattern/decorator-pattern.html

https://www.cnblogs.com/banluduxing/p/9152453.html