C#设计模式之三抽象工厂模式(AbstractFactory)【创建型】

简介: 原文:C#设计模式之三抽象工厂模式(AbstractFactory)【创建型】一、引言     写了3篇有关设计模式的文章了,大家有了些反馈,说能从中学到一些东西,我感到很欣慰,那就继续努力。今天我要写第四个模式了,该模式叫抽象工厂。
原文: C#设计模式之三抽象工厂模式(AbstractFactory)【创建型】

一、引言

     写了3篇有关设计模式的文章了,大家有了些反馈,说能从中学到一些东西,我感到很欣慰,那就继续努力。今天我要写第四个模式了,该模式叫抽象工厂。上一篇文章我们讲了【工厂方法】模式,它是为了解决【简单工厂】模式所面对的问题,它的问题就是:如果我们增加新的产品,工厂类的方法就要修改本身的代码,增加产品越多,其逻辑越复杂,同时这样的修改也是不符合【开放关闭原则OCP】,对修改代码关闭,对增加代码开放。为了解决【简单工厂】的问题,我们引出了【工厂方法】模式,通过子类化工厂类,解决了工厂类责任的划分,产品和相应的工厂一一对应,符合了OCP。如果我们要设计一套房子,当然我们知道房子是由房顶、地板、窗户、房门组成的,别的组件暂时省略,先设计一套古典风格的房子,再创建一套现代风格的房子,再创建一套欧式风格的房子,这么多套房子,我们该怎么办呢?今天我们要讲的【抽象工厂】模式可以很好的解决多套变化的问题。

二、抽象工厂详细介绍

  2.1、动机(Motivate):

     在软件系统中,经常面临着"一系统相互依赖的对象"的创建工作:同时,由于需求的变化,往往存在更多系列对象的创建工作。如何应对这种变化?如何绕过常规的对象创建方法(new),提供一种"封装机制"来避免客户程序和这种"多系列具体对象创建工作"的紧耦合?

  2.2、意图(Intent):

    提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。                            ——《设计模式》GoF

  2.3、结构图(Structure)

   

   该图是抽象工厂的UML图,结合抽象工厂的意图、动机和图示来理解该模式,今天我们就以建设房子为例来说明抽象工厂的实现机理。

2.4、模式的组成

      可以看出,在抽象工厂模式的结构图有以下角色:

      (1)、抽象产品类角色(AbstractProduct):为抽象工厂中相互依赖的每种产品定义抽象接口对象,也可以这样说,有几种产品,就要声明几个抽象角色,每一个抽象产品角色和一种具体的产品相匹配。

      (2)、具体产品类(ConcreteProduct):具体产品类实现了抽象产品类,是针对某个具体产品的实现的类型。

      (3)、抽象工厂类角色(Abstract Factory):定义了创建一组相互依赖的产品对象的接口操作,每种操作和每种产品一一对应。

      (4)、具体工厂类角色(ConcreteFactory):实现抽象类里面的所有抽象接口操作,可以创建某系列具体的产品,这些具体的产品是“抽象产品类角色”的子类。


2.5、抽象工厂的具体代码实现

       随着我们年龄的增大,我们也到了结婚的年龄。结婚首要的问题就是房子的问题,假设我有一个很有钱的爸爸,哈哈,有钱可以解决很多问题。作为长子的我,希望能有一套欧式风格的房子,再加上田园风光,此生足矣。我弟弟就不一样了,他想要一套现代样式的房子,如果兄弟姊妹再多年一点,那就有更多的要求了。由于房子由房顶、地板、窗户和房门组成,其他组件暂时省略,有这么多套房子要建设,每套房子的房顶、地板、窗户和房门都是一个体系的,那就让我们看看如何使用【抽象工厂】模式来实现不同房屋的建造。

  1          /// <summary>
  2         /// 下面以不同系列房屋的建造为例子演示抽象工厂模式
  3         /// 因为每个人的喜好不一样,我喜欢欧式的,我弟弟就喜欢现代的
  4         /// 客户端调用
  5         /// </summary>
  6         class Client
  7         {
  8             static void Main(string[] args)
  9             {
 10                // 哥哥的欧式风格的房子
 11                AbstractFactory europeanFactory= new EuropeanFactory();
 12                europeanFactory.CreateRoof().Create();
 13                europeanFactory.CreateFloor().Create();
 14                europeanFactory.CreateWindow().Create();
 15                europeanFactory.CreateDoor().Create(); 
 16 
 17    
 18                //弟弟的现代风格的房子
 19                AbstractFactory modernizationFactory = new ModernizationFactory();
 20                modernizationFactory.CreateRoof().Create();
 21                modernizationFactory.CreateFloor().Create();
 22                modernizationFactory.CreateWindow().Create();
 23                modernizationFactory.CreateDoor().Create();
 24                Console.Read();
 25           }
 26     }
 27    
 28       /// <summary>
 29       /// 抽象工厂类,提供创建不同类型房子的接口
 30      /// </summary>
 31       public abstract class AbstractFactory
 32      {
 33          // 抽象工厂提供创建一系列产品的接口,这里作为例子,只给出了房顶、地板、窗户和房门创建接口
 34          public abstract Roof CreateRoof();
 35          public abstract Floor CreateFloor();
 36          public abstract Window CreateWindow();
 37          public abstract Door CreateDoor();
 38      }
 39   
 40      /// <summary>
 41     /// 欧式风格房子的工厂,负责创建欧式风格的房子
 42     /// </summary>
 43     public class EuropeanFactory : AbstractFactory
 44     {
 45          // 制作欧式房顶
 46          public override Roof CreateRoof()
 47          {
 48               return new EuropeanRoof();
 49           }
 50   
 51          // 制作欧式地板
 52          public override Floor CreateFloor()
 53          {
 54              return new EuropeanFloor();
 55          }
 56  
 57         // 制作欧式窗户
 58         public override Window CreateWindow()
 59         {
 60              return new EuropeanWindow();
 61         }
 62  
 63         // 制作欧式房门
 64         public override Door CreateDoor()
 65         {
 66              return new EuropeanDoor();
 67          }
 68     }
 69   
 70      /// <summary>
 71     /// 现在风格房子的工厂,负责创建现代风格的房子
 72     /// </summary>
 73     public class ModernizationFactory : AbstractFactory
 74     {
 75          // 制作现代房顶
 76         public override Roof CreateRoof()
 77         {
 78              return new ModernizationRoof();
 79          }
 80 
 81         // 制作现代地板
 82        public override Floor CreateFloor()
 83        {
 84             return new ModernizationFloor();
 85        }
 86  
 87        // 制作现代窗户
 88       public override Window CreateWindow()
 89       {
 90            return new ModernizationWindow();
 91       }
 92  
 93       // 制作现代房门
 94      public override Door CreateDoor()
 95      {
 96            return new ModernizationDoor();
 97       }
 98   }
 99    
100     /// <summary>
101     /// 房顶抽象类,子类的房顶必须继承该类
102    /// </summary>
103    public abstract class Roof
104     {
105          /// <summary>
106         /// 创建房顶
107        /// </summary>
108        public abstract void Create();
109    }
110   
111    /// <summary>
112   /// 地板抽象类,子类的地板必须继承该类
113   /// </summary>
114   public abstract class Floor
115    {
116         /// <summary>
117        /// 创建地板
118       /// </summary>
119      public abstract void Create();
120   }
121   
122    /// <summary>
123   /// 窗户抽象类,子类的窗户必须继承该类
124   /// </summary>
125    public abstract class Window
126     {
127         /// <summary>
128        /// 创建窗户
129       /// </summary>
130       public abstract void Create();
131    }
132  
133    /// <summary>
134    /// 房门抽象类,子类的房门必须继承该类
135    /// </summary>
136    public abstract class Door
137     {
138         /// <summary>
139        /// 创建房门
140       /// </summary>
141       public abstract void Create();
142    }
143   
144    /// <summary>
145   /// 欧式地板类
146   /// </summary>
147   public class EuropeanFloor : Floor
148    {
149       public override void Create()
150      {
151           Console.WriteLine("创建欧式的地板");
152      }
153   }
154   
155   
156     /// <summary>
157    /// 欧式的房顶
158    /// </summary>
159    public class EuropeanRoof : Roof
160     {
161          public override void Create()
162         {
163             Console.WriteLine("创建欧式的房顶");
164         }
165     }
166   
167  
168     /// <summary>
169     ///欧式的窗户
170     /// </summary>
171     public class EuropeanWindow : Window
172      {
173          public override void Create()
174          {
175              Console.WriteLine("创建欧式的窗户");
176          }
177     }
178   
179   
180      /// <summary>
181     /// 欧式的房门
182    /// </summary>
183     public class EuropeanDoor : Door
184      {
185         public override void Create()
186         {
187             Console.WriteLine("创建欧式的房门");
188         }
189     }
190  
191      /// <summary>
192     /// 现代的房顶
193     /// </summary>
194     public class ModernizationRoof : Roof
195      {
196          public override void Create()
197         {
198              Console.WriteLine("创建现代的房顶");
199         }
200     }
201  
202     /// <summary>
203     /// 现代的地板
204    /// </summary>
205     public class ModernizationFloor : Floor
206     {
207         public override void Create()
208         {
209              Console.WriteLine("创建现代的地板");
210         }
211     }
212       
213     /// <summary>
214     /// 现代的窗户
215    /// </summary>
216    public class ModernizationWindow : Window
217    {
218           public override void Create()
219          {
220               Console.WriteLine("创建现代的窗户");
221          }
222     }
223  
224     /// <summary>
225     /// 现代的房门
226    /// </summary>
227    public class ModernizationDoor : Door
228     {
229         public override void Create()
230         {
231             Console.WriteLine("创建现代的房门");
232         }
233     }


2.6、 抽象工厂应对需求变更

  让我们看看该模式如何应对需求的变化,假设我的表弟一看我们的房子很好,他也想要一套古典风格的房子(哈哈,这个家伙事挺多的,有好事总是落不下他)。

 1     /// <summary>
 2     ///先为表弟的房子来建立一个工厂类吧
 3     /// </summary>
 4     public class ClassicalFactory : AbstractFactory
 5     {
 6         //创建房顶
 7         public override Roof CreateRoof()
 8         {
 9             return new  ClassicalRoof();
10         }
11 
12         // 创建地板
13         public override Floor CreateFloor()
14         {
15             return new  ClassicalFloor();
16         }
17 
18         // 创建窗户
19         public override Window CreateWindow()
20         {
21             return new  ClassicalWindow();
22         }
23 
24         // 创建房门
25         public override Door CreateDoor()
26         {
27             return new  ClassicalDoor();
28         }
29     }
30 
31     /// <summary>
32     ///古典的房顶
33     /// </summary>
34     public class  ClassicalRoof : Roof
35     {
36         public override void Create()
37         {
38             Console.WriteLine("创建古典的房顶");
39         }
40     }
41 
42     /// <summary>
43     /// 古典的地板
44     /// </summary>
45     public class  ClassicalFloor : Floor
46     {
47         public override void Create()
48         {
49             Console.WriteLine("创建古典的地板");
50         }
51     }
52  
53     /// <summary>
54     /// 古典的窗户
55     /// </summary>
56     public class  ClassicalWindow : Window
57     {
58         public override void Create()
59         {
60             Console.WriteLine("创建古典的窗户");
61         }
62     }
63  
64     /// <summary>
65     /// 古典的房门
66     /// </summary>
67     public class  ClassicalDoor: Door
68     {
69         public override void Create()
70         {
71             Console.WriteLine("创建古典的房门");
72         }
73     }


  此时,只需要添加五个类:一个是古典风格工厂类,负责创建古典风格的房子,另外几个类是具有古典风格的房顶、地板、窗户和房门的具体产品。从上面代码看出,抽象工厂对于系列产品的变化支持 “开放——封闭”原则(指的是要求系统对扩展开放,对修改封闭),扩展起来非常简便,但是,抽象工厂对于增加新产品这种情况就不支持”开放——封闭 “原则,因为要修改创建系列产品的抽象基类AbstractFactory,增加相应产品的创建方法,这也是抽象工厂的缺点所在。

三、抽象工厂的实现要点

     1、如果没有应对“多系列对象创建”的需求变化,则没有必要使用AbstractFactory模式,这时候使用简单的静态工厂完全可以。

      2、"系列对象"指的是这些对象之间有相互依赖、或作用的关系,例如游戏开发场景中“道路”与“房屋”的依赖,“道路”与“地道”的依赖。

      3、AbstractFactory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

      4、AbstractFactory模式经常喝FactoryMethod模式共同组合来应对“对象创建”的需求变化。

    3.1】、抽象工厂模式的优点:【抽象工厂】模式将系列产品的创建工作延迟到具体工厂的子类中,我们声明工厂类变量的时候是使用的抽象类型,同理,我们使用产品类型也是抽象类型,这样做就尽可能的可以减少客户端代码与具体产品类之间的依赖,从而降低了系统的耦合度。耦合度降低了,对于后期的维护和扩展就更有利,这也就是【抽象工厂】模式的优点所在。可能有人会说在Main方法里面(这里的代码就是客户端的使用方)还是会使用具体的工厂类,对的。这个其实我们通过Net的配置,把这部分移出去,最后把依赖关系放到配置文件中。如果有新的需求我们只需要修改配置文件,根本就不需要修改代码了,让客户代码更稳定。依赖关系肯定会存在,我们要做的就是降低依赖,想完全去除很难,也不现实。

   3.2】、抽象工厂模式的缺点:有优点肯定就有缺点,因为每种模式都有他的使用范围,或者说要解决的问题,不能解决的问题就是缺点了,其实也不能叫缺点了。【抽象工厂】模式很难支持增加新产品的变化,这是因为抽象工厂接口中已经确定了可以被创建的产品集合,如果需要添加新产品,此时就必须去修改抽象工厂的接口,这样就涉及到抽象工厂类的以及所有子类的改变,这样也就违背了“开发——封闭”原则。

   3.3】、抽象工厂模式的使用场景:   如果系统需要多套的代码解决方案,并且每套的代码方案中又有很多相互关联的产品类型,并且在系统中我们可以相互替换的使用一套产品的时候可以使用该模式,客户端不需要依赖具体实现。

四、.NET中抽象工厂模式实现

微软的类库发展了这么多年,设计模式在里面有大量的应用,【抽象工厂】模式在.NET类库中也存在着大量的使用,比如和操作数据库有关的类型,这个类就是System.Data.Common.DbProviderFactory,这个类位于System.Data.dll程序集中。该类扮演抽象工厂模式中抽象工厂的角色,我们可以用ILSpy反编译工具查看该类的实现:

/// 扮演抽象工厂的角色
/// 创建连接数据库时所需要的对象集合,
/// 这个对象集合包括有 DbConnection对象(这个是抽象产品类,如绝味例子中的YaBo类)、DbCommand类、DbDataAdapter类,针对不同的具体工厂都需要实现该抽象类中方法,

 1 public abstract class DbProviderFactory
 2     {
 3         public virtual bool CanCreateDataSourceEnumerator
 4         {
 5             get
 6             {
 7                 return false;
 8             }
 9         }
10 
11         public virtual DbCommand CreateCommand()
12         {
13             return null;
14         }
15 
16         public virtual DbCommandBuilder CreateCommandBuilder()
17         {
18             return null;
19         }
20 
21         public virtual DbConnection CreateConnection()
22         {
23             return null;
24         }
25 
26         public virtual DbConnectionStringBuilder CreateConnectionStringBuilder()
27         {
28             return null;
29         }
30 
31         public virtual DbDataAdapter CreateDataAdapter()
32         {
33             return null;
34         }
35 
36         public virtual DbParameter CreateParameter()
37         {
38             return null;
39         }
40 
41         public virtual CodeAccessPermission CreatePermission(PermissionState state)
42         {
43             return null;
44         }
45 
46         public virtual DbDataSourceEnumerator CreateDataSourceEnumerator()
47         {
48             return null;
49         }
50     }
51 }


DbProviderFactory类是一个抽象工厂类,该类提供了创建数据库连接时所需要的对象集合的接口,实际创建的工作在其子类工厂中进行,微软使用的是SQL Server数据库,因此提供了连接SQL Server数据的具体工厂实现,具体代码可以用反编译工具查看,具体代码如下:

SqlClientFactory扮演着具体工厂的角色,用来创建连接SQL Server数据所需要的对象

 1 public sealed class SqlClientFactory : DbProviderFactory, IServiceProvider
 2     {
 3         public static readonly SqlClientFactory Instance = new SqlClientFactory();
 4 
 5         public override bool CanCreateDataSourceEnumerator
 6         {
 7             get
 8             {
 9                 return true;
10             }
11         }
12 
13         private SqlClientFactory()
14         {
15         }
16 
17         public override DbCommand CreateCommand()
18         {
19             return new SqlCommand();
20         }
21 
22         public override DbCommandBuilder CreateCommandBuilder()
23         {
24             return new SqlCommandBuilder();
25         }
26 
27         public override DbConnection CreateConnection()
28         {
29             return new SqlConnection();
30         }
31 
32         public override DbConnectionStringBuilder CreateConnectionStringBuilder()
33         {
34             return new SqlConnectionStringBuilder();
35         }
36 
37         public override DbDataAdapter CreateDataAdapter()
38         {
39             return new SqlDataAdapter();
40         }
41 
42         public override DbParameter CreateParameter()
43         {
44             return new SqlParameter();
45         }
46 
47         public override CodeAccessPermission CreatePermission(PermissionState state)
48         {
49             return new SqlClientPermission(state);
50         }
51 
52         public override DbDataSourceEnumerator CreateDataSourceEnumerator()
53         {
54             return SqlDataSourceEnumerator.Instance;
55         }
56 
57         object IServiceProvider.GetService(Type serviceType)
58         {
59             object result = null;
60             if (serviceType == GreenMethods.SystemDataCommonDbProviderServices_Type)
61             {
62                 result = GreenMethods.SystemDataSqlClientSqlProviderServices_Instance();
63             }
64             return result;
65         }
66     }

OdbcFactory也是具体工厂类

 1 public sealed class OdbcFactory : DbProviderFactory
 2     {
 3         public static readonly OdbcFactory Instance = new OdbcFactory();
 4 
 5         private OdbcFactory()
 6         {
 7         }
 8 
 9         public override DbCommand CreateCommand()
10         {
11             return new OdbcCommand();
12         }
13 
14         public override DbCommandBuilder CreateCommandBuilder()
15         {
16             return new OdbcCommandBuilder();
17         }
18 
19         public override DbConnection CreateConnection()
20         {
21             return new OdbcConnection();
22         }
23 
24         public override DbConnectionStringBuilder CreateConnectionStringBuilder()
25         {
26             return new OdbcConnectionStringBuilder();
27         }
28 
29         public override DbDataAdapter CreateDataAdapter()
30         {
31             return new OdbcDataAdapter();
32         }
33 
34         public override DbParameter CreateParameter()
35         {
36             return new OdbcParameter();
37         }
38 
39         public override CodeAccessPermission CreatePermission(PermissionState state)
40         {
41             return new OdbcPermission(state);
42         }
43     }

当然,我们也有OleDbFactory 类型,都是负责具体的数据库操作。DbProviderFactory就是【抽象工厂】模式UML里面AbstractFactory类型。其他具体的工厂类型继承DbProviderFactory类型,这个结构很简单,我就不画图了。

五、总结

   终于写完了,写了3个小时,学习设计模式不能死学,要把握核心点和使用场景。关键点第一是,面向对象设计模式的基本原则,有了原则,考虑问题就不会跑偏,然后再仔细把握每种模式的使用场景和要解决的问题,多写写代码,多看看Net的类库,它是最好的教材。

目录
相关文章
|
4月前
|
设计模式
**工厂模式与抽象工厂模式**都是创建型设计模式,用于封装对象创建,减少耦合
【6月更文挑战第23天】**工厂模式与抽象工厂模式**都是创建型设计模式,用于封装对象创建,减少耦合。工厂模式专注于单个对象,通过具体工厂创建具体产品,适用于简单对象创建;抽象工厂则关注一系列相关产品,提供创建一族对象的接口,适用于处理多个不兼容产品族。选择模式基于问题域的复杂性,单个产品需求时用工厂模式,多产品族时用抽象工厂模式。
30 5
|
5月前
|
设计模式 Java
【设计模式】JAVA Design Patterns——Abstract Factory(抽象工厂模式)
【设计模式】JAVA Design Patterns——Abstract Factory(抽象工厂模式)
|
18天前
|
设计模式 Java
Java设计模式-抽象工厂模式(5)
Java设计模式-抽象工厂模式(5)
|
5月前
|
设计模式 Java
Java一分钟之-设计模式:工厂模式与抽象工厂模式
【5月更文挑战第17天】本文探讨了软件工程中的两种创建型设计模式——工厂模式和抽象工厂模式。工厂模式提供了一个创建对象的接口,延迟实例化到子类决定。过度使用或违反单一职责原则可能导致问题。代码示例展示了如何创建形状的工厂。抽象工厂模式则用于创建一系列相关对象,而不指定具体类,但添加新产品可能需修改现有工厂。代码示例展示了创建颜色和形状的工厂。根据需求选择模式,注意灵活性和耦合度。理解并恰当运用这些模式能提升代码质量。
57 2
|
1月前
|
设计模式 C# 开发者
C#设计模式入门实战教程
C#设计模式入门实战教程
|
2月前
|
设计模式 Java
Java 设计模式之谜:工厂模式与抽象工厂模式究竟隐藏着怎样的神奇力量?
【8月更文挑战第30天】在Java编程中,设计模式为常见问题提供了高效解决方案。工厂模式与抽象工厂模式是常用的对象创建型设计模式,能显著提升代码的灵活性、可维护性和可扩展性。工厂模式通过定义创建对象的接口让子类决定实例化哪个类;而抽象工厂模式则进一步提供了一个创建一系列相关或相互依赖对象的接口,无需指定具体类。这种方式使得系统更易于扩展和维护。
33 1
|
2月前
|
设计模式 算法 C#
C#设计模式之策略模式
C#设计模式之策略模式
76 19
|
2月前
|
设计模式 XML 存储
【三】设计模式~~~创建型模式~~~抽象工厂模式(Java)
文章详细介绍了抽象工厂模式,这是一种创建型设计模式,用于提供一个接口以创建一系列相关或相互依赖的对象,而不指定它们具体的类。通过代码示例和结构图,文章展示了抽象工厂模式的动机、定义、结构、优点、缺点以及适用场景,并探讨了如何通过配置文件和反射机制实现工厂的动态创建。
【三】设计模式~~~创建型模式~~~抽象工厂模式(Java)
|
2月前
|
设计模式 Java C语言
设计模式-----------工厂模式之抽象工厂模式(创建型)
抽象工厂模式是一种创建型设计模式,它提供了一个接口用于创建一系列相关或相互依赖的对象,而无需指定具体类,从而增强了程序的可扩展性并确保客户端只使用同一产品族的产品。
设计模式-----------工厂模式之抽象工厂模式(创建型)
|
2月前
|
设计模式 存储 XML
[设计模式]创建型模式-抽象工厂模式
[设计模式]创建型模式-抽象工厂模式