用于大量计算的 c# 模式或设计

Question

我正在寻找设计方法，我怎样才能实现大量计算，使代码看起来干净，并且可以进行单元测试。我现在就是这样做的。

我有包含 General、MainEngine、AuxEngine、Boilers、WaterBoilers 等 block 的表单。每个 block 都有很多属性。现在我的计算类看起来像这样。

我使用部分类来实现 block 之间的独立计算逻辑

/// <summary>
/// My result class wich fill CalculationResult 
/// </summary>
public partial class CalculateBlocks
{
    private readonly IClassificatoryService _classificatoryService;
    private readonly IReportService _reportService;

    public CalculationResult Result = new CalculationResult();

    /// <summary>
    /// Ctor with DI
    /// </summary>
    public CalculateBlocks(IClassificatoryService classificatoryService,IReportService reportService)
    {
        _classificatoryService = classificatoryService;
        _reportService = reportService;
    }

    public void Calculate()
    {
        CalculateGeneral();
        CalculateMainEngine();
        //and a lot more blocks
    }
}

public partial class CalculateBlocks
{
    private void CalculateGeneral()
    {
        Result.General.TotalReports = 2 + 2;
    }
}

public partial class CalculateBlocks
{
    private void CalculateMainEngine()
    {
        Result.MainEngine.Power = 1000;
    }
}

我的实体看起来像这样

public class CalculationResult
{
    public CalculationResult()
    {
        General = new General();
        MainEngine = new MainEngine();
    }

    public General General { get; set; }
    public MainEngine MainEngine { get; set; }
}

public class General
{
    public decimal? TotalReports { get; set; }
    //... more here
    //... more here
    //... more here
}

public class MainEngine
{
    public decimal? Power { get; set; }
    //... more here
    //... more here
    //... more here
}

Answer 1

听起来像 strategy pattern是你要找的。每个 block 都是一个实现接口(interface)的单独类。

类似于:

interface IBlockCalculator
{
    CalculationResult Calculate();
}

class MainEngineBlockCalculator : IBlockCalculator
{
    public CalculationResult Calculate()
    {
        // Calculation goes here...
    }
}

class GeneralEngineBlockCalculator : IBlockCalculator
{
    public CalculationResult Calculate()
    {
        // Calculation goes here...
    }
}

然后您可以为每个 block 实现接口(interface)。您甚至可以将它们组合起来，这样您就可以拥有一个带有子 block 的顶级 block 。

单元测试也得到了简化，因为您可以分别对每个单独的 block 计算进行单元测试。

[Test]
public void TestMainEngineBlock...()
{
    // Arrange
    var sut = new MainEngineBlockCalculator();
    // Set up your test scenario here...

    // Act
    var actualResult = sut.Calculate();

    // Assert
    // Assertion on actualResult go here...
}