设计模式学习笔记五：抽象工厂（Abstract Factory）

    1.概述 
    意图：
        提供一个创建一系列相关或相互依赖的对象的接口，而无需指定其具体的类。
    使用场合：
        在以下场合可以使用抽象工厂:
        (1).一个系统要独立于其产品的创建、组合和表示时；
        (2).一个系统要有多个产品系列中的一个来配置时
        (3).需要提供一个产品类库，而只想显示他们的接口，而影藏其实现时。
    抽象工厂结构：

        (1).AbstractFactory:声明一个创建抽象产品对象的接口。
        (2).CreateFactory:实现创建具体产品对象的操作。
        (3).AbstractProduct：为一类产品对象声明接口。
        (4).CreateProduct:定义一个将被相应具体工厂创建的产品对象，以实现AbstractProduct接口。
        (5).仅使用AbstractFactory和AbstractProduct类声明的接口。
    2.实例
    大话设计模式中的用了抽象工厂模式的数据访问，结构图：

抽象工厂：

Code
public interface IFactory
    {
        IUser CreateUser();
        IDepartment CreateDepartment();
    }

具体工厂：

Code
public class AccessFactory:IFactory
    {
        IFactory 成员#region IFactory 成员

        public IUser CreateUser()
        {
            return new AccessUser();
        }

        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }

        #endregion
    }

Code
public class SqlFactory:IFactory
    {
        IFactory 成员#region IFactory 成员

        public IUser CreateUser()
        {
            return new SqlUser();
        }

        public IDepartment CreateDepartment()
        {
            return new SqlDepartment();
        }

        #endregion
    }

实体类：

Code
public class UserInfo
    {
        private int userid;
        private string name;

        public int UserID
        {
            get { return userid; }
            set { userid = value; }
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }

Code
public class Department
    {
        private int departmentid;
        private string departmengname;

        public int DepartmentID
        {
            get { return departmentid; }
            set { departmentid = value; }
        }

        public string DepartmentName
        {
            get { return departmengname; }
            set { departmengname = value; }
        }
    }

User：

Code
public interface IUser
    {
        void Insert(UserInfo UserOne);
        UserInfo GetUserOne(int UserID);
    }

Code
public class SqlUser:IUser
    {
        IUser 成员#region IUser 成员

        public void Insert(UserInfo UserOne)
        {
            Console.WriteLine("在SqlServer中给User表增加一条记录");
        }

        public UserInfo GetUserOne(int UserID)
        {
            Console.WriteLine("在SqlServer中根据UserID得UserInfo的一条记录");
            return null;
        }

        #endregion
    }

Code
 public class AccessUser:IUser
    {
        IUser 成员#region IUser 成员

        public void Insert(UserInfo UserOne)
        {
            Console.WriteLine("在Access中给User表增加一条记录");
        }

        public UserInfo GetUserOne(int UserID)
        {
            Console.WriteLine("在Access中根据UserID得UserInfo的一条记录");
            return null;
        }

        #endregion
    }

Department:

Code
    public interface IDepartment
    {
        void InsertDepartment(Department DepartmentOne);
        Department GetDepartment(int DepartmentID);
    }

Code
public class AccessDepartment:IDepartment
    {
        IDepartment 成员#region IDepartment 成员

        public void InsertDepartment(Department DepartmentOne)
        {
            Console.WriteLine("在Access中增加一条部门记录");
        }

        public Department GetDepartment(int DepartmentID)
        {
            Console.WriteLine("根据部门编号从Access的Department中提取一条部门记录");
            return null;
        }

        #endregion
    }

main：

Code
static void Main(string[] args)
        {
            UserInfo user = new UserInfo();
            Department dept = new Department();

            IFactory Accfactory = new SqlFactory();

            IUser iua = Accfactory.CreateUser();
            iua.Insert(user);
            iua.GetUserOne(1);
            IDepartment ida = Accfactory.CreateDepartment();
            ida.InsertDepartment(dept);
            ida.GetDepartment(1);
            Console.WriteLine("=============================================================");
            IFactory sqlfactory = new AccessFactory();

            IUser ius = sqlfactory.CreateUser();
            ius.Insert(user);
            ius.GetUserOne(1);
            IDepartment ids = sqlfactory.CreateDepartment();
            ids.InsertDepartment(dept);
            ids.GetDepartment(1);

            Console.ReadLine();
        }

运行结果：

    3.总结     
         实现要点： 抽象工厂本身不负责创建产品，产品最终还是由具体工厂来创建的。比如，Iua是AccessFactory创建的，而不是IFactory创建的。在.NET中可以使用反射来创建具体工厂，从而使得代码变动降到最低；在抽象工厂中需要体现出生产一系列产品。这一系列产品是相互关联，相互依赖一起使用的； 抽象工厂对应抽象产品，具体工厂对应具体产品，外部依赖抽象类型，这样对于新系列产品的创建，外部唯一依赖的就是具体工厂的创建过程（可以通过反射解决）。
        注意事项：一般来说需要创建一系列对象的时候才考虑抽象工厂；如果系统的变化点不在新系列的扩充上，那么就没有必要使用抽象工厂。
        优点： 分离了具体的类。抽象工厂模式帮助你控制一个应用创建的对象的类，因为一个工厂封装创建产品对象的责任和过程。它将客户和类的实现分离，客户通过他们的抽象接口操纵实例，产品的类名也在具体工厂的实现中被分离，它们不出现在客户代码中；它使得易于交换产品系列。一个具体工厂类在一个应用中仅出现一次——即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变； 它有利于产品的一致性。当一个系列的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要，而抽象工厂很容易实现这一点。
        缺点：难以支持新种类的产品。难以扩展抽象工厂以生产新种类的产品。这是因为抽象工厂几口确定了可以被创建的产品集合，支持新种类的产品就需要扩展该工厂接口，这将涉及抽象工厂类及其所有子类的改变。