如何命名代表阈值或限制的变量？

Question

例如，假设我们有一个票务系统可以配置为以正常价格提供门票，但是一旦您在活动开始的X 小时内，您就会以不同的价格提供门票（可能会打折或增加）。我们将其称为“抢购价”。此外，一旦您在活动的Y 小时内，您就可以以另一个价格提供它们。我们将其称为“紧急价格”。

表示此配置信息的类可能如下所示：

public class RushTicketPolicy {

    private int rushHours;
    private int emergencyHours;

    public RushTicketPolicy(int rushHours, int emergencyHours) {
        this.rushHours      = rushHours;
        this.emergencyHours = emergencyHours;
    }

    public int RushHours      { get { return this.rushHours; } }
    public int EmergencyHours { get { return this.emergencyHours; } }
}

我发现很难为这些变量（和属性）想出足够表达和完整的名称，而不参考使用它们的代码，也不需要额外的推断。

也就是说，没有看过其余代码或对其业务需求一无所知的人应该能够查看变量名称并理解：

• 在活动前几个小时X 开始抢购。
• 紧急销售在活动前几个小时开始Y，包括在内。

有哪些名字可以做到这一点？

Answer 1

public class SalesPeriodStartRule {

    private int mHoursBeforeEvent = 0;

    public SalesPeriodStartRule(int hoursBeforeEvent) {
        mHours = hoursBeforeEvent;
    }
    public DateTime GetEffectiveDate(DateTime showDate) {
        return showDate.AddHours(-mHoursBeforeEvent);
    }
}

public class PricingPolicy {
    private SalesPeriodStartRule mRushRule;
    private SalesPeriodStartRule mEmergencyRule;

    public PricingPolicy(SalesPeriodStartRule rushRule, SalesPeriodStartRule emergencyRule) {
        mRushRule      = rushRule;
        mEmergencyRule = emergencyRule;
    }
    public string GetPriceCategory(DateTime purchaseDate, DateTime showDate) {
        if (purchaseDate > mEmergencyRule.GetEffectiveDate(showDate)) {
            return "Emergency";
        }
        else if (purchaseDate > mRushRule.GetEffectiveDate(showDate)) {
            return "Rush";
        }
        else {
            return "Standard";
        }
    }
}

Answer 2

我喜欢冗长：

DiscountThresholdInSeconds

根据您的编辑 #1：

如果你有一个类“票”，我会简单地给它一个折扣集合：

public class Ticket { private List <Discount> m_availableDiscounts = new List<Discount>(); private decimal m_basePrice = 0m; private DateTime m_showTime; public Ticket(DateTime showTime) { m_showTime = showTime; } public List<Discount> Discounts { get { return m_availableDiscounts; } } public decimal BasePrice { get { return m_basePrice; } set { m_basePrice = value; } } public DateTime ShowTime { get { return m_showTime; } } public decimal CalculatePrice(int quantity) { //Apply discounts here... } } public class Discount { private int m_thresholdInSeconds = 0; private decimal m_percentOff = 0m; private decimal m_flatAmountOff = 0m; public Discount(int thresholdInSeconds, decimal percentOff, decimal flatAmountOff) { m_thresholdInSeconds = thresholdInSeconds; m_percentOff = percentOff; m_flatAmountOff = flatAmountOff; } public int ThresholdInSeconds { get { return m_thresholdInSeconds; } } public decimal PercentOff { get { return m_percentOff; } } public decimal FlatAmountOff { get { return m_flatAmountOff; } } }

根据问题编辑 #2 编辑 #2

您列出的代码与我提供的代码之间的区别在于，您的代码只允许两个不同的折扣期，而我的代码支持分层模型。如果我们真的在这里谈论门票，请将其视为时间线：

现在---------------------------------------------- ---------------------------------------放映时间

在此期间的任何时候，您都可能超过了有资格获得折扣的阈值（检查点、边界等）。

------------|------现在------------|-------------- ----|---------------|---|---演出时间

由于 ShowTime 是此时间线中的稳定信息，因此您需要捕获与 showtime 的“距离”和适用的折扣。与 ShowTime 的“距离”是跨越的门槛。

Answer 3

将其命名为它所代表的... :D

RushTicketPolicyValidityIntervalLength

好的，班级已经有了部分信息。那么这个呢？

ValidityIntervalLength

或类似的东西。

Answer 4

也许您可以使用fluent interface 使 API 更具表现力。 考虑以下几点：

public class Test
{
    public string TestPolicies()
    {
        int year = 2010;
        int month = 11;
        int day = 3;
        int hour = 15;
        int minute = 30;
        int second = 0;

        DateTime eventDateTime = new DateTime(year, month, day, hour, minute, second);

        IConfiguredTicketPolicy emergencyTicketPolicy = new TicketPolicy().Starts(2).HoursBefore(eventDateTime).Inclusive();
        IConfiguredTicketPolicy rushTicketPolicy      = new TicketPolicy().Starts(4).HoursBefore(eventDateTime).Inclusive();

        DateTime now = DateTime.Now;

        if (emergencyTicketPolicy.IsEffectiveAsOf(now))
        {
            return "Emergency";
        }
        else if (rushTicketPolicy.IsEffectiveAsOf(now))
        {
            return "Rush";
        }
        else
        {
            return "Standard";
        }            
    }
}

TicketPolicy 类的实现看起来像这样：

    public class TicketPolicy : IConfigurePolicySalesStart, IConfigurePolicyHoursBefore, IConfigurePolicyInclusive, IConfiguredTicketPolicy
{
    private int mHours;
    public IConfigurePolicyHoursBefore Starts(int hours)
    {
        TicketPolicy clone = this.Clone();
        clone.mHours = hours;
        return clone;
    }

    private DateTime mEventDateTime;
    public IConfigurePolicyInclusive HoursBefore(DateTime eventDateTime)
    {
        TicketPolicy clone = this.Clone();
        clone.mEventDateTime = eventDateTime;
        return clone;
    }

    private bool mInclusive = false;
    public IConfiguredTicketPolicy Inclusive()
    {
        TicketPolicy clone = this.Clone();
        clone.mInclusive = true;
        return clone;
    }

    public bool IsEffectiveAsOf(DateTime now)
    {
        DateTime effectiveDate = mEventDateTime.AddHours(-1*this.mHours);
        if (!this.mInclusive)
        {
            effectiveDate = effectiveDate.AddTicks(1);
        }

        return effectiveDate.CompareTo(now) < 0;
    }
    public TicketPolicy Clone()
    {
        TicketPolicy clone = new TicketPolicy();
        clone.Starts(this.mHours);
        clone.HoursBefore(this.mEventDateTime);
        if (this.mInclusive)
        {
            clone.Inclusive();
        }
        return clone;
    }
}  

这些接口用于帮助智能感知通过 API 导航用户，可能不是必需的。它们可能看起来像这样：

public interface IConfigurePolicySalesStart
 {
     IConfigurePolicyHoursBefore Starts(int hours);
 }

 public interface IConfigurePolicyHoursBefore
 {
     IConfigurePolicyInclusive HoursBefore(DateTime eventDateTime);
 }

 public interface IConfigurePolicyInclusive
 {
     IConfiguredTicketPolicy Inclusive();
 }

 public interface IConfiguredTicketPolicy
 {
     bool IsEffectiveAsOf(DateTime now); 
 }