学步园

前言：早已断断续续把23种设计模式学习了一遍，可是实际运用的不是很理想。如果刻意用设计模式，你会发现一个很小的项目，很小的功能其实处处都是可以按标准模式去编码的，这个也许就是所谓的过度设计的问题；而不用设计模式，代码又写得愚蠢臃肿，除了堆砌代码实现功能之外你看不到程序更别提思想上的一丝闪光点。也许正像网上很多人说的那样，到一定境界自动就会高效运用到项目中去了。当然现在也不能放弃学习它，下面就把创建型模式再整理一遍，下次用到的时候可以对照查一查看一下，希望可以“一劳永逸”。
一、概述
1、创建型模式，就是用来创建对象的模式，抽象了实例化的过程。它帮助一个系统独立于如何创建、组合和表示它的那些对象。
2、两个主旋律：第一，将系统使用哪些具体类的信息封装起来；第二，隐藏了这些类的实例是如何被创建和组织的。外界对于这些对象只知道它们共同的接口，而不清楚其具体的实现细节。
3、作用
创建者模式作用可以概括为如下两点（(1)和(2)引用网上博文）：
（1）封装创建逻辑，绝不仅仅是new一个对象那么简单。
（2）封装创建逻辑变化，客户代码尽量不修改，或尽量少修改。

 二、五种模式
1、单件模式（Singleton Pattern）

单件模式（Singleton Pattern）解决的是实体对象的个数问题，贴一段代码说明一下：

using System;
using System.Collections;
using System.Collections.Generic;

//创建型设计模式总结-单例模式
namespace CreateTypePattern
{
    //饿汉式
    sealed class Singleton
    {
        //私有的唯一实例成员,在类加载的时候就创建好了单例对象
        private static readonly Singleton instance = new Singleton();

        //私有的构造方法,避免外部创建类实例
        private Singleton()
        {
        }

        //静态方法,返回此类的唯一实例
        public static Singleton GetInstance()
        {
            return instance;
        }

    }

    //客户端调用
    public class Program
    {
        static void Main()
        {
           Singleton instance= Singleton.GetInstance();
           Singleton instance1 = Singleton.GetInstance();

           Console.WriteLine(object.ReferenceEquals(instance,instance1)); //引用指向同一个对象
           Console.WriteLine(instance.Equals(instance1)); //同一个对象

           Console.ReadLine();
        }
    }

}

2、工厂方法模式（Factory Pattern）

在工厂方法中，工厂类成为了抽象类，其实际的创建工作将由其具体子类来完成。工厂方法的用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中去，强调的是“单个对象”的变化。

using System;
using System.Collections;
using System.Collections.Generic;

//创建型设计模式总结-工厂方法模式
namespace CreateTypePattern
{
    interface IProduct
    {

    }
    class ProductA : IProduct
    {

    }
    class ProductB : IProduct
    {

    }
    interface IFactory
    {
        IProduct CreateProduct();
    }

    class FactoryA : IFactory
    {
        public IProduct CreateProduct() { return new ProductA(); }
    }

    class FactoryB : IFactory
    {
        public IProduct CreateProduct() { return new ProductB(); }
    }

    //客户端调用
    public class Program
    {
        static void Main()
        {
            IFactory factory = new FactoryA();
            Console.WriteLine(factory.CreateProduct().GetType());
            Console.WriteLine("---------------------------------");
            factory = new FactoryB();
            Console.WriteLine(factory.CreateProduct().GetType());
            Console.ReadLine();
        }
    }

}

3、抽象工厂模式（Abstract Factory）

(1).AbstractFactory:声明一个创建抽象产品对象的接口。
(2).CreateFactory:实现创建具体产品对象的操作。
(3).AbstractProduct：为一类产品对象声明接口。
(4).CreateProduct:定义一个将被相应具体工厂创建的产品对象，以实现AbstractProduct接口。
(5).仅使用AbstractFactory和AbstractProduct类声明的接口。
抽象工厂是所有工厂模式中最为抽象和最具有一般性的一种形态。抽象工厂可以向客户提供一个接口，使得客户可以在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象，强调的是“系列对象”的变化。

using System;
using System.Collections;
using System.Collections.Generic;

//创建型设计模式总结-抽象工厂模式
namespace CreateTypePattern
{
    /// <summary>
    /// 抽象工厂接口，里面包含所有的产品创建的抽象方法
    /// </summary>
    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    class ConcreteFactory1 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }
    /// <summary>
    /// 抽象产品A 它们都有可能有两种不同的实现 ProductA1，ProductA2
    /// </summary>
    abstract class AbstractProductA
    {
    }
    /// <summary>
    /// 抽象产品B 它们都有可能有两种不同的实现 ProductB1，ProductB2
    /// </summary>
    abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }

    class ProductA1 : AbstractProductA
    {
    }

    class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    class ProductA2 : AbstractProductA
    {
    }

    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    class Client
    {
        private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;

        // Constructor 
        public Client(AbstractFactory factory)
        {
            AbstractProductA = factory.CreateProductA();
            AbstractProductB = factory.CreateProductB();
        }

        public void Run()
        {
            AbstractProductB.Interact(AbstractProductA);
        }
    }
    //客户端调用
    public class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();

            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();

            Console.Read();
        }
    }
}

4、原型模式（Prototype Pattern）

和工厂模式一样，同样对客户隐藏了对象创建工作，但是，与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。

using System;
using System.Collections;
using System.Collections.Generic;

//创建型设计模式总结-原型模式
namespace CreateTypePattern
{
    /// <summary>
    /// 原型类
    /// </summary>
    public abstract class Prototype
    {
    
        public Prototype(string id)
        {
            this.id = id;
        }

        private string id;
        public string Id
        {
            get { return id; }
        }

        public abstract Prototype Clone();
    }

    /// <summary>
    /// 具体原型类ConcretePrototype1
    /// </summary>
    public class ConcretePrototype1 : Prototype
    {
        public ConcretePrototype1(string id)
            : base(id)
        {
        }

        public override Prototype Clone()
        {
            // Shallow copy 
            return (Prototype)this.MemberwiseClone();
        }
    }

    /// <summary>
    /// 具体原型类ConcretePrototype1
    /// </summary>
    public class ConcretePrototype2 : Prototype
    {
        // Constructor 
        public ConcretePrototype2(string id)
            : base(id)
        {
        }

        public override Prototype Clone()
        {
            // Shallow copy 
            return (Prototype)this.MemberwiseClone();
        }
    }

    //客户端调用
    public class Program
    {
        static void Main(string[] args)
        {
            ConcretePrototype1 p1 = new ConcretePrototype1("11111");
            ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();
            Console.WriteLine("Cloned id: {0}", c1.Id);
            Console.WriteLine(p1.Equals(c1));
            Console.WriteLine(object.ReferenceEquals(p1, c1));

            Console.WriteLine(p1.Id.Equals(c1.Id)); //true

            ConcretePrototype2 p2 = new ConcretePrototype2("22222");
            ConcretePrototype2 c2 = (ConcretePrototype2)p2.Clone();
            Console.WriteLine("Cloned id: {0}", c2.Id);
            Console.WriteLine(p2.Equals(c2));
            Console.WriteLine(object.ReferenceEquals(p2, c2));

            Console.WriteLine(p2.Id.Equals(c2.Id)); //true

            Console.Read();
        }
    }
}

5、建造者模式（Builder Pattern）

（1）抽象建造者（Builder）：给出一个抽象接口，以规范产品对象的各个组成部分的建造。
（2）具体建造者（Concrete Builder）：担任这个角色的是与应用程序紧密相关的一些类，它们在应用程序的调用下创建产品的实例。
（3）导演者（Director）：是与客户端打交道的角色，将创建产品的请求划分为对各个零件的建造请求，再将这些请求委派给具体建造者。 这一部分是组合到一起的算法（相对稳定）。
（4）产品（Product）：建造中的对象（由多个部件组成）。 这个复杂对象的组成部分经常面临着剧烈的变化。
建造者模式把构造对象实例的逻辑移到了类的外部，在这个类的外部定义了这个类的构造逻辑。它把一个复杂对象的构造过程从对象的表示中分离出来，其直接效果是将一个复杂的对象简化为一个比较简单的目标对象。

using System;
using System.Collections;
using System.Collections.Generic;

//创建型设计模式总结-建造者模式
namespace CreateTypePattern
{
    /// <summary>
    /// 产品类，由多个部件组成
    /// </summary>
    class Product
    {
        IList<string> listPart = new List<string>();
        public void Add(string part) //part添加产品部件
        {
            listPart.Add(part);
        }
        public void ShowDetail()
        {
            Console.WriteLine("Product created:");
            foreach (string item in listPart)
            {
                Console.WriteLine(item);
            }
        }
    }

    /// <summary>
    /// 抽象建造者，确定产品由两个部件partA和partB组成，并声明一个得到产品建造后结果的方法GetResult
    /// </summary>
    abstract class Builder
    {
        public abstract void BuildPartA();
        public abstract void BuildPartB();

        public abstract Product GetResult();
    }

    class ConcreteBuilder1 : Builder
    {
        private Product product = new Product();
        public override void BuildPartA()
        {
            product.Add("part A");
        }
        public override void BuildPartB()
        {
            product.Add("part B");
        }
        public override Product GetResult()
        {
            return product;
        }
    }

    class ConcreteBuilder2 : Builder
    {
        private Product product = new Product();
        public override void BuildPartA()
        {
            product.Add("part AA");
        }
        public override void BuildPartB()
        {
            product.Add("part BB");
        }
        public override Product GetResult()
        {
            return product;
        }
    }

    class Director
    {
        /// <summary>
        /// 指挥建造过程
        /// </summary>
        /// <param name="builder"></param>
        public void Construct(Builder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }

    //客户端调用
    public class Program
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder builder = new ConcreteBuilder1();
            director.Construct(builder);

            Product product = builder.GetResult(); //指挥者用ConcreteBuilder1创建产品
            product.ShowDetail();

            Console.WriteLine("----------------------");

            builder = new ConcreteBuilder2();
            director.Construct(builder);
            product = builder.GetResult(); //指挥者用ConcreteBuilder2创建产品
            product.ShowDetail();

            Console.Read();
        }
    }
}

关于创建型模式还有其他几种，ms它们用的很“非主流”，不在赘述了。