C#設計模式之簡單工廠模式（過渡模式）

時間 2019-11-10

標籤 c# 設計模式簡單工廠過渡欄目 C# 简体版

原文原文鏈接

1、引言

之因此寫這個系列，是了爲了本身更好的理解設計模式，也爲新手提供一些幫助，我都是用最簡單的、最生活化的實例來講明。在上一篇文章中講解了單例模式，今天就給你們講一個比較簡單的模式——簡單工廠模式。可是這裏要說明的是，這個模式並不屬於GoF23裏面的設計模式，其實他屬於一個過渡的模式，這個模式是爲了引出下一篇要將的模式：工廠模式。編程

2、簡單工廠模式的介紹

不管是簡單工廠仍是複雜工廠，首先它們都是工廠，工廠是幹什麼的呢？在現實生活中的工廠是負責生產產品的，產品或者能夠食用或者可使用，能夠爲咱們提供功能或者補充能量，這個產品是有用的，真實存在的。那麼在面向對象的軟件設計中提到的工廠是什麼意思呢？既然也是工廠，確定也是生產東西的，只不過這個東西在這裏必定是一個對象的實例，並且這個東西咱們可使用，因此在軟件設計中工廠的概念就是指能夠生產某個類型對象實例的一個類型。就像咱們要吃餅乾不用本身作，去超市買就行了，由於有工廠已經把餅乾生產好了，生產是工廠的任務，吃是咱們本身的事情，兩個互不干涉，多好啊。。。在軟件設計中，若是之後咱們要使用某個類型的實例，就告訴工廠就行，他就會給咱們想要的實例對象，具體工廠是怎麼生產咱們就不用管了，咱們也省事了，也就是所謂的解耦了。咱們日常編程中，當使用」new」關鍵字建立一個對象時，此時該類就依賴與這個對象，也就是他們之間的耦合度比較高，當需求變化時，咱們就不得不去修改此類的源碼，此時咱們能夠運用面向對象（OO）的很重要的原則去解決這一的問題，該原則就是——封裝變化點，既然要封裝改變點，天然也就要找到變化的代碼，而後把變化的代碼用類來封裝，這樣的一種思路也就是咱們簡單工廠模式的實現方式了。下面經過一個現實生活中的例子來引出簡單工廠模式。設計模式

生活中，免不了要常常在外面吃飯，固然咱們也能夠本身在家作飯吃，可是本身作飯吃麻煩，由於又要本身買菜，然而，出去吃飯就徹底沒有這些麻煩的，咱們只須要到餐館點菜就能夠了，買菜的事情就交給餐館作就能夠了，這裏餐館就充當簡單工廠的角色，下面讓咱們看看現實生活中的例子用代碼是怎樣來表現的。ide

本身作飯的狀況：函數

 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     }

3、優勢與缺點

看完簡單工廠模式的實現以後，不少人確定會有這樣的疑惑——咱們只是把變化的代碼移到了工廠類中罷了，好像沒有變化的問題了，若是客戶想吃其餘菜時，此時咱們仍是須要修改工廠類中的方法（也就是多加case語句，沒應用簡單工廠模式以前，修改的是客戶類）。我首先要說：你們想的很對，每種設計模式只會解決一種問題，他們有本身的使用場景，沒有一種模式能夠解決全部問題，這個就是簡單工廠模式的缺點所在（這個缺點後面介紹的工廠方法模式能夠很好地解決），然而，簡單工廠模式與以前的實現也有它的優勢：編碼

簡單工廠模式解決了客戶端直接依賴於具體對象的問題，客戶端能夠消除直接建立對象的責任，而僅僅是消費產品。簡單工廠模式實現了對責任的分割。
簡單工廠模式也起到了代碼複用的做用，由於以前的實現（本身作飯的狀況）中，換了一我的一樣要去在本身的類中實現作菜的方法，而後有了簡單工廠以後，去餐館吃飯的全部人都不用那麼麻煩了，只須要負責消費就能夠了。此時簡單工廠的燒菜方法就讓全部客戶共用了。（同時這點也是簡單工廠方法的缺點——由於工廠類集中了全部產品建立邏輯，一旦不能正常工做，整個系統都會受到影響，也沒什麼很差理解的，就如事物都有兩面性同樣道理）

雖然上面已經介紹了簡單工廠模式的缺點，下面仍是總結下簡單工廠模式的缺點：spa

工廠類集中了全部產品建立邏輯，一旦不能正常工做，整個系統都會受到影響（通俗地意思就是：一旦餐館沒飯或者關門了，不少不肯意作飯的人就沒飯吃了）
系統擴展困難，一旦添加新產品就不得不修改工廠邏輯，這樣就會形成工廠邏輯過於複雜。

瞭解了簡單工廠模式以後的優缺點以後，咱們以後就能夠知道簡單工廠的應用場景了：設計

當工廠類負責建立的對象比較少時能夠考慮使用簡單工廠模式
客戶若是隻知道傳入工廠類的參數，對於如何建立對象的邏輯不關心時能夠考慮使用簡單工廠模式

4、簡單工廠模式UML圖

簡單工廠模式在不少時候能夠叫靜態工廠模式（由於工廠類都定義了一個靜態方法），由一個工廠類根據傳入的參數決定建立出哪種產品類的實例（通俗點表達：經過客戶下的訂單來負責燒那種菜）。簡單工廠模式的UML圖以下：

若是你們想看源碼，源碼以下：code

  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         }

5、.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仍然未改動這部分代碼。