计算器实例代码讲解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。

以上就是计算器实例代码讲解C#工厂模式的详细内容,更多关于c# 工厂模式的资料请关注我们其它相关文章!

(0)

相关推荐

  • 深入c#工厂模式的详解

    什么是工厂模式?类比生活中的概念,当我们需要打电话的时候,我们需要一部手机,我们通常会选择直接去卖手机的实体店买.但在程序设计中,当我们需要调用一个类(PhoneA或PhoneB)的方法的时候,我们往往还要关心他是怎么new出来的(见代码段1).这就好比我们自己还要去工厂里面告诉他们你要怎么生产出一部我需要的手机.而我们只关心他能不能打电话,你怎么做的关我屁事.所以这就有了工厂模式.工厂模式其实就是抽象出一个工厂,我需要什么手机,去哪个工厂买就行了.我不必关心他的制作过程,你只要能生产我要的功能

  • 实例解析C#设计模式编程中简单工厂模式的使用

    简单工厂模式的介绍 说到简单工厂,自然的第一个疑问当然就是什么是简单工厂模式了? 在现实生活中工厂是负责生产产品的,同样在设计模式中,简单工厂模式我们也可以理解为负责生产对象的一个类, 我们平常编程中,当使用"new"关键字创建一个对象时,此时该类就依赖与这个对象,也就是他们之间的耦合度高,当需求变化时,我们就不得不去修改此类的源码,此时我们可以运用面向对象(OO)的很重要的原则去解决这一的问题,该原则就是--封装改变,既然要封装改变,自然也就要找到改变的代码,然后把改变的代码用类来封

  • C#基于简单工厂模式实现的计算器功能示例

    本文实例讲述了C#基于简单工厂模式实现的计算器功能.分享给大家供大家参考,具体如下: 子类拥有父类除私有之外的所有属性字段和方法 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 工厂方法实现计算器 { /// <summary> /// 计算器类(抽象类,由子类重写) /// </sum

  • 浅谈C#设计模式之工厂模式

    工厂模式和简单工厂有什么区别.废话不多说,对比第一篇例子应该很清楚能看出来. 优点: 工厂模式弥补了简单工厂模式中违背开放-封闭原则,又保持了封装对象创建过程的优点. 复制代码 代码如下: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace DesignModel {     public inte

  • c#使用简单工厂模式实现生成html文件的封装类分享

    由于这段时间比较轻松,于是想到很多的企业网站,新闻网站需要将页面静态化,于是写了个封装类来实现静态文件的生成,思路比较简单,但未完善,网友可根据自己的思路将此类扩展,运用了简单工厂模式,先来看看静态类的父类:StaticBase(抽象类) 复制代码 代码如下: public abstract class StaticBase : IDisposable    {        /// <summary>        /// 默认编码方式        /// </summary>

  • C# 设计模式系列教程-抽象工厂模式

    1. 概述 抽象工厂模式为一个产品家族提供了统一的创建接口.当需要这个产品家族的某一系列的时候,可以从抽象工厂中选出相对应的系列来创建一个具体的工厂类别. 2. 抽象工厂模式中的角色 2.1 抽象工厂(AbstractFactory):担任这个角色的是工厂方法模式的核心,它是与应用系统商业逻辑无关的. 2.2 具体工厂(ConcreteFactory):这个角色直接在客户端的调用下创建产品的实例.这个角色含有选择合适的产品对象的逻辑,而这个逻辑是与应用系统的商业逻辑紧密相关的. 2.3 抽象产品

  • C# 设计模式系列教程-简单工厂模式

    1. 概述: 将一个具体类的实例化交给一个静态工厂方法来执行,它不属于GOF的23种设计模式,但现实中却经常会用到 2. 模式中的角色 2.1 工厂类(Simple Factory): 只包含了创建具体类的静态方法. 2.2 抽象产品(Product):定义简单工厂中要返回的产品. 2.3 具体产品(ConcreteProduct):具体产品. 3. 模式解读 3.1 简单工厂模式的一般化类图 3.2 简单工厂模式的代码实现 /// <summary> /// 简单工厂类,用sealed修饰,

  • 详解C#的设计模式编程之抽象工厂模式的应用

    这里首先以一个生活中抽象工厂的例子来实现一个抽象工厂,然后再给出抽象工厂的定义和UML图来帮助大家更好地掌握抽象工厂模式,同时大家在理解的时候,可以对照抽象工厂生活中例子的实现和它的定义来加深抽象工厂的UML图理解.抽象工厂模式比其它工厂模式更加抽象,抽象工厂模式适用与多个抽象类的情况下,通过工厂返回多个抽象类中你需要得到的具体子类实例. 抽象工厂模式比其它工厂模式更加抽象,抽象工厂模式适用与多个抽象类的情况下,通过工厂返回多个抽象类中你需要得到的具体子类实例. 举例阐述抽象工厂模式: 假如中国

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

    工厂模式作为很常见的设计模式,在日常工作中出镜率非常高,程序员们一定要掌握它的用法哟,今天跟着老胡一起来看看吧. 举个例子 现在先让我们来看一个例子吧,比如,要开发一个简单的计算器,完成加减功能,通过命令行读入形如1+1的公式,输出2这个结果,让我们看看怎么实现吧. 第一个版本 这个版本里面,我们不考虑使用模式,就按照最简单的结构,怎么方便怎么来. 思路非常简单,仅需要实现以下几个方法 取运算数 取运算符 输出结果 class Program { static int GetOperatorIn

  • Java 设计模式以虹猫蓝兔的故事讲解简单工厂模式

    目录 专栏介绍 本期介绍 什么是简单工厂模式 优点 缺点 应用场景 简单工厂的实现 专栏介绍 本系列专栏会以虹猫蓝兔七侠传的故事为例来给大家详细分析所有模式,希望能给大家带来帮助! 本期介绍 模式: 简单工厂模式 案例: 一个天外陨石(抽象产品),三把剑(产品), 一个铸剑师(工厂). 虹猫蓝兔莎莉分别找铸剑师造了三把剑. 什么是简单工厂模式 工厂模式的定义: 定义一个创建产品对象的工厂接口,将产品对象的实际创建工作推迟到具体子工厂类当中.这满足创建型模式中所要求的"创建与使用相分离"

  • Java 深入探究讲解抽象工厂模式

    目录 1. 抽象工厂模式解决 2. 抽象工厂类图UML 3. 抽象工厂模式的主要角色 4. 代码实现 5. 抽象工厂方法再探究 6. 优缺点 7. 适用示例 解决工厂方法模式的问题:一个具体工厂只能创建一类产品,而实际过程中一个工厂往往需要生成很多的产品,这种可以采用抽象工厂模式. 1. 抽象工厂模式解决 定义:提供一个创建一系列相关或者互相依赖对象的接口,无需指定他们的具体的类,具体的工厂负责实现具体的产品的实例.使一个工厂可以产生多个产品. 2. 抽象工厂类图UML 3. 抽象工厂模式的主要

  • Java 深入探究讲解简单工厂模式

    目录 1. 简单工厂介绍 2. 简单工厂类图UML 3. 简单工厂角色说明 4. 代码实现 5. 优缺点 6. 使用场景 1. 简单工厂介绍 简单工厂有一个具体的工厂类,可以生产不同的产品,属于创建型设计模式. 注意:简单工厂模式 不属于23种设计模式之列 2. 简单工厂类图UML 3. 简单工厂角色说明 简单工厂(SimpleFactory):是简单工厂模式的核心,负责实现创建所有实例的内部逻辑,工厂类的创建产品类的方法可以被外界直接访问,创建所需的产品对象. 抽象产品(Product):是简

  • 实例代码讲解JAVA多线程

    进程与线程 进程是程序的一次动态执行过程,它需要经历从代码加载,代码执行到执行完毕的一个完整的过程,这个过程也是进程本身从产生,发展到最终消亡的过程.多进程操作系统能同时达运行多个进程(程序),由于 CPU 具备分时机制,所以每个进程都能循环获得自己的CPU 时间片.由于 CPU 执行速度非常快,使得所有程序好像是在同时运行一样. 多线程是实现并发机制的一种有效手段.进程和线程一样,都是实现并发的一个基本单位.线程是比进程更小的执行单位,线程是进程的基础之上进行进一步的划分.所谓多线程是指一个进

  • 实例代码讲解JAVA 观察者模式

    当对象间存在一对多关系时,则使用观察者模式(Observer Pattern).比如,当一个对象被修改时,则会自动通知依赖它的对象.观察者模式属于行为型模式. 介绍 意图:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新. 主要解决:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作. 何时使用:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知. 如何解决:使用面向对象技术

  • 实例代码讲解c# 线程(下)

    前言 实例代码讲解c# 线程(上) 使用Mutex类 class Program { static void Main(string[] args) { const string MutexName ="CSharpThreadingCookbook"; using (var m = new Mutex(false, MutexName)) { if (!m.WaitOne(TimeSpan.FromSeconds(5), false)) { Console.WriteLine(&qu

  • 实例代码讲解Python 线程池

    大家都知道当任务过多,任务量过大时如果想提高效率的一个最简单的方法就是用多线程去处理,比如爬取上万个网页中的特定数据,以及将爬取数据和清洗数据的工作交给不同的线程去处理,也就是生产者消费者模式,都是典型的多线程使用场景. 那是不是意味着线程数量越多,程序的执行效率就越快呢. 显然不是.线程也是一个对象,是需要占用资源的,线程数量过多的话肯定会消耗过多的资源,同时线程间的上下文切换也是一笔不小的开销,所以有时候开辟过多的线程不但不会提高程序的执行效率,反而会适得其反使程序变慢,得不偿失. 所以,如

  • ASP.NET操作MySql数据库的实例代码讲解

    一.把MySql.Data.dll放到BIN目录下. 二.这是aspx.cs的全部源码,修改参数直接运行即可!   using MySql.Data.MySqlClient; using System; using System.Collections.Generic; using System.Data; using System.Linq; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; publ

  • jQuery判断邮箱格式对错实例代码讲解

    废话不多说了,具体代码如下所示: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>检测Email地址格式是否正确</title> <script src="http://apps.bdimg.com/libs/jquery/1.10.2/jquery.min.js"><

随机推荐