2

我找不到在类中编写一些计算的良好性能和易读性的方法。想象一下以下类和所有获取 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：重写所有公式 - 不利于维护。最有可能在以后引入价格差异。

        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：使用吸气剂。这将在每次调用时计算。这是一个简单的计算，但假设更多的代码。

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

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

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

2 回答 2

4

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

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

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

于 2013-08-29T04:47:13.300 回答
4

我会在 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;
    }
}

如果您转到属性的定义，您可以立即看到它是如何计算的。你也不关心需要先完成哪些计算。

于 2013-08-29T04:56:14.630 回答