C#工厂设计模式

来源：互联网发布：c语言数据类型1byte 编辑：程序博客网时间：2024/05/18 03:35

一、引言

在上一专题中介绍了工厂方法模式，工厂方法模式是为了克服简单工厂模式的缺点而设计出来的,简单工厂模式的工厂类随着产品类的增加需要增加额外的代码），而工厂方法模式每个具体工厂类只完成单个实例的创建,所以它具有很好的可扩展性。但是在现实生活中，一个工厂只创建单个产品这样的例子很少，因为现在的工厂都多元化了，一个工厂创建一系列的产品，如果我们要设计这样的系统时，工厂方法模式显然在这里不适用，然后抽象工厂模式却可以很好地解决一系列产品创建的问题,这是本专题所要介绍的内容。

二、抽象工厂详细介绍

这里首先以一个生活中抽象工厂的例子来实现一个抽象工厂，然后再给出抽象工厂的定义和UML图来帮助大家更好地掌握抽象工厂模式，同时大家在理解的时候，可以对照抽象工厂生活中例子的实现和它的定义来加深抽象工厂的UML图理解。

2.1 抽象工厂的具体实现

下面就以生活中 “绝味” 连锁店的例子来实现一个抽象工厂模式。例如，绝味鸭脖想在江西南昌和上海开分店，但是由于当地人的口味不一样，在南昌的所有绝味的东西会做的辣一点，而上海不喜欢吃辣的，所以上海的所有绝味的东西都不会做的像南昌的那样辣，然而这点不同导致南昌绝味工厂和上海的绝味工厂生成所有绝味的产品都不同，也就是某个具体工厂需要负责一系列产品(指的是绝味所有食物)的创建工作，下面就具体看看如何使用抽象工厂模式来实现这种情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/// <summary>
    /// 下面以绝味鸭脖连锁店为例子演示下抽象工厂模式
    /// 因为每个地方的喜欢的口味不一样，有些地方喜欢辣点的，有些地方喜欢吃不辣点
    /// 客户端调用
    /// </summary>
    classClient
    {
        staticvoid Main(string[] args)
        {
            // 南昌工厂制作南昌的鸭脖和鸭架
            AbstractFactory nanChangFactory = newNanChangFactory();
            YaBo nanChangYabo = nanChangFactory.CreateYaBo();
            nanChangYabo.Print();
            YaJia nanChangYajia= nanChangFactory.CreateYaJia();
            nanChangYajia.Print();
 
            // 上海工厂制作上海的鸭脖和鸭架
            AbstractFactory shangHaiFactory = newShangHaiFactory();
            shangHaiFactory.CreateYaBo().Print();
            shangHaiFactory.CreateYaJia().Print();
 
            Console.Read();
        }
    }
 
    /// <summary>
    /// 抽象工厂类，提供创建两个不同地方的鸭架和鸭脖的接口
    /// </summary>
    publicabstract class AbstractFactory
    {
        // 抽象工厂提供创建一系列产品的接口，这里作为例子，只给出了绝味中鸭脖和鸭架的创建接口
        publicabstract YaBo CreateYaBo();
        publicabstract YaJia CreateYaJia();
    }
 
    /// <summary>
    /// 南昌绝味工厂负责制作南昌的鸭脖和鸭架
    /// </summary>
    publicclass NanChangFactory : AbstractFactory
    {
        // 制作南昌鸭脖
        publicoverride YaBo CreateYaBo()
        {
            returnnew NanChangYaBo();
        }
        // 制作南昌鸭架
        publicoverride YaJia CreateYaJia()
        {
            returnnew NanChangYaJia();
        }
    }
 
    /// <summary>
    /// 上海绝味工厂负责制作上海的鸭脖和鸭架
    /// </summary>
    publicclass ShangHaiFactory : AbstractFactory
    {
        // 制作上海鸭脖
        publicoverride YaBo CreateYaBo()
        {
            returnnew ShangHaiYaBo();
        }
        // 制作上海鸭架
        publicoverride YaJia CreateYaJia()
        {
            returnnew ShangHaiYaJia();
        }
    }
 
    /// <summary>
    /// 鸭脖抽象类，供每个地方的鸭脖类继承
    /// </summary>
    publicabstract class YaBo
    {
        /// <summary>
        /// 打印方法，用于输出信息
        /// </summary>
        publicabstract void Print();
    }
 
    /// <summary>
    /// 鸭架抽象类，供每个地方的鸭架类继承
    /// </summary>
    publicabstract class YaJia
    {
        /// <summary>
        /// 打印方法，用于输出信息
        /// </summary>
        publicabstract void Print();
    }
 
    /// <summary>
    /// 南昌的鸭脖类，因为江西人喜欢吃辣的，所以南昌的鸭脖稍微会比上海做的辣
    /// </summary>
    publicclass NanChangYaBo : YaBo
    {
        publicoverride void Print()
        {
            Console.WriteLine("南昌的鸭脖");
        }
    }
 
    /// <summary>
    /// 上海的鸭脖没有南昌的鸭脖做的辣
    /// </summary>
    publicclass ShangHaiYaBo : YaBo
    {
        publicoverride void Print()
        {
            Console.WriteLine("上海的鸭脖");
        }
    }
 
    /// <summary>
    /// 南昌的鸭架
    /// </summary>
    publicclass NanChangYaJia : YaJia
    {
        publicoverride void Print()
        {
            Console.WriteLine("南昌的鸭架子");
        }
    }
 
    /// <summary>
    /// 上海的鸭架
    /// </summary>
    publicclass ShangHaiYaJia : YaJia
    {
        publicoverride void Print()
        {
            Console.WriteLine("上海的鸭架子");
        }
    }

2.2 抽象工厂模式的定义和类图

上面代码中都有详细的注释，这里就不再解释上面的代码了，下面就具体看看抽象工厂模式的定义吧（理解定义可以参考上面的实现来加深理解）：

抽象工厂模式：提供一个创建产品的接口来负责创建相关或依赖的对象，而不具体明确指定具体类

抽象工厂允许客户使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么。这样客户就可以从具体产品中被解耦。下面通过抽象工模式的类图来了解各个类中之间的关系：

2.3 抽象工厂应对需求变更

看完上面抽象工厂的实现之后，如果 “绝味”公司又想在湖南开一家分店怎么办呢？因为湖南人喜欢吃麻辣的，下面就具体看看应用了抽象工厂模式的系统是如何应对这种需求的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/// <summary>
    /// 如果绝味又想开一家湖南的分店时，因为湖南喜欢吃麻的
    /// 所以这是有需要有一家湖南的工厂专门制作
    /// </summary>
    publicclass HuNanFactory : AbstractFactory
    {
        // 制作湖南鸭脖
        publicoverride YaBo CreateYaBo()
        {
            returnnew HuNanYaBo();
        }
 
        // 制作湖南鸭架
        publicoverride YaJia CreateYaJia()
        {
            returnnew HuNanYajia();
        }
    }
 
    /// <summary>
    /// 湖南的鸭脖
    /// </summary>
    publicclass HuNanYaBo : YaBo
    {
        publicoverride void Print()
        {
            Console.WriteLine("湖南的鸭脖");
        }
    }
 
    /// <summary>
    /// 湖南的鸭架
    /// </summary>
    publicclass HuNanYajia : YaJia
    {
        publicoverride void Print()
        {
            Console.WriteLine("湖南的鸭架子");
        }
    }

此时，只需要添加三个类：一个是湖南具体工厂类，负责创建湖南口味的鸭脖和鸭架，另外两个类是具有湖南口味的鸭脖类和鸭架类。从上面代码看出，抽象工厂对于系列产品的变化支持 “开放——封闭”原则（指的是要求系统对扩展开放，对修改封闭），扩展起来非常简便，但是，抽象工厂对于添加新产品这种情况就不支持”开放——封闭 “原则，这也是抽象工厂的缺点所在，这点会在第四部分详细介绍。

三、抽象工厂的分析

抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展，这真是抽象工厂模式的优点所在，然后抽象模式同时也存在不足的地方。下面就具体看下抽象工厂的缺点（缺点其实在前面的介绍中以已经涉及了）：

抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则。

知道了抽象工厂的优缺点之后，也就能很好地把握什么情况下考虑使用抽象工厂模式了，下面就具体看看使用抽象工厂模式的系统应该符合那几个前提：

一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。
这个系统有多个系列产品，而系统中只消费其中某一系列产品
系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。

0 0