（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. 输出：

• 优缺点：

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

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