工厂和抽象工厂

　　如何将实例化具体类的代码从应用中抽离，或者封装起来，使他们不会干扰到应用的其他部分?

静态工厂方法　

    interface IAnimal
    {
        void Shout();
    }

    class Dog:IAnimal
    {
        #region IAnimal 成员

        public void Shout()
        {
            Console.WriteLine("汪汪汪...");
        }

        #endregion
    }

    class Duck:IAnimal
    {
        #region IAnimal 成员

        public void Shout()
        {
            Console.WriteLine("嘎嘎嘎...");
        }

        #endregion
    }

    class AnimalFactory
    {
        //静态工厂方法
        public static IAnimal Create(string category)
        {
            IAnimal animal = null;
            switch (category)
            {
                case "Dog":
                    animal = new Dog();
                    break;
                case "Duck":
                    animal = new Duck();
                    break;
                default:
                    break;
            }
            return animal;
        }
    }

　　把具体实例化的过程封装了起来，这已经开始有了面向对象编程的意识了（虽然这里用的是静态方法）。

工厂方法模式

　　接着上面的例子，我们把动物种类进行抽象，不再让他通同switch判断，下面我们创建动物类的工厂

    public interface AnimalFactory
    {
        IAnimal Create();
    }

    class DogFactory:AnimalFactory
    {
        #region AnimalFactory 成员

        public IAnimal Create()
        {
            return new Dog();
        }

        #endregion
    }

    class DuckFactory:AnimalFactory
    {
        #region AnimalFactory 成员

        public IAnimal Create()
        {
            return new Duck();
        }

        #endregion
    }

   public interface IAnimal
    {
        void Shout();
    }

    class Duck:IAnimal
    {
        #region IAnimal 成员

        public void Shout()
        {
            Console.WriteLine("嘎嘎嘎...");
        }

        #endregion
    }

    class Dog : IAnimal
    {
        #region IAnimal 成员

        public void Shout()
        {
            Console.WriteLine("汪汪汪...");
        }

        #endregion
    }

　　如果我们这时候再添加各种类型的动物因为不用再去大肆修改原来的代码，直接再建立新的动物工厂就行，这不就是实现类设计原则中常说的开放-封闭原则么。

抽象工厂

　　这个也是我们比较常见的一个模式，还记得Petshop这个案例么，它里面就有用到，在数据访问层就是用到的抽象工厂，创建了MSSQL和oracle数据库对数据操作的工厂。

通过工厂去创建对应数据类的处理。关于Petshop大家感兴趣的话可以自己去下载下来看，我们再写一个动物的例子好了。假设上面的动物分为家养和野生两种类型

   //家养
    public interface IKeepAnimal
    {
        void Shout();
    }
    //野生
    public interface IWildAnimal
    {
        void Shout();
    }

　　分别实现这两个接口

    class KeepDog:IKeepAnimal
    {
        #region IKeepAnimal 成员

        public void Shout()
        {
            Console.WriteLine("家养狗,汪！汪！汪！");
        }

        #endregion
    }

    class WildDog:IWildAnimal
    {
        #region IWildAnimal 成员

        public void Shout()
        {
            Console.WriteLine("野狗,汪~~~");
        }

        #endregion
    }

　　创建抽象工厂；依赖抽象，而不是依赖具体。

    interface AnimalFactory
    {
        IKeepAnimal KeepFactory();
        IWildAnimal WildFactory();
    }

    class DogFacory:AnimalFactory
    {
        #region AnimalFactory 成员

        public IKeepAnimal KeepFactory()
        {
            return new KeepDog();
        }

        public IWildAnimal WildFactory()
        {
            return new WildDog();
        }

        #endregion
    }

　　鸭子的实现方式也和狗的一样，大家感兴趣的话可以试着自己去写下。

小结

　　工厂方法模式通过让子类决定创建的对象是什么，来达到将对象创建的过程封装的目的。

　　抽象工厂模式提供一个接口，用于创建相关或依赖的对象家族，而不需要明确指定哪个类。