成本计算器应用程序的设计模式？

我有一个问题,以前曾尝试获得帮助,但是当时我无法解决,所以我现在尝试简化问题,以查看是否可以为此获得更多具体帮助.让我发疯…

基本上,我有这个应用程序的工作版本(更复杂),它是一个项目成本计算器.但是因为同时我想学习更好地设计应用程序,所以我想对如何改进这种设计提供一些建议.基本上,我想要的主要内容是在(这里)在两个地方重复出现的条件输入.我之前得到的建议是使用策略模式或工厂模式.我也对马丁·福勒(Martin Fowler)的书有所了解,并建议采用多态条件重构.我在他的简单示例中了解了该原理.但是,在这里我该怎么做(如果合适的话)？从我的角度来看,计算取决于两个条件：1.它是哪种服务,无论是编写还是分析？ 2.项目是小型,中型还是大型的？ (请注意,可能还存在其他参数,它们也同样不同,例如“产品是新的还是以前存在的？”,因此应该可以添加这样的参数,但是我尝试通过仅将两个参数保持为简单的示例能够获得具体帮助)

因此,使用多态进行重构将意味着创建多个子类,对于第一个条件(服务类型)我已经具有这些子类,并且我是否还应该为第二个条件(大小)创建更多的子类？那会变成什么,AnalysisSmall,AnalysisMedium,AnalysisLarge,WritingSmall等……？不,我知道那不好,我只是不明白如何使用该模式？

对于使用策略模式的建议,我基本上看到了相同的问题(就像我看到的工厂模式一样,它可以帮助实现上述多态性).因此,如果有人对如何最好地设计这些课程提出具体建议,我将不胜感激！还请考虑我是否也正确选择了对象,或者是否需要重新设计它们. (诸如“您应该考虑工厂模式”之类的响应显然无济于事……我已经走过那条路了,在这种情况下我很困惑)

问候,

安德斯

代码(非常简化,不要介意我使用字符串而不是枚举,不使用配置文件存储数据等事实,一旦我掌握了这些设计问题,就可以在实际应用程序中按需完成此操作)：

public abstract class Service
{
    protected Dictionary<string, int> _hours;
    protected const int SMALL = 2;
    protected const int MEDIUM = 8;

    public int NumberOfProducts { get; set; }
    public abstract int GetHours();
}

public class Writing : Service
{
    public Writing(int numberOfProducts)
    {
        NumberOfProducts = numberOfProducts;
        _hours = new Dictionary<string, int> { { "small", 125 }, { "medium", 100 }, { "large", 60 } };
    }

    public override int GetHours()
    {
        if (NumberOfProducts <= SMALL)
            return _hours["small"] * NumberOfProducts;
        if (NumberOfProducts <= MEDIUM)
            return (_hours["small"] * SMALL) + (_hours["medium"] * (NumberOfProducts - SMALL));
        return (_hours["small"] * SMALL) + (_hours["medium"] * (MEDIUM - SMALL))
            + (_hours["large"] * (NumberOfProducts - MEDIUM));
    }
}

public class Analysis : Service
{
    public Analysis(int numberOfProducts)
    {
        NumberOfProducts = numberOfProducts;
        _hours = new Dictionary<string, int> { { "small", 56 }, { "medium", 104 }, { "large", 200 } };
    }

    public override int GetHours()
    {
        if (NumberOfProducts <= SMALL)
            return _hours["small"];
        if (NumberOfProducts <= MEDIUM)
            return _hours["medium"];
        return _hours["large"];
    }
}

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        List<int> quantities = new List<int>();

        for (int i = 0; i < 100; i++)
        {
            quantities.Add(i);
        }
        comboBoxNumberOfProducts.DataSource = quantities;
    }

    private void comboBoxNumberOfProducts_SelectedIndexChanged(object sender, EventArgs e)
    {
        Service writing = new Writing((int) comboBoxNumberOfProducts.SelectedItem);
        Service analysis = new Analysis((int) comboBoxNumberOfProducts.SelectedItem);

        labelWriterHours.Text = writing.GetHours().ToString();
        labelAnalysisHours.Text = analysis.GetHours().ToString();
    }
}

解决方法:

在您的计算中,服务类型,服务大小和产品数量之间存在紧密的联系,因为很难将它们分成模块化的块以应用策略模式,所以这非常困难.

如果计算系统是固定的,则似乎策略模式不合适.如果不是,那么,为什么不简化系统呢？

例如,从服务规模中拉出基本小时数,然后根据您的其他设置应用各种折扣或增加.

public class Service
{
    public IServiceSize serviceSize { internal get; set; }
    public IServiceBulkRate serviceBulkRate { internal get; set; }
    public IServiceType serviceType { internal get; set; }
    public int numberOfProducts { get; set; }

    /// <summary>
    /// Initializes a new instance of the <see cref="Service"/> class with default values
    /// </summary>
    public Service()
    {
        serviceSize = new SmallSize();
        serviceBulkRate = new FlatBulkRate();
        serviceType = new WritingService();
        numberOfProducts = 1;
    }

    public decimal CalculateHours()
    {
        decimal hours = serviceSize.GetBaseHours();
        hours = hours * serviceBulkRate.GetMultiplier(numberOfProducts);
        hours = hours * serviceType.GetMultiplier();

        return hours;
    }
}

public interface IServiceSize
{
    int GetBaseHours();
}

public class SmallSize : IServiceSize
{
    public int GetBaseHours()
    {
        return 125;
    }
}

public interface IServiceBulkRate
{
    decimal GetMultiplier(int numberOfProducts);
}

public class FlatBulkRate : IServiceBulkRate
{
    public decimal GetMultiplier(int numberOfProducts)
    {
        return numberOfProducts;
    }
}

public class StaggeredBulkRate : IServiceBulkRate
{
    public decimal GetMultiplier(int numberOfProducts)
    {
        if (numberOfProducts < 2)
            return numberOfProducts;
        else if (numberOfProducts >= 2 & numberOfProducts < 8)
            return numberOfProducts * 0.85m;
        else
            return numberOfProducts * 0.8m;
    }
}

public interface IServiceType
{
    decimal GetMultiplier();
}

public class WritingService : IServiceType
{
    public decimal GetMultiplier()
    {
        return 1.15m;
    }
}

标签：strategy-pattern,factory-pattern,c,design-patterns
来源： https://codeday.me/bug/20191210/2099096.html