设计模式--decorator Pattern

• Decorator Pattern
  装饰模式用于动态地给一个对象增加一些额外的职责，就增加对象功能来说，装饰模式比生成子类实现更为灵活。它是一种对象结构型模式。
  Wrapping a gift, putting it in a box, and wrapping the box。

• Decorator 模式分析
  装饰模式包含四个角色：

• （Component）抽象构件： 定义了对象的接口，可以给这些对象动态增加职责（方法）；

• （ConcreteComponent）具体构件： 定义了具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）；

• （Decorator）抽象装饰类： 是（Component）抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现；

• （ConcreteDecorator）具体装饰类是抽象装饰类的子类，负责向构件添加新的职责。

• 类图
  

• 代码示例

/*
 * Decorators  Pattern:装饰器模式
 *
 */
using System;


namespace Pattern01
{
    class Program
    {
        static void Main(string[] args)
        {

            // Create ConcreteComponent and two Decorators

            ConcreteComponent c = new ConcreteComponent();

            ConcreteDecoratorA d1 = new ConcreteDecoratorA();
            ConcreteDecoratorB d2 = new ConcreteDecoratorB();

            // Link decorators

            d1.SetComponent(c);//依据component对象，为其动态添加职责
            d1.Operation();


            Console.WriteLine("============");
            Console.WriteLine();


            d2.SetComponent(d1); //依据component对象，为其动态添加职责
            d2.Operation();


            Console.ReadKey();

        }


    }
    /// <summary>
    /// 抽象构件： 定义了对象的接口，可以给这些对象动态增加职责（方法）；
    /// </summary>
    abstract class Component
    {
        public abstract void Operation();
    }
    /// <summary>
    /// 具体构件： 定义了具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）；
    /// </summary>
    class ConcreteComponent : Component
    {
        public override void Operation()
        {
            Console.WriteLine("具体构件的默认operation");
            Console.WriteLine("ConcreteComponent.Operation()");///
        }
    }
    /// <summary>
    /// 抽象装饰类： 是（Component）抽象构件类的子类，用于给ConcreteComponent 增加职责，但是具体职责在其子类中实现
    /// </summary>
    abstract class DeCorator : Component
    {
        protected Component component;//利用这个对象实现关联，从而将对象的功能加以扩展。
        public void SetComponent(Component component)
        {
            this.component = component;
        }
        public override void Operation()
        {
            if (component != null)
            {
                component.Operation();
            }
        }
    }

    class ConcreteDecoratorA : DeCorator
    {
        public override void Operation()
        {
            base.Operation();调用基类方法，

            ///这里可动态为component对象添加职责
            Console.WriteLine("具体装饰器A的Operation");
           

        }
    }

    class ConcreteDecoratorB : DeCorator
    {
        public override void Operation()
        {
            base.Operation();调用基类方法，并为Component，动态添加职责。

            //add behavior 

            AddedBehavior();//动态扩展对象的功能，为其增加职责
            Console.WriteLine("ConCreteDecoratorB.Operation()");
        }
        /// <summary>
        /// 动态为构件增加的职责。
        /// </summary>
        void AddedBehavior()
        {
            Console.WriteLine("ConCreteDecoratorB added behavior for 构件");
        }
    }


}

• 应用例子
  下面代码，模拟变形金刚，假设变形金刚未变身之前是一辆车，可以为其增加变身功能，变身成机器人，飞机，轮船，变身技能可以随意组合。

/*
 * Decorators  Pattern:装饰器模式,
 *
 */
using System;


namespace Pattern01
{
    class Program
    {
        static void Main(string[] args)
        {

            //变形金刚
       

            Car car = new Car();
            Robot robot = new Robot();
            AirPlane airPlane = new AirPlane();
            Ship ship = new Ship();


            Console.WriteLine("======机器人变身技能======");
            Console.WriteLine();

            robot.SetComponent(car);
            robot.Move();



            Console.WriteLine();
            Console.WriteLine("===== 机器人+飞机变身技能=======");
            Console.WriteLine();



            airPlane.SetComponent(robot);
            airPlane.Move();


            Console.WriteLine();
            Console.WriteLine("=======机器人+轮船 变身技能=====");
            Console.WriteLine();


            ship.SetComponent(robot);
            ship.Move();

            Console.WriteLine();
            Console.WriteLine("=====机器人+飞机+轮船 变身技能=======");
            Console.WriteLine();

            ship.SetComponent(airPlane);
            ship.Move();





            Console.ReadKey();

        }


    }
    /// <summary>
    /// Component  抽象构件： 定义了对象的接口，可以给这些对象动态增加职责（方法）；
    /// </summary>
    abstract class Transform
    {
        public abstract void Move();
    }
    /// <summary>
    /// ConcreteComponent 具体构件： 定义了具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）；
    /// </summary>
    class Car : Transform
    {
        public override void Move()
        {
            //核心功能
            Console.WriteLine("Move");
           
        }
    }
    /// <summary>
    /// DeCorator 抽象装饰类： 是（Component）抽象构件类的子类，用于给ConcreteComponent 增加职责，但是具体职责在其子类中实现
    /// </summary>
    abstract class changer : Transform
    {
        protected Transform transform;//利用这个对象实现关联，从而将对象的功能加以扩展。
        public void SetComponent(Transform  trans)
        {
            this.transform = trans;
        }
        public override void Move()
        {
            if (transform != null)
            {
                transform.Move();
            }
        }
    }
    /// <summary>
    /// ConcreteDecorator 
    /// </summary>
    class Robot : changer
    {
        public override void Move()
        {
            base.Move();调用基类方法，

            //装饰功能
            RobotMove();

        }
        void RobotMove()
        {
            Console.WriteLine(" i become a Robot now !!,i Can walk");
        }
    }
    /// <summary>
    /// ConcreteDecorator 
    /// </summary>
    class AirPlane :changer
    {
        public override void Move()
        {
            base.Move();

            ///装饰功能
            AddedBehavior();//动态扩展对象的功能，为其增加职责
        }
       
        /// <summary>
        /// 动态为构件增加的职责。
        /// </summary>
        void AddedBehavior()
        {
            Console.WriteLine(" i become a airplane, i can fly");
        }
    }
    /// <summary>
    /// ConcreteDecorator
    /// </summary>
    class Ship : changer
    {
        public override void Move()
        {
            base.Move();

            //装饰功能
            addBehaviorC();
        }
        public void addBehaviorC()
        {
            Console.WriteLine(" i become a ship now, i can swim");
        }
    }


}