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

舉個例子

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

第一個版本

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

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

• 取運算數(shù)
• 取運算符
• 輸出結果

  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); //得到運算符索引
   var op1 = GetOp(input, 0, operatorIndex); //得到運算數(shù)1
   var op2 = GetOp(input, operatorIndex + 1); //得到運算數(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();
   }   
  }
}

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

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

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

工廠方法模式版本

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

依葫蘆畫瓢，我們設計思路如下：

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

關鍵代碼如下，其他讀取操作數(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)建部分被工廠封裝了起來，工廠和客戶端以接口的形式依賴，工廠內部邏輯可以隨時變化而不用擔心影響客戶端代碼
• 工廠部分可以放在另外一個程序集，項目規(guī)劃會更加合理
• 客戶端僅僅需要知道工廠和抽象的產品類，不需要再知道每一個具體的產品（不需要知道如何構建每一個具體運算符），符合迪米特法則
• 擴展性增強，如果之后需要添加乘法multiple，那么僅需要添加一個Operator類代表Multiple并且修改Facotry里面的生成Operator邏輯就可以了，不會影響到客戶端

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

反射版本

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

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

我們的設計思路如下：

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

代碼如下：

• 描述屬性

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

• 添加描述屬性到運算符

   [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];
    }
   }

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

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

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

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

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

最新評論