欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

.NET简单工厂模式讲解

程序员文章站 2024-02-08 13:38:34
简单工厂模式介绍: 简单工厂模式是属于创建型模式,又叫做静态工厂方法(static factory method)模式,但不属于23种gof设计模式之一。简单工厂模式是由...

简单工厂模式介绍:

简单工厂模式是属于创建型模式,又叫做静态工厂方法(static factory method)模式,但不属于23种gof设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。

结构模式图:

.NET简单工厂模式讲解

角色分类:

工厂(creator)角色
简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用,创建所需的产品对象。

抽象产品(product)角色
简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。

具体产品(concrete product)角色
是简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。

引入实际情况:

如果有一个住户管理系统,里面的住户类型是可变的,每一种租户类型的租金计算公式都存在差异

a类型的住户租金额=天数*单价+绩效*0.005

b类型的住户租金额=月份*(每月价格+performance*0.001)

分析:

1. 商店存在共有的计算方法,这是实体商店的行为,然而他们的行为的方式不一样,所有我们抽象商店类,代码如下:

using system;
using system.collections.generic;
using system.linq;
using system.text;

namespace simplefactory.app.ifactroy
{
  
  public interface ishop
  {
    double getrent(int days, double dayprice, double performance);
  }
}

2.在抽象了商店之后,我们要对创建具体产品类,这里就是具体的类型商店,里面实现该商店的行为方法。创建a类型的商店

using simplefactory.app.ifactroy;
using system;
using system.collections.generic;
using system.linq;
using system.text;

namespace simplefactory.app.product
{
  //a类型的商店的创建
  public class ashop:ishop
  {
    /// <summary>
    /// /// a类型商店租金额,天数*单价+绩效*0.005
    /// </summary>
    /// <param name="days">天数</param>
    /// <param name="dayprice">每天单价</param>
    /// <param name="performance">日平均绩效</param>
    /// <returns></returns>
    public double getrent(int days, double dayprice, double performance)
    {
      console.writeline("a商店的租金算法");
      return days * dayprice + performance * 0.01;
    }
  }
}

3.创建b类型的商店:

using simplefactory.app.ifactroy;
using system;
using system.collections.generic;
using system.linq;
using system.text;

namespace simplefactory.app.product
{
  /// <summary>
  /// b类型的商店的创建
  /// </summary>
  public class bshop:ishop
  {
    
    /// <summary>
    /// b类型商店的租金=月份*(每月价格+performance*0.001)
    /// </summary>
    /// <param name="month">月数</param>
    /// <param name="monthprice">月单价</param>
    /// <param name="performance">月平均绩效</param>
    /// <returns></returns>
    public double getrent(int month, double monthprice, double performance)
    {
      console.writeline("b商店的租金算法");
      return month * (monthprice + performance * 0.001);
    }
  }
}

4. 在创建号类型商店并实现方法后,思考在什么情况下如何创建那种对象,于是简单工厂模式中最核心的部分:工厂类出来了

using simplefactory.app.ifactroy;
using simplefactory.app.product;
using system;
using system.collections.generic;
using system.linq;
using system.text;

namespace simplefactory.app.factorymethod
{
  public class factorymethod
  {
    public ishop createshow(string show)
    {
      switch (show.trim().tolower())
      {
        case"ashop":
          return new ashop();
        case "bshop":
          return new ashop();
        default:
          throw new exception("该商店不存在");
      }
    }
  }
}

5.然后就根据当前的商店类型进行判断,该类型的商店应该进行哪一种算法:

using simplefactory.app.factorymethod;
using simplefactory.app.ifactroy;
using system;
using system.collections.generic;
using system.linq;
using system.text;

namespace simplefactory.app
{
  class program
  {
    static void main(string[] args)
    {
      ishop as;
      factorymethod afm = new factorymethod();
      as = afm.createshow("ashop"); //a 类型的某商店
      double total = as.getrent(30, 300, 2000);   //30 天/100元 日平均绩效为2000
      console.writeline("该a类型商店的租金为:" + total);

      console.writeline("=============");

      ishop bs;
      factorymethod bfm = new factorymethod();
      bs = bfm.createshow("bshop"); //b 类型的某商店
      total = bs.getrent(3, 3000, 60000);     //3 月/4000元 月平均绩效为60000
      console.writeline("该b类型商店的租金为:" + total);
      console.readkey();
    }
  }
}

到这里我们实现了客户要求的两种类型商店的算法的需求,但是作为一种好的设计架构,还应该考虑到后面的需求变革,如果客户现在又增加了c类型商店和d类型商店,它们的算法要求又不一样,这个时候我们就需要进行c,d类型商店的创建,并继承ishop接口,实现里面的方法,同时还得继续修改工厂类在switc中增加case进行捕捉创建相应的商店对象,一旦出现这样的情况,是不利于程序的扩展性和项目后期的维护性的。

优点:

  • 简单工厂模式能够根据外界给定的信息,决定究竟应该创建哪个具体类的对象。通过它,外界可以从直接创建具体产品对  象的尴尬局面中摆脱出来。
  • 外界与具体类隔离开来,偶合性低。
  • 明确区分了各自的职责和权力,有利于整个软件体系结构的优化。

缺点:

  • 工厂类集中了所有实例的创建逻辑,容易违反graspr的高内聚的责任分配原则
  • 虽然简单工厂模式能够适应一定的变化,但是它所能解决的问题是远远有限的。它所能创建的类只能是事先教考虑到的,如果需要添加新的类,则就需要改变工厂类了。

出现的上诉情况,应该如何解决,值得思考,将在下一个工厂方法模式中得到很好的解决。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。