工廠模式作為很常見的設(shè)計模式，在日常工作中出鏡率非常高，程序員們一定要掌握它的用法喲，今天跟著老胡一起來看看吧。

舉個例子

現(xiàn)在先讓我們來看一個例子吧，比如，要開發(fā)一個簡單的計算器，完成加減功能，通過命令行讀入形如1+1的公式，輸出2這個結(jié)果，讓我們看看怎么實現(xiàn)吧。

第一個版本

這個版本里面，我們不考慮使用模式，就按照最簡單的結(jié)構(gòu)，怎么方便怎么來。

思路非常簡單，僅需要實現(xiàn)以下幾個方法

• 取運(yùn)算數(shù)
• 取運(yùn)算符
• 輸出結(jié)果

  class Program
 {
  static int GetOperatorIndex(string input)
  {
   int operatorIndex = 0;
   for (; operatorIndex < input.Length; operatorIndex++)
   {
    if (!char.IsDigit(input[operatorIndex]))
     break;
   }
   return operatorIndex;
  }

  static int GetOp(string input, int startIndex, int size = -1)
  {
   string subStr;
   if (size == -1)
   {
    subStr = input.Substring(startIndex);
   }
   else
   {
    subStr = input.Substring(startIndex, size);
   }
   return int.Parse(subStr);
  }

  static int CalculateExpression(string input)
  {
   var operatorIndex = GetOperatorIndex(input); //得到運(yùn)算符索引
   var op1 = GetOp(input, 0, operatorIndex); //得到運(yùn)算數(shù)1
   var op2 = GetOp(input, operatorIndex + 1); //得到運(yùn)算數(shù)2
   switch (input[operatorIndex])
   {
    case '+':
     return op1 + op2;
    case '-':
     return op1 - op2;
    default:
     throw new Exception("not support");
   }
  }

  static void Main(string[] args)
  {
   string input = Console.ReadLine();
   while(!string.IsNullOrEmpty(input))
   {
    var result = CalculateExpression(input);
    Console.WriteLine("={0}", result);
    input = Console.ReadLine();
   }   
  }
}

代碼非常簡單，毋庸置疑，這個運(yùn)算器是可以正常工作的。這也可能是我們大部分人剛剛踏上工作崗位的時候可能會寫出的代碼。但它有著以下這些缺點：

• 缺乏起碼的抽象，至少加和減應(yīng)該能抽象出操作類。
• 缺乏抽象造成了巨型客戶端，所有的邏輯都嵌套在了客戶端里面。
• 使用switch case缺乏擴(kuò)展性，同時switch case也暗指了這部分代碼是屬于變化可能性比較高的地方，我們應(yīng)該把它們封裝起來。而且不能把他們放在和客戶端代碼一起
  

接下來，我們引入我們的主題，工廠方法模式。

工廠方法模式版本

工廠方法模式使用一個虛擬的工廠來完成產(chǎn)品構(gòu)建（在這里是運(yùn)算符的構(gòu)建，因為運(yùn)算符是我們這個程序中最具有變化的部分），通過把可變化的部分封裝在工廠類中以達(dá)到隔離變化的目的。我們看看UML圖：

依葫蘆畫瓢，我們設(shè)計思路如下：

• 設(shè)計一個IOperator接口，對應(yīng)抽象的Product
• 設(shè)計AddOperator和SubtractOperator，對應(yīng)具體Product
• 設(shè)計IOperatorFactory接口生產(chǎn)Operator
• 設(shè)計OperatorFactory實現(xiàn)抽象IFactory
  

關(guān)鍵代碼如下，其他讀取操作數(shù)之類的代碼就不在贅述。

• IOperator接口

    interface IOperator
    {
     int Calculate(int op1, int p2);
    }

• 具體Operator

  	class AddOperator : IOperator
    {
     public int Calculate(int op1, int op2)
     {
      return op1 + op2;
     }
    }
  
    class SubtractOperator : IOperator
    {
     public int Calculate(int op1, int op2)
     {
      return op1 - op2;
     }
    }

• Factory接口

  	interface IOperatorFactory
    {
     IOperator CreateOperator(char c);
    }

• 具體Factory

  	class OperatorFactory : IOperatorFactory
    {
     public IOperator CreateOperator(char c)
     {
      switch(c)
      {
       case '+':
        return new AddOperator();
       case '-':
        return new SubtractOperator();
       default:
        throw new Exception("Not support");
      }
     }
    }

• 在CalculateExpression里面使用他們

   static IOperator GetOperator(string input, int operatorIndex)
    {
     IOperatorFactory f = new OperatorFactory();
     return f.CreateOperator(input[operatorIndex]);
    }
  
    static int CalculateExpression(string input)
    {
     var operatorIndex = GetOperatorIndex(input);
     var op1 = GetOp(input, 0, operatorIndex);
     var op2 = GetOp(input, operatorIndex + 1);
     IOperator op = GetOperator(input, operatorIndex);
     return op.Calculate(op1, op2);     
    }

這樣，我們就用工廠方法重新寫了一次計算器，現(xiàn)在看看，好處有

• 容易變化的創(chuàng)建部分被工廠封裝了起來，工廠和客戶端以接口的形式依賴，工廠內(nèi)部邏輯可以隨時變化而不用擔(dān)心影響客戶端代碼
• 工廠部分可以放在另外一個程序集，項目規(guī)劃會更加合理
• 客戶端僅僅需要知道工廠和抽象的產(chǎn)品類，不需要再知道每一個具體的產(chǎn)品（不需要知道如何構(gòu)建每一個具體運(yùn)算符），符合迪米特法則
• 擴(kuò)展性增強(qiáng)，如果之后需要添加乘法multiple，那么僅需要添加一個Operator類代表Multiple并且修改Facotry里面的生成Operator邏輯就可以了，不會影響到客戶端

自此，我們已經(jīng)在代碼里面實現(xiàn)了工廠方法模式，但可能有朋友就會想，雖然現(xiàn)在擴(kuò)展性增強(qiáng)了，但是新添加運(yùn)算符還是需要修改已有的工廠，這不是違反了開閉原則么。。有沒有更好的辦法呢？當(dāng)然是有的。

反射版本

想想工廠方法那個版本，我們?yōu)槭裁丛黾有碌倪\(yùn)算符就會不可避免的修改現(xiàn)有工廠？原因就是我們通過switch case來硬編碼“教導(dǎo)”工廠如何根據(jù)用戶輸入產(chǎn)生正確的運(yùn)算符，那么如果有一種方法可以讓工廠自動學(xué)會發(fā)現(xiàn)新的運(yùn)算符，那么我們的目的不就達(dá)到了？

嗯，我想聰明的朋友們已經(jīng)知道了，用屬性嘛，在C#中，這種方法完成類的自描述，是最好不過了的。

我們的設(shè)計思路如下：

• 定義一個描述屬性以識別運(yùn)算符
• 在運(yùn)算符中添加該描述屬性
• 在工廠啟動的時候，掃描程序集以注冊所有運(yùn)算符
  

代碼如下：

• 描述屬性

   class OperatorDescriptionAttribute : Attribute
   {
    public char Symbol { get; }
    public OperatorDescriptionAttribute(char c)
    {
     Symbol = c;
    }
   }

• 添加描述屬性到運(yùn)算符

   [OperatorDescription('+')]
   class AddOperator : IOperator
   {
    public int Calculate(int op1, int op2)
    {
     return op1 + op2;
    }
   }
  
   [OperatorDescription('-')]
   class SubtractOperator : IOperator
   {
    public int Calculate(int op1, int op2)
    {
     return op1 - op2;
    }
   }

• 讓工廠使用描述屬性

   class OperatorFactory : IOperatorFactory
   {
    private Dictionary<char, IOperator> dict = new Dictionary<char, IOperator>();
    public OperatorFactory()
    {
     Assembly assembly = Assembly.GetExecutingAssembly();
     foreach (var type in assembly.GetTypes())
     {
      if (typeof(IOperator).IsAssignableFrom (type) 
       && !type.IsInterface)
      {
       var attribute = type.GetCustomAttribute<OperatorDescriptionAttribute>();
       if(attribute != null)
       {
        dict[attribute.Symbol] = Activator.CreateInstance(type) as IOperator;
       }
      }
     }
    }
    public IOperator CreateOperator(char c)
    {
     if(!dict.ContainsKey(c))
     {
      throw new Exception("Not support");
     }
     return dict[c];
    }
   }

經(jīng)過這種改造，現(xiàn)在程序?qū)U(kuò)展性支持已經(jīng)很友好了，需要添加Multiple，只需要添加一個Multiple類就可以，其他代碼都不用修改，這樣就完美符合開閉原則了。

 [OperatorDescription('*')]
 class MultipleOperator : IOperator
 {
  public int Calculate(int op1, int op2)
  {
   return op1 * op2;
  }
 }

這就是我們怎么一步步從最原始的代碼走過來，一點點重構(gòu)讓代碼實現(xiàn)工廠方法模式，最終再完美支持開閉原則的過程，希望能幫助到大家。

其實關(guān)于最后那個通過標(biāo)記屬性實現(xiàn)擴(kuò)展，微軟有個MEF框架支持的很好，原理跟這個有點相似，有機(jī)會我們再聊聊MEF。

以上就是計算器實例代碼講解C#工廠模式的詳細(xì)內(nèi)容，更多關(guān)于c# 工廠模式的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論