2.工厂方法模式

1.定义

Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory method let a class defer instantiation to subclasses.(定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。)

2.通用源码

    /// <summary>
    /// 抽象产品类
    /// </summary>
    public abstract class Product
    {
        //抽象方法
        public abstract void Method1();
    }

    /// <summary>
    /// 具体产品类
    /// </summary>
    public class ConcreteProduct1 : Product
    {
        public override void Method1() 
        {
            //业务逻辑处理
            Console.WriteLine("ConcreteProduct1");
        }
    }

    /// <summary>
    /// 具体产品类
    /// </summary>
    public class ConcreteProduct2 : Product
    {
        public override void Method1()
        {
            //业务逻辑处理
            Console.WriteLine("ConcreteProduct2");
        }
    }

    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class Creator
    {
        public abstract Product CreateProduct(Type type);
    }

    /// <summary>
    /// 具体工厂类
    /// </summary>
    public class ConcreteCreator : Creator
    {
        public override Product CreateProduct(Type type)
        {
            return Activator.CreateInstance(type) as Product;
        }
    }

 3.工厂模式的扩展

(1)缩小为简单工厂模式

我们这样考虑一个问题:一个模块仅需要一个工厂类，没有必要把它产生出来，使用静态的方法就可以了。针对上述的通用源码，只需要去掉抽象工厂类，同时把CreateProduct方法设置为静态方法。

    /// <summary>
    /// 具体工厂类
    /// </summary>
    public class Creator
    {
        public static Product CreateProduct(Type type)
        {
            return Activator.CreateInstance(type) as Product;
        }
    }

该模式是工厂方法模式的弱化，因为简单，所以称为简单工厂模式(Simple Factory Pattern),也叫做静态工厂模式。

(2)升级为多个工厂类

当我们在做一个比较复杂的项目时，经常会遇到初始化一个对象很耗费精力的情况，所有的产品类都放到一个工厂方法中进行初始化会使代码结构不清晰。例如，一个产品类有5个具体实现，每个实现类的初始化方法都不相同，如果写在一个工厂方法中，势必会导致该方法巨大无比。

考虑到需要结构清晰，我们就为每个产品定义一个创建者，然后由调用者自己去选择与哪个工厂方法关联。

    /// <summary>
    /// 抽象类
    /// </summary>
    public abstract class Human
    {
        //抽象方法
        public abstract void Method1();
    }

    /// <summary>
    /// 具体类
    /// </summary>
    public class BlackHuman : Human
    {
        public override void Method1() 
        {
            //业务逻辑处理
            Console.WriteLine("BlackHuman");
        }
    }

    /// <summary>
    /// 具体类
    /// </summary>
    public class WhiteHuman : Human
    {
        public override void Method1()
        {
            //业务逻辑处理
            Console.WriteLine("WhiteHuman");
        }
    }

    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class HumanFactory
    {
        public abstract Human CreateHuman();
    }

    /// <summary>
    /// 具体工厂类
    /// </summary>
    public class BlackHumanFactory : HumanFactory
    {
        public override Human CreateHuman()
        {
            return new BlackHuman();
        }
    }

     /// <summary>
    /// 具体工厂类
    /// </summary>
    public class WhiteHumanFactory : HumanFactory
    {
        public override Human CreateHuman()
        {
            return new WhiteHuman();
        }
    }

    /// <summary>
    /// 场景类
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Human whiteHuman = (new WhiteHumanFactory()).CreateHuman();

            whiteHuman.Method1();

            Console.ReadKey();
        }
    }

 3.延迟初始化

定义一个Map容器，容纳所有产生的对象，如果在Map窗口中已经有的对象，则直接取出返回;如果没有，则根据需要的类型产生一个对象并放入到Map窗口中，以方便下次调用。