设计模式（三）（Abstract Factory）抽象工厂

• 定义:

抽象工厂同工厂方法有相似处：都提供了对子类创建的封装，都是有工厂方法的接口实现类的中决定了子类被创建为什么对象。

不同于工厂方法之处：工厂方法创建的对象只是一个类型的子类，而抽象工厂创建的对象为多个类型的不同类。

例如：工厂方法创建与A具有同一性质的子类A1，A2，而抽象工厂确实要负责创建多个类型的类：A1,A2...B1,B2...。

• 应用场景：

当在一个类中出现多个不同类型类的创建时，而且这些不同类都可以抽象出不同的接口，这是就可以考虑抽象工厂。

• 例如：我们系统中有Member，和SupperMember,而Member要求Mmeber1:Member要求保存在Access数据库中，Member2:Member要求保存在SqlServer数据库中；

SupperMember要求SupperMember1：SupperMember存储在Access数据库总，而SupperMember2:SupperMember保存在SqlServer数据库中。

• 分析：

我们可以想到该场景适用于创建类型的模式，而有多个不同创品创建的子类，可以想到工厂方法，但是我们这里SupperMember和Member是两个不同的类型的类，这就是说，我么要创建多个不同类型的子类，这无疑最适合的就是抽象工厂了。

• 实现：

　　1. 代码结构：

　　2. 代码：

MemberBO.cs

/// <summary>
    /// Description of MemberBO.
    /// </summary>
    public class MemberBO
    {
        private MemberDaoBase memberDaoBase = null;
        
        public MemberBO(string dbType)
        {
            if (dbType.ToUpper() == "ACCESS") {
                this.memberDaoBase = new MemberAccessDao();
            } else if (dbType.ToUpper() == "SQLSERVER") {
                this.memberDaoBase = new MemberSqlServerDao();
            } else {
                throw new ArgumentOutOfRangeException();
            }
        }
        
        public MemberBase CreateMember()
        {
            return this.memberDaoBase.CreateMember();
        }
    
        public SupperMemberBase CreateSupperMember()
        {
            return this.memberDaoBase.CreateSupperMember();
        }
    }

MemberDaoBase.cs

/// <summary>
    /// Description of MemberDaoBase.
    /// </summary>
    public abstract class MemberDaoBase
    {
        public abstract MemberBase CreateMember();
        
        public abstract SupperMemberBase CreateSupperMember();
    }

MemberAccessDao.cs

/// <summary>
    /// Description of MemberAccessDao.
    /// </summary>
    public class MemberAccessDao:MemberDaoBase
    {
        public MemberAccessDao()
        {
        }
        
        public override MemberBase CreateMember()
        { 
            Console.WriteLine("create member1 in access db");
            return new Member1();
        }
        
        public override SupperMemberBase CreateSupperMember()
        {    
            Console.WriteLine("create suppermember1 in access db");
            return new SupperMember1();
        }
    }

MemberSqlServerDao.cs

/// <summary>
    /// Description of MemberSqlServerDao.
    /// </summary>
    public class MemberSqlServerDao:MemberDaoBase
    {
        public MemberSqlServerDao()
        {
        }
        
        public override MemberBase CreateMember()
        {
            Console.WriteLine("create member2 in sqlserver db");
            return new Member2();
        }
        
        public override SupperMemberBase CreateSupperMember()
        {
            Console.WriteLine("create suppermember2 in sqlserver db");
            return new SupperMember2();
        }
    }

MemberBase.cs

public abstract class MemberBase
    {
        public int ID{ get; set; }
    
        public string Name{ get; set; }
    }

Member1.cs

/// <summary>
    /// Description of Member1.
    /// </summary>
    public class Member1:MemberBase
    {
        public Member1()
        {
        }
    }

Member2.cs

/// <summary>
    /// Description of Member2.
    /// </summary>
    public class Member2:MemberBase
    {
        public Member2()
        {
        }
    }

SupperMemberBase.cs

/// <summary>
    /// Description of SupperMember.
    /// </summary>
    public abstract class SupperMemberBase
    {        
        public int ID { get; set; }
            
        public string Name { get; set; }
    }

SupperMember1.cs

    /// <summary>
    /// Description of SupperMember1.
    /// </summary>
    public class SupperMember1:SupperMemberBase
    {
        public SupperMember1()
        {
        }
    }

SupperMember2.cs

/// <summary>
    /// Description of SupperMember2.
    /// </summary>
    public class SupperMember2:SupperMemberBase
    {
        public SupperMember2()
        {
        }
    }

　　3. 调用运行：

class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            
            MemberBO memberBO=new MemberBO("Access");
            memberBO.CreateMember();
            memberBO.CreateSupperMember();
            
            memberBO=new MemberBO("SqlServer");
            memberBO.CreateMember();
            memberBO.CreateSupperMember();            
            
            // TODO: Implement Functionality Here
            
            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
        }
    }

　　4. 输出：

• 优缺点：

优点：推迟了子类的创建，实现多种创建的创建，不在局限于一个类型的产品，更加灵活，对子类的创建进行了封装，代码更有层次，逻辑更加清洗，分工明确；

缺点：封装对性能带来性能影响。