搜索
简帛阁>技术文章>计算器实例代码讲解C#工厂模式

计算器实例代码讲解C#工厂模式

工厂模式作为很常见的设计模式,在日常工作中出镜率非常高,程序员们一定要掌握它的用法哟,今天跟着老胡一起来看看吧。

举个例子

现在先让我们来看一个例子吧,比如,要开发一个简单的计算器,完成加减功能,通过命令行读入形如1+1的公式,输出2这个结果,让我们看看怎么实现吧。

第一个版本

这个版本里面,我们不考虑使用模式,就按照最简单的结构,怎么方便怎么来。

思路非常简单,仅需要实现以下几个方法

  • 取运算数
  • 取运算符
  • 输出结果
  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); //得到运算数1
   var op2 = GetOp(input, operatorIndex + 1); //得到运算数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实现抽象IFactory

关键代码如下,其他读取操作数之类的代码就不在赘述。

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

这样,我们就用工厂方法重新写了一次计算器,现在看看,好处有

  • 容易变化的创建部分被工厂封装了起来,工厂和客户端以接口的形式依赖,工厂内部逻辑可以随时变化而不用担心影响客户端代码
  • 工厂部分可以放在另外一个程序集,项目规划会更加合理
  • 客户端仅仅需要知道工厂和抽象的产品类,不需要再知道每一个具体的产品(不需要知道如何构建每一个具体运算符),符合迪米特法则
  • 扩展性增强,如果之后需要添加乘法multiple,那么仅需要添加一个Operator类代表Multiple并且修改Facotry里面的生成Operator逻辑就可以了,不会影响到客户端

自此,我们已经在代码里面实现了工厂方法模式,但可能有朋友就会想,虽然现在扩展性增强了,但是新添加运算符还是需要修改已有的工厂,这不是违反了开闭原则么。。有没有更好的办法呢?当然是有的。

反射版本

想想工厂方法那个版本,我们为什么增加新的运算符就会不可避免的修改现有工厂?原因就是我们通过switch case来硬编码“教导”工厂如何根据用户输入产生正确的运算符,那么如果有一种方法可以让工厂自动学会发现新的运算符,那么我们的目的不就达到了?

嗯,我想聪明的朋友们已经知道了,用属性嘛,在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];
      }
     }

经过这种改造,现在程序对扩展性支持已经很友好了,需要添加Multiple,只需要添加一个Multiple类就可以,其他代码都不用修改,这样就完美符合开闭原则了。

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

这就是我们怎么一步步从最原始的代码走过来,一点点重构让代码实现工厂方法模式,最终再完美支持开闭原则的过程,希望能帮助到大家。

其实关于最后那个通过标记属性实现扩展,微软有个MEF框架支持的很好,原理跟这个有点相似,有机会我们再聊聊MEF。

工厂模式作为很常见的设计模式,在日常工作中出镜率非常高,程序员们一定要掌握它的用法哟,今天跟着老胡一起来看看吧。举个例子现在先让我们来看一个例子吧,比如,要开发一个简单的计算器,完成加减功能,通过命令
简单工厂模式:①抽象基类:类中定义抽象一些方法,用以在子类中实现②继承自抽象基类的子类:实现基类中的抽象方法③工厂类:用以实例化对象看完文章再回头来看下这张图,效果会比较好采用封装方式代码如下:<
本文介绍了如何在VisualStudio中创建用户控件来显示下拉式计算器,弹出效果类似于日历控件。介绍如果我们正在做一个类似于库存控制和计费系统的项目,有些部分可能必须手动计算数值。因此,用户就不得
工厂模式作为很常见的设计模式,在日常工作中出镜率非常高,程序员们一定要掌握它的用法哟,今天跟着老胡一起来看看吧。举个例子现在先让我们来看一个例子吧,比如,要开发一个简单的计算器,完成加减功能,通过命令
本文实例讲述了PHP基于工厂模式实现的计算器。分享给大家供大家参考。具体如下:abstractclassCalculator{private$number1;private$number2;publi
简介工厂方法模式是什么?为什么要有工厂方法模式,不是有了简单工厂模式了吗?两个模式都有工厂,那有什么不同呢?功工厂方式模式是怎样实现的?OK,带着这些问题,继续看下面文章。工厂方法模式是对简单工厂模式
抽想工厂类创建方法,以下是一个多年前写的例子1,提供一个供外部访问的属性2,构造函数初始化该属性3,创建子类工厂需要继承实现的业务类的属性publicabstractclassBLLFactory{p
言最近开始花点心思研究下设计模式,主要还是让自己写的代码可重用性高、保证代码可靠性。所谓设计模式,我找了下定义:是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。毫无疑问,设计模式
设计模式总原则:开闭原则(对扩展开放,对修改关闭)1单一职责原则:每个类有单一的职责,如若不然就要把类拆分。2里氏替换原则:开闭原则是实现抽象化,而里氏替换原则是抽象化的具体实现。3依赖倒转原则:是开
这是我们用得比较多的一种设计模式,也是23种标准设计模式之一,使用前面讲的简单工厂设计模式,遇到具体产品经常变换时就不太适合了,违反了开闭设计原则;怎么才能避免修改工厂类呢?工厂方法模式可以做到。工厂