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

舉個(gè)例子

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

第一個(gè)版本

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

思路非常簡(jiǎn)單，僅需要實(shí)現(xiàn)以下幾個(gè)方法

• 取運(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();
   }   
  }
}

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

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

接下來(lái)，我們引入我們的主題，工廠方法模式。

工廠方法模式版本

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

依葫蘆畫瓢，我們?cè)O(shè)計(jì)思路如下：

• 設(shè)計(jì)一個(gè)IOperator接口，對(duì)應(yīng)抽象的Product
• 設(shè)計(jì)AddOperator和SubtractOperator，對(duì)應(yīng)具體Product
• 設(shè)計(jì)IOperatorFactory接口生產(chǎn)Operator
• 設(shè)計(jì)OperatorFactory實(shí)現(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);     
    }

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

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

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

反射版本

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

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

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

• 定義一個(gè)描述屬性以識(shí)別運(yùn)算符
• 在運(yùn)算符中添加該描述屬性
• 在工廠啟動(dòng)的時(shí)候，掃描程序集以注冊(cè)所有運(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)過(guò)這種改造，現(xiàn)在程序?qū)U(kuò)展性支持已經(jīng)很友好了，需要添加Multiple，只需要添加一個(gè)Multiple類就可以，其他代碼都不用修改，這樣就完美符合開閉原則了。

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

這就是我們?cè)趺匆徊讲綇淖钤嫉拇a走過(guò)來(lái)，一點(diǎn)點(diǎn)重構(gòu)讓代碼實(shí)現(xiàn)工廠方法模式，最終再完美支持開閉原則的過(guò)程，希望能幫助到大家。

其實(shí)關(guān)于最后那個(gè)通過(guò)標(biāo)記屬性實(shí)現(xiàn)擴(kuò)展，微軟有個(gè)MEF框架支持的很好，原理跟這個(gè)有點(diǎn)相似，有機(jī)會(huì)我們?cè)倭牧腗EF。

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

最新評(píng)論