设计模式之装饰模式

c#装饰模式

1、定义

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

2、原理

1. UML类图
   
   Compnent是定义一个对象接口，可以给这些对象动态的添加职责。ConcreteCompnent是定义了一个具体的对象，也可以给这个对象添加一些职责。Decorator，装饰抽象类，继承了Compnent，从外类来扩展Compnent类的功能，但是Compnent是不需要知道Decorator存在的。至于ConcreteDecorator就是具体的装饰对象，起到给Compnent添加职责的功能

2. 代码实现：

//Compnent是定义一个对象接口，可以给这些对象动态添加职责
 abstract class Compnent
    {
        public abstract void Oprerator();

    }

 //定义了一个具体的对象，亦可以给这个对象添加职责
    class ConcreteCompnent : Compnent
    {
        public override void Oprerator()
        {
            Console.WriteLine("具体对象的操作");
        }
    }

  //装饰抽象类，继承自Compnent，从外类扩展Compnent功能，但是对于Compnent来说是无需知道Decorator存在的
 abstract class Decorator:Compnent
    {
        protected Compnent compnent;
        public void SetCompnent(Compnent compnent)
        {
            this.compnent = compnent;
        }

        public override void Oprerator()
        {
            if (compnent!=null)
            {
                compnent.Oprerator();
            }
        }
    }
}

//具体的装饰A
 class ConcreteDecoratorA:Decorator
    {
        private string AddState;
        public override void Oprerator()
        {
            base.Oprerator();
            AddState = "New State";
            Console.WriteLine("具体装饰对象A的操作");
        }
    }

//具体的装饰B
 class ConcreteDecoratorB:Decorator

    {
        public override void Oprerator()
        {
            base.Oprerator();
            AddBehavior();
            Console.WriteLine("具体装饰B的操作");
        }

        private void AddBehavior()
        {
            Console.WriteLine("B的行为");
        }
    }

客户端：

 //装饰的方法是先实例化ConcreteCompnent对象，然后实例化ConcreteDecoratorA对象来装饰ConcreteCompnent，
 //再实例化ConcreteDecoratorB对象装饰ConcreteDecoratorA，最后执行ConcreteDecoratorB的Opreator（）方法
    ConcreteCompnent cc = new ConcreteCompnent();
    ConcreteDecoratorA ca = new ConcreteDecoratorA();
      ConcreteDecoratorB cb = new ConcreteDecoratorB();
            ca.SetCompnent(cc);
            cb.SetCompnent(ca);
            cb.Oprerator();
            Console.ReadKey();

3、优点

把类中的装饰功能从类中搬移去除，这样可以简化原有的类；有效的把类的核心职责和装饰功能区分开了，而且可以去除相关类中的重复的装饰逻辑

4、实例

以人装饰衣服为例

1. UML类图
   

2. 代码实现
   如果只有一个ConcreteComponent类而没有抽象的Component类，那么Decorator类可以是ConcreteCopmnent的一个子类。同样道理，如果只有一个ConcreteDecorator类，那么就没必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator类的职责结合起来
   这里就没必要有Compnent类了，直接让Decorator继承人类ConcrateCompnent就可以了
   //人类

 class Person
    {
        private  string name;
        public Person()
        {

        }
        public Person(string name)
        {
            this.name = name;
        }

        public virtual void Show()
        {
            Console.WriteLine("装扮的{0}",name);
        }
    }

//Decorator类

 class Clothes : Person
    {
        protected Person compnent;
        //装扮
        public void Decorator(Person compnent)
        {
            this.compnent = compnent;
        }

        public override void Show()
        {
            if (compnent!=null)
            {
                compnent.Show();
            }
        }
    }

//具体服饰

//牛仔裤
 class Jeans : Clothes
    {
        public override void Show()
        {
            Console.WriteLine("H&M");
            base.Show();
        }
    }
    //运动鞋
     class Shoes:Clothes
    {
        public override void Show()
        {
            Console.WriteLine("New Balance");
            base.Show();
        }
    }
    //T_shirt
     class T_shirt:Clothes
    {
        public override void Show()
        {
            Console.WriteLine("Big T_Shirt");
            base.Show();

        }
    }

客户端：

 class Program
    {
        static void Main(string[] args)
        {
            Person dzb = new Person("DZB");
            T_shirt ts = new T_shirt();
            Jeans js = new Jeans();
            Shoes ss = new Shoes();
            ts.Decorator(dzb);
            js.Decorator(ts);
            ss.Decorator(js);
            ss.Show();
            Console.ReadKey();
        }
    }

输出：

5、源代码

设计模式之装饰模式