C#设计模式之简单工厂模式（过渡模式） - 可均可可

公告

一、引言

之所以写这个系列，是了为了自己更好的理解设计模式，也为新手提供一些帮助，我都是用最简单的、最生活化的实例来说明。在上一篇文章中讲解了单例模式，今天就给大家讲一个比较简单的模式——简单工厂模式。但是这里要说明的是，这个模式并不属于GoF23里面的设计模式，其实他属于一个过渡的模式，这个模式是为了引出下一篇要将的模式：工厂模式。

二、简单工厂模式的介绍

无论是简单工厂还是复杂工厂，首先它们都是工厂，工厂是干什么的呢？在现实生活中的工厂是负责生产产品的，产品或者可以食用或者可以使用，可以为我们提供功能或者补充能量，这个产品是有用的，真实存在的。那么在面向对象的软件设计中提到的工厂是什么意思呢？既然也是工厂，肯定也是生产东西的，只不过这个东西在这里一定是一个对象的实例，而且这个东西我们可以使用，所以在软件设计中工厂的概念就是指可以生产某个类型对象实例的一个类型。就像我们要吃饼干不用自己做，去超市买就好了，因为有工厂已经把饼干生产好了，生产是工厂的任务，吃是我们自己的事情，两个互不干涉，多好啊。。。在软件设计中，如果以后我们要使用某个类型的实例，就告诉工厂就行，他就会给我们想要的实例对象，具体工厂是怎么生产我们就不用管了，我们也省事了，也就是所谓的解耦了。我们平常编程中，当使用”new”关键字创建一个对象时，此时该类就依赖与这个对象，也就是他们之间的耦合度比较高，当需求变化时，我们就不得不去修改此类的源码，此时我们可以运用面向对象（OO）的很重要的原则去解决这一的问题，该原则就是——封装变化点，既然要封装改变点，自然也就要找到变化的代码，然后把变化的代码用类来封装，这样的一种思路也就是我们简单工厂模式的实现方式了。下面通过一个现实生活中的例子来引出简单工厂模式。

生活中，免不了要经常在外面吃饭，当然我们也可以自己在家做饭吃，但是自己做饭吃麻烦，因为又要自己买菜，然而，出去吃饭就完全没有这些麻烦的，我们只需要到餐馆点菜就可以了，买菜的事情就交给餐馆做就可以了，这里餐馆就充当简单工厂的角色，下面让我们看看现实生活中的例子用代码是怎样来表现的。

自己做饭的情况：

 1     /// <summary>
 2     /// 自己做饭的情况
 3     /// 没有简单工厂，客户想吃什么菜只能自己炒的
 4     /// </summary>
 5     public class Customer
 6     {
 7         /// <summary>
 8         /// 烧菜方法
 9         /// </summary>
10         /// <param name="type"></param>
11         /// <returns></returns>
12         public static Food Cook(string type)
13         {
14             Food food = null;
15             // 客户A说：我想吃西红柿炒蛋怎么办？
16             // 客户B说：那你就自己烧啊
17             // 客户A说： 好吧，那就自己做吧
18             if (type.Equals("西红柿炒蛋"))
19             {
20                 food = new TomatoScrambledEggs();
21             }
22             // 我又想吃土豆肉丝, 这个还是得自己做
23             // 我觉得自己做好累哦，如果能有人帮我做就好了？
24             else if (type.Equals("土豆肉丝"))
25             {
26                 food = new ShreddedPorkWithPotatoes();
27             }
28             return food;
29         }
30  
31         static void Main(string[] args)
32         {
33             // 做西红柿炒蛋
34             Food food1 = Cook("西红柿炒蛋");
35             food1.Print();
36  
37             Food food2 = Cook("土豆肉丝");
38             food1.Print();
39  
40             Console.Read();
41         }
42     }
43     /// <summary>
44     /// 菜抽象类
45     /// </summary>
46     public abstract class Food
47     {
48         // 输出点了什么菜
49         public abstract void Print();
50     }
51  
52     /// <summary>
53     /// 西红柿炒鸡蛋这道菜
54     /// </summary>
55     public class TomatoScrambledEggs : Food
56     {
57         public override void Print()
58         {
59             Console.WriteLine("一份西红柿炒蛋！");
60         }
61     }
62  
63     /// <summary>
64     /// 土豆肉丝这道菜
65     /// </summary>
66     public class ShreddedPorkWithPotatoes : Food
67     {
68         public override void Print()
69         {
70             Console.WriteLine("一份土豆肉丝");
71         }
72     }

自己做饭，如果我们想吃别的菜时，此时就需要去买这种菜和洗菜这些繁琐的操作，有了餐馆（也就是简单工厂）之后，我们就可以把这些操作交给餐馆去做，此时消费者（也就是我们）对菜（也就是具体对象）的依赖关系从直接变成的间接的，这样就是实现了面向对象的另一个原则——降低对象之间的耦合度，下面就具体看看有了餐馆之后的实现代码（即简单工厂的实现）：

 1 /// <summary>
 2     /// 顾客充当客户端，负责调用简单工厂来生产对象
 3     /// 即客户点菜，厨师（相当于简单工厂）负责烧菜(生产的对象)
 4     /// </summary>
 5     class Customer
 6     {
 7         static void Main(string[] args)
 8         {
 9             // 客户想点一个西红柿炒蛋        
10             Food food1 = FoodSimpleFactory.CreateFood("西红柿炒蛋");
11             food1.Print();
12  
13             // 客户想点一个土豆肉丝
14             Food food2 = FoodSimpleFactory.CreateFood("土豆肉丝");
15             food2.Print();
16  
17             Console.Read();
18         }
19     }
20  
21     /// <summary>
22     /// 菜抽象类
23     /// </summary>
24     public abstract class Food
25     {
26         // 输出点了什么菜
27         public abstract void Print();
28     }
29  
30     /// <summary>
31     /// 西红柿炒鸡蛋这道菜
32     /// </summary>
33     public class TomatoScrambledEggs : Food
34     {
35         public override void Print()
36         {
37             Console.WriteLine("一份西红柿炒蛋！");
38         }
39     }
40  
41     /// <summary>
42     /// 土豆肉丝这道菜
43     /// </summary>
44     public class ShreddedPorkWithPotatoes : Food
45     {
46         public override void Print()
47         {
48             Console.WriteLine("一份土豆肉丝");
49         }
50     }
51  
52     /// <summary>
53     /// 简单工厂类, 负责 炒菜
54     /// </summary>
55     public class FoodSimpleFactory
56     {
57         public static Food CreateFood(string type)
58         {
59             Food food = null;
60             if (type.Equals("土豆肉丝"))
61             {
62                 food= new ShreddedPorkWithPotatoes();
63             }
64             else if (type.Equals("西红柿炒蛋"))
65             {
66                 food= new TomatoScrambledEggs();
67             }
68  
69             return food;
70         }
71     }

三、优点与缺点

看完简单工厂模式的实现之后，很多人肯定会有这样的疑惑——我们只是把变化的代码移到了工厂类中罢了，好像没有变化的问题了，如果客户想吃其他菜时，此时我们还是需要修改工厂类中的方法（也就是多加case语句，没应用简单工厂模式之前，修改的是客户类）。我首先要说：大家想的很对，每种设计模式只会解决一种问题，他们有自己的使用场景，没有一种模式可以解决所有问题，这个就是简单工厂模式的缺点所在（这个缺点后面介绍的工厂方法模式可以很好地解决），然而，简单工厂模式与之前的实现也有它的优点：

简单工厂模式解决了客户端直接依赖于具体对象的问题，客户端可以消除直接创建对象的责任，而仅仅是消费产品。简单工厂模式实现了对责任的分割。
简单工厂模式也起到了代码复用的作用，因为之前的实现（自己做饭的情况）中，换了一个人同样要去在自己的类中实现做菜的方法，然后有了简单工厂之后，去餐馆吃饭的所有人都不用那么麻烦了，只需要负责消费就可以了。此时简单工厂的烧菜方法就让所有客户共用了。（同时这点也是简单工厂方法的缺点——因为工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响，也没什么不好理解的，就如事物都有两面性一样道理）

虽然上面已经介绍了简单工厂模式的缺点，下面还是总结下简单工厂模式的缺点：

工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响（通俗地意思就是：一旦餐馆没饭或者关门了，很多不愿意做饭的人就没饭吃了）
系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，这样就会造成工厂逻辑过于复杂。

了解了简单工厂模式之后的优缺点之后，我们之后就可以知道简单工厂的应用场景了：

当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式
客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式

四、简单工厂模式UML图

简单工厂模式在很多时候可以叫静态工厂模式（因为工厂类都定义了一个静态方法），由一个工厂类根据传入的参数决定创建出哪一种产品类的实例（通俗点表达：通过客户下的订单来负责烧那种菜）。简单工厂模式的UML图如下：

如果大家想看源码，源码如下：

  1 public static Encoding GetEncoding(int codepage)
  2         {
  3             Encoding encoding = EncodingProvider.GetEncodingFromProvider(codepage);
  4             if (encoding != null)
  5             {
  6                 return encoding;
  7             }
  8             if (codepage < 0 || codepage > 65535)
  9             {
 10                 throw new ArgumentOutOfRangeException("codepage", Environment.GetResourceString("ArgumentOutOfRange_Range", new object[]
 11                 {
 12                     0,
 13                     65535
 14                 }));
 15             }
 16             if (Encoding.encodings != null)
 17             {
 18                 encoding = (Encoding)Encoding.encodings[codepage];
 19             }
 20             if (encoding == null)
 21             {
 22                 object internalSyncObject = Encoding.InternalSyncObject;
 23                 lock (internalSyncObject)
 24                 {
 25                     if (Encoding.encodings == null)
 26                     {
 27                         Encoding.encodings = new Hashtable();
 28                     }
 29                     if ((encoding = (Encoding)Encoding.encodings[codepage]) != null)
 30                     {
 31                         return encoding;
 32                     }
 33                     if (codepage <= 1201)
 34                     {
 35                         if (codepage <= 42)
 36                         {
 37                             switch (codepage)
 38                             {
 39                             case 0:
 40                                 encoding = Encoding.Default;
 41                                 goto IL_193;
 42                             case 1:
 43                             case 2:
 44                             case 3:
 45                                 break;
 46                             default:
 47                                 if (codepage != 42)
 48                                 {
 49                                     goto IL_182;
 50                                 }
 51                                 break;
 52                             }
 53                             throw new ArgumentException(Environment.GetResourceString("Argument_CodepageNotSupported", new object[]
 54                             {
 55                                 codepage
 56                             }), "codepage");
 57                         }
 58                         if (codepage == 1200)
 59                         {
 60                             encoding = Encoding.Unicode;
 61                             goto IL_193;
 62                         }
 63                         if (codepage == 1201)
 64                         {
 65                             encoding = Encoding.BigEndianUnicode;
 66                             goto IL_193;
 67                         }
 68                     }
 69                     else if (codepage <= 20127)
 70                     {
 71                         if (codepage == 1252)
 72                         {
 73                             encoding = new SBCSCodePageEncoding(codepage);
 74                             goto IL_193;
 75                         }
 76                         if (codepage == 20127)
 77                         {
 78                             encoding = Encoding.ASCII;
 79                             goto IL_193;
 80                         }
 81                     }
 82                     else
 83                     {
 84                         if (codepage == 28591)
 85                         {
 86                             encoding = Encoding.Latin1;
 87                             goto IL_193;
 88                         }
 89                         if (codepage == 65001)
 90                         {
 91                             encoding = Encoding.UTF8;
 92                             goto IL_193;
 93                         }
 94                     }
 95                     IL_182:
 96                     encoding = Encoding.GetEncodingCodePage(codepage);
 97                     if (encoding == null)
 98                     {
 99                         encoding = Encoding.GetEncodingRare(codepage);
100                     }
101                     IL_193:
102                     Encoding.encodings.Add(codepage, encoding);
103                 }
104                 return encoding;
105             }
106             return encoding;
107         }

五、.NET中简单工厂模式的实现

介绍完了简单工厂模式之后，.NET类库中也有类似的实现，NET中System.Text.Encoding类就实现了简单工厂模式，该类中的GetEncoding(int codepage)就是工厂方法，具体的代码可以通过Reflector反编译工具进行查看

.NET 中Encoding的UML图为：

Encoding类中实现的简单工厂模式是简单工厂模式的一种演变，此时简单工厂类由抽象产品角色扮演，然而.NET中Encoding类是如何解决简单工厂模式中存在的问题的呢（即如果新添加一种编码怎么办）？在GetEncoding方法里的switch函数有如下代码：

switch (codepage)
     {
          .......
   default:
                    unicode = GetEncodingCodePage(codepage);
                    if (unicode == null)
                    {
                        unicode = GetEncodingRare(codepage); //当编码很少见时
                    }
                    break;
           ......
      }

在GetEncodingRare方法里有一些不常用编码的实例化代码，微软正式通过这个方法来解决新增加一种编码的问题。（其实也就是列出所有可能的编码情况），微软之所以以这样的方式来解决这个问题，可能是由于现在编码已经稳定了，添加新编码的可能性比较低，所以在.NET 4.5仍然未改动这部分代码。

六、总结

今天就到这里了，简单工厂模式的介绍都到这里了，说起简单工厂，其实是一个很容易的工厂，可能很多人有意或者无意的使用过着模式，模式不要太关注实现细节，要关注模式得出的原因，分析问题的方法。我们一定要好好的记住面向对象设计的原则，然后好好的体会模式之美，理解会更多。

posted on 2017-09-19 13:27 可均可可阅读(2695) 评论(2) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部