抽象工厂模式

前面我们介绍了简单工厂模式和工厂方法模式，现在简单的回顾一下：

简单工厂模式是充分利用面向对象的三大特性，将操作要素和操作方法对象化，通过定义工厂方法，决定实例化哪个对象。但简单工厂模式不利于程序的扩展，在需要扩展的时候需要将整个工程类开放，不符合开放-封闭原则。

在简单工厂模式的基础上，我们通过继承接口实现个操作对象的实例化，各具体操作类各自实现相应的方法，只需实现工厂类接口方法即可，在对功能进行扩展时，不需要对工厂类接口进行修改，只需新增操作类和实例化自己的工厂类即可。

那我们为什么需要抽象工厂模式呢？

当我们项目的数据库需要从sqlserver改成oracle时，当初用抽象工厂模式设计的优点就体现出来了。

抽象工厂模式：创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

以数据访问为例：

    interface IUser
    {
        void Insert(User user);

        User GetUser(int id);
    }

    class SqlserverUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在Sqlserver中给User表增加一条记录");
        }

        public User GetUser(int id)
        {
            Console.WriteLine("在Sqlserver中根据ID得到User表一条记录");
            return null;
        }
    }

    class AccessUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在Access中给User表增加一条记录");
        }

        public User GetUser(int id)
        {
            Console.WriteLine("在Access中根据ID得到User表一条记录");
            return null;
        }
    }

    interface IFactory
    {
        IUser CreateUser();
    }

    class SqlServerFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlserverUser();
        }
    }

    class AccessFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
    }

客户端调用：

            User user = new User();
　　　　　　     //IFactory factory=new SqlServerFactory();//SqlServer调用
            IFactory factory = new AccessFactory();//Access调用

            IUser iu = factory.CreateUser();

            iu.Insert(user);
            iu.GetUser(1);

            Console.Read();

当我们新增了一个表时，我们至少要新增四个类：表对象类，表对应接口类，表对象操作在sqlserver类，表对象操作在access类；修改三个类：工厂接口类，工厂接口类在sqlserver中实现类，工厂接口类在access中实现类。

还有就是当我们更改数据库时，程序中所有对工厂类进行实例化的地方都要修改。为此，我们可以通过简单工厂来改进抽象工厂：

将工厂接口类，工厂接口类在sqlserver中实现类，工厂接口类在access中实现类融合到一个类，也就是说将数据访问判断从客户端移到统一类：

class DataAccess
    {
        private static readonly string db = "Sqlserver";
        //private static readonly string db = "Access";

        public static IUser CreateUser()
        {
            IUser result = null;
            switch (db)
            {
                case "Sqlserver":
                    result = new SqlserverUser();
                    break;
                case "Access":
                    result = new AccessUser();
                    break;
            }
            return result;
        }

        public static IDepartment CreateDepartment()
        {
            IDepartment result = null;
            switch (db)
            {
                case "Sqlserver":
                    result = new SqlserverDepartment();
                    break;
                case "Access":
                    result = new AccessDepartment();
                    break;
            }
            return result;
        }
    }

但现在又有新的问题：当我们需要增加oracle数据访问时，需要在dataaccess类中的每个方法新增switch。

为了解决这个问题，我们需要用到反射机制。

使用.net里面的system.Reflection实现反射：

    class DataAccess
    {
        private static readonly string AssemblyName = "抽象工厂模式";//命名空间
        private static readonly string db = "Sqlserver";//要实例化的类前缀
        //private static readonly string db = "Access";

        public static IUser CreateUser()
        {
            string className = AssemblyName + "." + db + "User";
            return (IUser)Assembly.Load(AssemblyName).CreateInstance(className);
        }

        public static IDepartment CreateDepartment()
        {
            string className = AssemblyName + "." + db + "Department";
            return (IDepartment)Assembly.Load(AssemblyName).CreateInstance(className);
        }
    }

当然为了在更换数据库时完全不修改程序，我们可以用配置文件代替，在程序中读取配置文件。

private static readonly string db = "Sqlserver";//要实例化的类前缀

这样我们就可以在不修改DataAccess类的情况下更换数据库。