Question

我找不到一个好的高性能和易读性的方法来编写一个类内部的计算。想象一下以下课程以及获得FinalPrice的所有方法：

public class Order {
    public Order(Product[] products) {
        Items = products;

选项1：为每个想要计算的属性设置变量声明，可怕的易读性

        var orderPrice = products.Sum(p => p.Price * p.Quantity);
        var orderTaxes = products.Sum(p => p.Taxes * p.Quantity);
        var orderDiscount = products.Sum(p => p.Price * p.Quantity * p.Discount);

        OrderPrice = orderPrice;
        OrderTaxes = orderTaxes;
        OrderDiscount = orderDiscount;

        FinalPrice = orderPrice + orderTaxes - orderDiscount;

选项2：让班级的顺序问题很重要！ FinalPrice行不能在其他行之前，否则它将无效但不会引发错误。

        OrderPrice = products.Sum(p => p.Price * p.Quantity);
        OrderTaxes = products.Sum(p => p.Taxes * p.Quantity);
        OrderDiscount = products.Sum(p=> p.Price * p.Quantity * p.Discount);

        FinalPrice = OrderPrice + OrderTaxes - OrderDiscount;

选项3：重写所有公式 - 对于manteinance不好。最有可能在以后引入价格差异。

        FinalPrice = products.Sum(p => p.Price * p.Quantity) + 
                     products.Sum(p => p.Taxes * p.Quantity) - 
                     products.Sum(p => p.Price * p.Quantity * p.Discount);

    }

选项4：使用getter。这将在每次调用时计算。这是一个简单的计算，但是假设代码更多。

    public decimal FinalPrice { get {
        return OrderPrice + OrderTaxes - OrderDiscount;
    } }
}

选项5：使用函数。这是好事还是坏事？

    public decimal CalculateFinalPrice() {
        return OrderPrice + OrderTaxes - OrderDiscount;
    }

Answer 1

我会为CalculateFinalPrice，CalculateOrderPrice，CalculateOrderTaxes和CalculateOrderDiscount创建方法，如下所示：

public decimal CalculateFinalPrice() {
    return CalculateOrderPrice() + CalculateOrderTaxes() - CalculateOrderDiscount();
}

public decimal CalculateOrderPrice()
{
    // Logic here to calculate order price
    return theOrderPrice;
}

public decimal CalculateOrderTaxes()
{
    // Logic here to calculate order taxes
    return theOrderTaxes;
}

public decimal CalculateOrderDiscount()
{
    // Logic here to calcuate order discount
    return theOrderDiscount;
}

这为您提供了更多，但更小的部分，更易于维护，阅读和单元测试，因为每种方法都有一个单一的责任。

Answer 2

我会在getter中完成所有逻辑：

public decimal CalculateFinalPrice
{
    get { return CalculateOrderPrice + CalculateOrderTaxes - CalculateOrderDiscount; }
}

public decimal CalculateOrderPrice
{
    get { return products.Sum(p => p.Price*p.Quantity); }
}

public decimal CalculateOrderTaxes
{
    get { return products.Sum(p => p.Taxes*p.Quantity); }
}

public decimal CalculateOrderDiscount
{
    get { return products.Sum(p => p.Price*p.Quantity*p.Discount); }
}

如果您的方案中速度很慢，则可以缓存属性。

private decimal? _calculateOrderPrice;
public decimal CalculateOrderPrice
{
    get
    {
        if (_calculateOrderPrice == null)
        {
            _calculateOrderPrice = products.Sum(p => p.Price*p.Quantity;
        }
        return _calculateOrderPrice.Value;
    }
}

如果您转到属性的定义，您可以立即看到它的计算方式。您也不必关心首先需要进行计算。

Getter，Function还是只在构造函数上设置它？

2 个答案: