装饰模式VS建造者模式

1）装饰模式

装饰者模式顾名思义就是装扮的意思，春天又来临了！女孩们又开始各方面的打扮自己了！想到这，自己忽然想来一个假设：下雪的夏天会是怎样的情景？

或许可以通过雪花来装饰一下炎热的夏天：

static void Main(string[] args)
        {
            World su = new World("季节");

            Console.WriteLine("\n第一种季节： ");

            Snow sw = new Snow();
            Dorritity dt = new Dorritity();
            Skate st = new Skate();

            sw.Seasons(su);
            dt.Seasons(sw);
            st.Seasons(dt);
            st.show();

            Console.Read();
        }
    }
    //world类
    class World
    {
        public World ()
        { }
        private string season;
        public World (string season)
        {
            this.season = season;
        }
        public virtual void show()
        {
            Console.WriteLine("的{0}",season  );
        }
    }
    //季节类(Seasons)
    class Decoration :World
    {
        protected World component;

        //修饰
        public void Seasons(World component)
        {
            this.component = component;
        }
        public override void show()
        {
            if (component !=null )
            {
                component.show();
            }
        }
    }
    //具体季节修饰类
    class Snow:Decoration
    {
        public override void show()
        {
            Console.WriteLine("飘着雪花 ");
            base.show();
        }
    }
    class Skate:Decoration
    {
        public override void show()
        {
            Console.WriteLine("划着旱冰 ");
            base.show();
        }
    }
    class Dorritity : Decoration
    {
        public override void show()
        {
            Console.WriteLine("汗淋淋 ");
            base.show();
        }
    }

结果：

小时候每年夏天一直幻想的季节，现在终于实现了哈！

装饰模式定义来说，就是动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更加灵活。简单点就是为已有的功能动态地添加更多功能的一种方式

优点：把类中的装潢四功能从类中搬移去除，这样可以简化原有的类。这样做更大的好处就是有效地把类的核心职责和装饰功能区分开了，而且可以去除相关中重复的装饰逻辑。

描述：简单点就是对象A可以装饰成对象B，还可以装饰成对象C……这样被装饰的对象就拥有了所有装饰者对象的能力。

2）建造者模式：

在现实世界中，我们遇到的对象往往是很复杂的对象。该对象由许多子对象组成，并且这些子对象的创建步骤是一样，只是他们的创建细节不一样。这就要用到我们的建造者模式了，先来举个例子：

每月的18号是德克士半价的日子，这个月18正好赶上了休息，所以去和同学大吃了一顿，感觉很不错哈!德克士里的套餐创建不就是一个很好的例子吗？

namespace dicos点餐
{
    class Program
    {
        static void Main(string[] args)  //通过服务者A，B来服务顾客
        {
            dicosWaiter dicoswaiter = new dicosWaiter();
            MealBuilder b1 = new SubMealBuilderA();
            //MealBuilder b2 = new SubMealBuilderB();

            dicoswaiter.Construct(b1);
            Meals p1 = b1.GetResult();
            p1.show();
        }
    }
    class Meals
    {
        IList kinds= new List();

        public void Add (string kind)   //添加肉类
        {
            kinds.Add(kind );
        }
        public void show()
        {
            Console.WriteLine("\n 香辣鸡翅，鸡排大亨，烧鸡肉饭，超级鸡腿堡,冰淇淋……");
            foreach (string kind in kinds )
            {
                Console.WriteLine(kind );
            }
        }
    }
    //抽象建造者类
    abstract class MealBuilder
    {
        public abstract void MealBuilderX();
        public abstract void MealBuilderY();
        public abstract Meals GetResult();
    }
    //SubMealBuilderA  -具体建造者类
    class SubMealBuilderA : MealBuilder
    {
        private Meals meals = new Meals();

        public override void MealBuilderX()
        {
            meals.Add("服务者A");
        }
        public override void MealBuilderY()
        {
            meals.Add ("服务者B");
        }
        public override Meals GetResult()
        {
            return meals;
        }
    }
class dicosWaiter    //用来指挥服务员服务过程
    {
        public void Construct(MealBuilder mealbuilder)
        {
            mealbuilder.MealBuilderX();
            mealbuilder.MealBuilderY();
        }
    }

老板通过服务员A，B来服务顾客。运行结果：

看着运行结果有没有特别有食欲的感觉呢？建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式。

3）两者比较：

装饰模式	建造者模式
装饰物与被装饰物继承自同一组件类，组件对象均可由装饰物在外部按顺序装饰；	被建造者集成一个成员组成稳定的接口，并对成员内容做具体实现。
各装饰物记录自己装饰了谁，其功能函数除了实现自己的功能外，还需要调用被自己装饰的组件的功能函数	被创建对象的成员有一个指挥类稳定的按顺序件建造，指挥类隔离建造过程及客户代码；
针对构建过程不稳定的情况	针对建造者过程十分稳定的情况

转载于:https://www.cnblogs.com/huohuoL/p/10545597.html