装饰模式（5）

本篇博文，给大家讲解一下装饰模式，还是老样子，有一个简单的例子逐步演绎

一、举例

用一个简单的控制台实现 一个人穿各种各样衣服 的功能

然后我们会很自然的写出一下代码：

先写一个Person类

 class Person
    {
        private string name;
        public Person(string name)
        {
            this.name = name;
        }
        public void WearTshirts()
        {
            Console.WriteLine("大T恤");
        }
        public void WearBigTrouser()
        {
            Console.WriteLine("跨裤");
        }
        public void WearSneakers()
        {
            Console.WriteLine("破球鞋");
        }
        public void WearSuit()
        {
            Console.WriteLine("西装");
        }
        public void WearTie()
        {
            Console.WriteLine("领带");
        }
        public void WearLeatherShoes()
        {
            Console.WriteLine("皮鞋");
        }
        public void Show()
        {
            Console.WriteLine($"{name}装扮完毕！");
        }
    }

然后客户端调用这个Person类

 static void Main(string[] args)
        {
            Person xmw = new Person("小魔王");
            Console.WriteLine("
第一种装扮");
            xmw.WearTshirts();
            xmw.WearBigTrouser();
            xmw.WearSneakers();
            xmw.Show();
            Console.WriteLine("
第二种装扮");
            xmw.WearSuit();
            xmw.WearTie();
            xmw.WearLeatherShoes();
            xmw.Show();
            Console.ReadKey();
        }

这样就写完了。

二、演绎

①现在，我各种装扮都写到了Person类中，有这样一个问题，假如，有一天，我新加了一件衣服，比如"皮裤"哈哈，那么，我该怎么办呢？

很多小伙伴就说了，这很容易啊，直接在Person类中增加一个“皮裤”的方法不就完事了吗。

这的确可以解决这个问题，这也是大多数人解决这个问题的方法。但是，真正的高手可以看出里面的弊端。

首先，给大家介绍程序设计中的一个重要原则——开放-封闭原则，这个原则讲的是：软件实体（类，模块，函数等等）应该可以扩展，但是不可修改。也就是说对于扩展是开放的，对于修改是封闭的。

那么，用 修改Person类来解决上述的问题就违背了开放-封闭原则。

那我们该如何解决上述这个问题呢？

于是，我们想到这样一个设计方法：

 /// <summary>
    /// Person类
    /// </summary>
    class Person
    {
        private string name;
        public Person(string name)
        {
            this.name = name;
        }
        public void Show()
        {
            Console.WriteLine($"{name}装扮完毕");
        }
    }
    /// <summary>
    /// 服饰抽象类
    /// </summary>
    abstract class Finery
    {
        public abstract void Show();
    }
    //各种服饰子类
    class TShirts : Finery
    {
        public override void Show()
        {
            Console.WriteLine("大T恤");
        }
    }
    class BigTrouser : Finery
    {
        public override void Show()
        {
            Console.WriteLine("跨裤");
        }
    }
    class Sneakers : Finery
    {
        public override void Show()
        {
            Console.WriteLine("破球鞋");
        }
    }
    class Surt : Finery
    {
        public override void Show()
        {
            Console.WriteLine("西装");
        }
    }
    class Tie : Finery
    {
        public override void Show()
        {
            Console.WriteLine("领带");
        }
    }
    class LeatherShoes : Finery
    {
        public override void Show()
        {
            Console.WriteLine("皮鞋");
        }
    }

上述，我们把各种各样的服饰写成单个的类。

客户端：

 static void Main(string[] args)
        {
            Person xmw = new Person("小魔王");
            Console.WriteLine("
第一种装扮");
            Finery dtx = new TShirts();
            Finery kk = new BigTrouser();
            Finery pqx = new Sneakers();
            dtx.Show();
            kk.Show();
            pqx.Show();
            xmw.Show();
            Console.WriteLine("
第二种装扮");
            Finery xz = new Surt();
            Finery ld = new Tie();
            Finery px = new LeatherShoes();
            xz.Show();
            ld.Show();
            px.Show();
            xmw.Show();
            Console.ReadKey();
        }

这样的话，如果要增加新的服饰，我只需要增加一个Finery 的子类就可以了。

在这里，我们用到了继承，用到了抽象，也做到了‘服饰’类与‘人’类的分离，的确进步不少，但还存在一些其他的问题。

什么问题呢？我们来看一下这段代码：

            dtx.Show();
            kk.Show();
            pqx.Show();
            xmw.Show();

怎么看怎么别扭呢。在客户端把穿的各种服饰一个一个的显示出来。这就好比，在客户面前，光着身子把各种服饰一件一件的穿上一样。这岂不是太丢人？我总不能当着客户的面一件一件的穿衣服吧，我应该在别的地方一件一件的穿好了衣服，然后再去见客户。

所以，针对上述问题，我们应该在内部组装完毕之后，在整体展现出来。（类似于建造者模式，但有所不同，最大的区别在于，建造者模式中的建造过程是稳定的，而我们这个例子中穿各种服饰的过程是不稳定的。在之后的博文中我会讲到建造者模式。）

我们可以想象一下穿衣服打扮的场景过程：我们从一大堆服饰中挑选自己习惯的来穿上，但是，穿衣服也是有顺序的，比如，先穿内裤，再穿毛裤。。。。但是，你可以玩个性的，先穿毛裤，再穿内裤。。。额，想想下面就刺挠。。

如果我们想要实现上述场景的功能，该如何设计呢？ 这貌似很难哦。

不要怕，接下来我们要讲的装饰模式可以很好的解决上述问题。

 首先，我们来看一下装饰模式的基本构成和作用。

    /// <summary>
    /// 此接口可以对这些对象动态的添加职责
    /// </summary>
    abstract class Component
    {
        public abstract void Operation();
    }
    /// <summary>
    /// 具体的对象，可以给这个对象添加一些职责
    /// </summary>
    class ConcreteComponent : Component
    {
        public override void Operation()
        {
            Console.WriteLine("具体对象的操作");
        }
    }
    /// <summary>
    /// 装饰类，继承Component，目的是从外类来扩展继承Component类的功能
    /// 对于Component来说，无须知道Decorator的存在。
    /// </summary>
    abstract class Decorator : Component
    {
        protected Component component;
        //设置Componnet
        public void SetComponent(Component component)
        {
            this.component = component;
        }
        //重写Operation（），实际执行的是Component的Operation（）
        public override void Operation()
        {
            if (component != null)
            {
                component.Operation();
            }
        }
    }
    /// <summary>
    /// 具体的装饰对象，起到给Component添加功能的作用。
    /// </summary>
    class ConcreteDecoratorA : Decorator
    {
        private string addedState;//本类独有的方法，以区别与ConcreteDecoratorB
        public override void Operation()
        {
            //首先运行原Component的Operation（），再执行本类的功能addedSate，相当于对原Component进行了装饰
            base.Operation();
            addedState = "New State";
            Console.WriteLine("具体装饰对象A的操作");
        }
    }
    class ConcreteDecoratorB : Decorator
    {
        public override void Operation()
        {
            //首先运行原Component的Operation（），再执行本类的功能 AddedBehavior()，相当于对原Component进行了装饰
            base.Operation();
            AddedBehavior();
            Console.WriteLine("具体装饰对象B的操作");
        }

        private void AddedBehavior()
        {
            //本类独有的方法，以区别与ConcreteDecoratorA
        }
    }

根据功能的扩展需要，可能还有ConcreteDecoratorC,ConcreteDecoratorD，等等这样的添加功能作用的类。

上述代码就是装饰模式的基本形式。一定要理解哦，注释已经很明确了哦。

 客户端：

  static void Main(string[] args)
        {
            ConcreteComponent c = new ConcreteComponent();
            ConcreteDecoratorA d1 = new ConcreteDecoratorA();
            ConcreteDecoratorB d2 = new ConcreteDecoratorB();
            //装饰的方法是：
            //首先用ConcreteComponent实例化对象c，
            //然后用ConcreteDecoratorA的实例化对象d1来包装c，
            //再用ConcreteDecoratorB的对象d2包装d1.最终执行d2的Operation（）
            d1.SetComponent(c);
            d2.SetComponent(d1);
            d2.Operation();
            Console.ReadKey();
        }

 下面，我们将装饰模式运用到一开始举的案例中。

   class Person
    {
        //构造函数
        public Person()
        {

        }
        private string name;
        //构造函数
        public Person(string name)
        {
            this.name = name;
        }
        public virtual void Show()
        {
            Console.WriteLine($"{name}装扮完毕");
        }
    }

    class Finery : Person
    {
        protected Person component;
        //设置Component
        public void Decorate(Person component)
        {
            this.component = component;
        }
        //重写Show()方法，实际执行的是Component中的Show()
        public override void Show()
        {
            if (component!=null)
            {
                component.Show();
            }
        }
    }

    class TShirts:Finery
    {
       
        public override void Show()
        {
            //先执行本类中的功能
            Console.WriteLine("大T恤");
            //在执行 Component 中的Show();
            base.Show();

            //相当于对原Component进行装饰
        }
    }
    class BigTrouser:Finery
    {
        //同TShirts类

        public override void Show()
        {
            Console.WriteLine("垮裤");
            base.Show();
        }
    }
    
    //***************其余类似装扮，省略**********

相比装饰模式模板的代码，我们少了两个抽象类，这里我么你要学会变通，一些不必要的类，我们可以省略，思路对即可。没有必要照葫芦画瓢，只有对设计模式达到灵活运用的时候，我们才能接近高手。

客户端调用

  static void Main(string[] args)
        {
            Person xmw = new Person("小魔王");
            Console.WriteLine("第一种装扮");
            BigTrouser bg = new BigTrouser();
            TShirts ts = new TShirts();
            bg.Decorate(xmw);
            ts.Decorate(bg);
            ts.Show();
            Console.ReadKey();
        }

ok，装饰模式讲完了，一句话总结一下：装饰模式是为已有功能动态添加更多功能的一种方式

好了，今天就到这吧，下一篇，会讲 代理模式

---

本系列将持续更新，喜欢的小伙伴可以点一下关注和推荐，谢谢大家的支持。