设计模式实践—策略+简单工厂对大量计算公式的处理

业务流程:

1.用户根据需要选择的实验方案,每个实验方案对应一种计算公式,计算公式例如下面这种

设计模式实践—策略+简单工厂对大量计算公式的处理插图
 

 2.将带有实验数据的PDF文件上传到特定位置,对PDF文件进行解析后将数据数据保存到数据库。

3.遍历所有方案,对每种方案使用特定的公式对数据库中的数据进行

重构前实现:

遍历方案,使用IF语句对使用的公式进行判断,而后在IF块里对数据进行处理

IF(Formula=='F1'){
    //F1的处理...
}
IF(Formula=='F2'){
    //F2的处理...
}
IF(Formula=='F3'){
    //F2的处理...
}

这样实现的问题就是程序太过庞大,八十多个公式就要有八十多个判断语句,并且判断内部的处理现也是很庞大的,这就导致了这个程序可读性很差,维护以及调试都十分困难。

重构

这里考虑使用策略模式+简单工厂进行重构

策略模式(Strategy Pattern):定义一系列算法,将每一个算法封装起来,并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化。

设计模式实践—策略+简单工厂对大量计算公式的处理插图1
使用策略模式重构后的程序结构:
设计模式实践—策略+简单工厂对大量计算公式的处理插图2

定义一个AbstractFormula抽象类,在抽象类中定义一个Calculation计算方法,这个方法返回经过计算的结果的集合,在各个实现类(即具体公式)中实现Calculation方法

定义上下文类,在上下文类中指定要使用的公式,定义Caclute方法用于返回结果。

实现代码

    /// 
    /// 简易的方案信息
    /// 
    internal class Schemeinformation
    {
        //方案ID
        public string SchemeID { get; set; }
        //方案名称
        public string SchemeName { get; set; }
        //公式
        public string Formula { get; set; }
    }
    /// 
    /// 单个结果
    /// 
    internal class Result
    {
        public Result(Schemeinformation schemeinformation, string 
        Result)
        {
            Schemeinformation = schemeinformation;
            FinalResult=Result;
        }
        public string FinalResult { get; set; }

        public Schemeinformation Schemeinformation { get; set; }
    }
//抽象的公式类   
 internal abstract class AbstractFormula
    {
        //公式计算后的结果集
        public Liststring>? tempResultList;
        public abstract Liststring> Caclution(Schemeinformation 
        schemeinformation);
    }
//具体实现    
internal class Formula1 : AbstractFormula
    {
        public override Liststring> Caclution(Schemeinformation schemeinformation)
        {
            tempResultList = new Liststring>();
            //计算过程... 对tempResultList赋值
            return tempResultList;
        }
    }
    internal class Formula2 : AbstractFormula
    {
        public override Liststring> Caclution(Schemeinformation schemeinformation)
        {
            tempResultList = new Liststring>();
            //计算过程...其中需要使用到Schemeinformation中的信息
            //对tempResultList赋值
            return tempResultList;
        }
    }
    /// 
    /// 上下文类 使用公式,并管理结果集
    /// 
    internal class Context
    {
        AbstractFormula formula;
        public void SetFromula(AbstractFormula formula)
        {
            this.formula = formula;
        }
        public Liststring> Caclute(Schemeinformation schemeinformation)
        {
            return formula.Caclution(schemeinformation);
        }
    }
    /// 
    /// 创建公式的简单工厂
    /// 
    internal class FormulaFactory
    {
        public static AbstractFormula GetFormula(string Formula)
        {
            if(Formula == "F1")
            {
                return new Formula1();
            }
            else if(Formula == "F2")
            {
                return new Formula2();
            }
            //以下若干.....

            else
            {
                //找不到这个公式,抛出异常
                throw new ArgumentNullException("value", $"公式{Formula}不存在"); ;
            }

        }
    }
//实际使用      
 static void Main(string[] args)
        {
            Context context= new Context();
            //获取所有方案信息
            List schemeinformationList = new List();
            //总结果集
            List results= new List();

            foreach(Schemeinformation schemeinformation in schemeinformationList)
            {
                //使用简单工厂获得公式对象
                context.SetFromula(FormulaFactory.GetFormula(schemeinformation.Formula));
                //获取当前公式的计算结果集
                Liststring>tempResults=context.Caclute(schemeinformation);
                //遍历结果,将所有结果放入到总结果集中
                foreach(string tempResult in tempResults)
                {
                    results.Add(new Result(schemeinformation,tempResult));
                }
            }
            //下面就可以输出总结果集了
            Console.WriteLine(results.Count);
        }

 

文章来源于互联网:设计模式实践---策略+简单工厂对大量计算公式的处理

THE END
分享
二维码