今天将和大家一起讨论建造者模式、组合模式和装饰者模式。

先来讨论建造者模式，字里行间很容易明白这是一种对象创建型模式，一般对象的创建是由本身抽象实例化本身，在这里需要通过另外种角色建造者角色去帮我们创建。这是为什么呢？因为在现实系统中，我们遇到的对象往往是很复杂的对象。该对象由很多子对象组成，并且这些子对象的创建步骤是一样，只是它们的创建细节不一样，我们怎么解决该类问题呢！这就要求我们使用“封装机制”来隔离出“复杂对象的各个部分”的变化，这就是要讨论的建造者模式。

结构示意图如下：

 

建造者模式中的角色：

指导角色：对象创建的指导者，负责将客户的请求传给建造者，控制建造者怎样创建复杂对象。

抽象建造者角色：复杂对象创建者，提供对象创建模板。

具体建造者角色：实现复杂对象创建，提供对象创建细节，并向客户返回复杂对象。

示意代码：

抽象建造者：    /// 
    /// 抽象构造者，制定了复杂对象的构造步骤    /// 
    public abstract class AbstractBuilder    {        public abstract void BuilderPart1();        public abstract void BuilderPart2();        public abstract Food GetFood();}具体建造者：    /// 
    /// 具体建造者，实现了复杂对象具体构造细节    /// 
    public class FoodBuilder:AbstractBuilder    {        private Food food = new Food();        public override void BuilderPart1()        {            food.AddFood("a", "1");        }         public override void BuilderPart2()        {            food.AddFood("b", "2");        }         public override Food GetFood()        {            return food;        }    }复杂对象：    /// 
    /// 复杂对象    /// 
    public class Food    {        private Dictionary
     
       ht = new Dictionary
      
       ();         public void AddFood(string name, string price)        {            ht.Add(name, price);        }         public void Show()        {            foreach (KeyValuePair
       
         kv in ht)            {                Console.WriteLine(kv.Key + ":" + kv.Value);            }        }    }指挥者：    /// 
        
    /// 复杂对象构造控制者    /// 
    public class Director    {        public Director()        {         }         public Food Construct(AbstractBuilder ab)        {            ab.BuilderPart1();            ab.BuilderPart2();            return ab.GetFood();        }    }客户端示意性代码：class Client    {        static void Main(string[] args)        {            AbstractBuilder ab = new FoodBuilder();            Director d = new Director();            Food food=d.Construct(ab);            food.Show();            Console.ReadLine();        }     }
       
      
     

 

复杂对象创建时序图：

 

总结：

建造者模式向客户端隐藏了复杂对象的构造细节，符合设计原则开-闭原则。

 

 

 

 

 

 

 

 

 

 

接下来我们讨论组合模式(Composite)

在学习ASP.NET的时候，我们经常会碰到页面生命周期的问题。相信大家用户控件都用过，

当服务器渲染用户控件的时候，都会调用其中子空间的渲染方法，在用户（我们）看来，使用用户控件这种复杂元素就像使用简单元素一样方便，这无形之中就用到了常用的设计思想组合模式。组合模式的作用：就是封装复杂元素的复杂性，提供和简单元素一样的访问接口。

结构示意图：

 

组合模式涉及的角色：

抽象构件：规范了简单对象和复杂对象共同的接口。

简单对象：实现了抽象构件。

复杂对象：实现了抽象构件，并且提供管理简单对象的方法。

这里组合对象既实现了一般构件的方法，并且拥有复杂构件的维护接口，这属于组合模式安全式实现，如果将这部分接口提取到抽象构件里面，那么简单构件也拥有这部分功能，这是组合模式的透明式实现，但是这种设计有点不合理。

组合模式安全模式实现示意代码：

抽象构件：    /// 
    /// 抽象构件 定义了简单构件和复杂构件统一的访问接口    /// 
    public abstract class AbstractComponent    {        public abstract void Render();} 简单构件：    /// 
    /// 简单构件    /// 
    public class SampleComponent:AbstractComponent    {         public override void Render()        {            //render code        }} 复杂构件：    /// 
    /// 组合构件，聚合了简单构件    /// 
    public class Composite:AbstractComponent    {        private List
     
       sl=new List
      
       ();        public override void Render()        {            foreach (AbstractComponent ac in sl)            {                ac.Render();            }        }         public void Add(AbstractComponent ac)        {            sl.Add(ac);        }         public void Remove(AbstractComponent ac)        {            sl.Remove(ac);        }}客户端示意代码：    /// 
       
    /// 客户端    /// 
    class Client    {        static void Main(string[] args)        {            Composite c = new Composite();            c.Add(new SampleComponent());            //渲染复杂构件            c.Render();        }}
      
     

 

总结：

组合模式解耦了客户程序与复杂元素内部元素内部结构。

 

 

 

 

最后我们讨论下装饰者模式（decoration）

 

“装饰”二字在生活中经常听到。装饰房子简称装潢。女人最喜欢的一件事就是“装饰”（化妆）。装饰者模式就是给已有的对象增加新功能，但不是去修改原来的代码，就是借助于装饰者对象。它的魅力体现在对象A装饰成对象B还可以装饰成对象C…，可以以此装饰下去，这样被装饰的对象就拥有了所有装饰者对象的能力。还有个比较灵活的地方就是装饰对象可以任意组合装饰被装饰对象。

装饰者模式结构图：

 

设计到的角色：

抽象构件：装饰对象与被装饰对象统一接口。

具体构件：被装饰的对象。

抽象装饰者角色：包含抽象构件，实现统一接口。

具体装饰者角色：为具体构件提供新的职责。

 

示意性代码：

抽象构件：    /// 
    /// 抽象构件    /// 
    public abstract class Component    {        public abstract void  Operation();} 具体构件：    /// 
    /// 具体构件 需要被装饰的对象    /// 
    public class ConcreteComponent:Component    {        public override void Operation()        {            //operate code            Console.WriteLine("ConcreteComponent!");        } } 抽象装饰者：    /// 
    /// 装饰者接口，继承自抽象构件，并包含抽象构件引用    /// 
    public class Decorator:Component    {        private Component component;         public Decorator(Component component)        {            this.component = component;        }         public override void Operation() { component.Operation(); } } 具体装饰者：    /// 
    /// 具体装饰者 实现装饰者统一接口，并加入新的职责    /// 
    public class Decorator1:Decorator    {        public Decorator1(Component component) : base(component) { }         public override void Operation()        {            base.Operation();            AddNewBehavior();        }         private void AddNewBehavior()        {            Console.WriteLine("Decorator1");        }} 客户端代码：class Client    {        static void Main(string[] args)        {            ConcreteComponent cc = new ConcreteComponent();            Decorator d = new Decorator1(cc);            d.Operation();             Console.ReadLine();        } }

 

总结：

装饰模式与继承都是为了增加对象的功能，但是装饰者模式比继承更灵活，尽量用组合代替继承。