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

我有一个问题，我之前曾尝试寻求帮助，但当时无法解决它，所以我现在尝试简化问题，看看是否可以获得更具体的帮助，因为它让我发疯了……

基本上，我有这个应用程序的工作（更复杂）版本，它是一个项目成本计算器。但因为我同时尝试学习更好地设计我的应用程序，所以我希望获得一些关于如何改进此设计的意见。基本上我想要的主要内容是输入（此处）在两个地方重复出现的条件。之前得到的建议是使用策略模式或者工厂模式。我还知道 Martin Fowler 的书，其中建议使用多态性进行条件重构。我在他更简单的例子中理解了这个原则。但是我该如何在这里做这些事情（如果合适的话）？在我看来，计算取决于几个条件： 1. 它是什么类型的服务，写作还是分析？ 2. 项目是小型、中型还是大型？ （请注意，可能还有其他参数，同样不同，例如“产品是新的还是以前存在的？”因此应该可以添加此类参数，但我试图使示例保持简单，仅使用两个参数能够得到具体的帮助）

因此，使用多态性进行重构意味着创建许多子类，我已经为第一个条件（服务类型）创建了多个子类，我真的应该为第二个条件（大小）创建更多子类吗？那会变成什么， AnalysisSmall、 AnalysisMedium、 AnalysisLarge、writingSmall 等等……？？？不，我知道这不好，我只是不知道如何使用该模式？

对于使用策略模式的建议，我基本上看到了同样的问题（我认为工厂模式只是实现上述多态性的帮助者）。因此，如果有人对如何以最佳方式设计这些类有具体建议，我将非常感激！还请考虑我是否也正确选择了对象，或者是否需要重新设计它们。 （像“你应该考虑工厂模式”这样的回应显然不会有帮助......我已经沿着这条路走下去了，我对在这种情况下到底是如何做到的感到困惑）

Regards,

Anders

代码（非常简单，不要介意我使用字符串而不是枚举，不使用数据配置文件等，一旦我掌握了这些设计问题，这将在实际应用程序中根据需要完成）：

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