Language agnostic 如何命名表示阈值或限制的变量？

例如，假设我们有一个票务系统，可以配置为以正常价格提供门票，但一旦您在活动

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

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

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

我发现，如果不参考使用这些变量的代码，也不进行额外的推理，就很难为这些变量（和属性）提供足够表达和完整的名称

也就是说，没有看过代码其余部分或不了解其业务需求的人应该能够查看变量名称并理解：

• 抢购活动在活动开始前的

  X

  小时（含）开始
• 紧急销售在活动开始前

  Y

  小时（含）开始

---

有什么名字可以做到这一点呢？

给它命名它代表什么…：D

RushTicketPolicyValidityIntervalLength

好的，课堂上已经有了部分信息。那么这个呢

ValidityIntervalLength

---

或者类似的东西。

我是这里冗长的粉丝：

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

公务舱票
{
私有列表m_availableDiscounts=新列表（）；
私有十进制m_基准价格=0m；
私人日期时间m_showTime；
公众票（日期时间显示时间）
{
m_showTime=showTime；
}
公开名单折扣
{
得到
{
返回m_可用的搜索结果；
}
}
公共十进制基准价
{
得到
{
返回m_基价；
}
设置
{
m_基准价格=价值；
}
}
公共日期时间显示时间
{
得到
{
返回m_showTime；
}
}
公共十进制计算器价格（整数数量）
{
//在这里申请折扣。。。
}
}
公务舱折扣
{
私有int m_thresholdInSeconds=0；
专用十进制m_百分比=0m；
私有十进制m_FlataMontoff=0m；
公共折扣（整数阈值、小数百分比、小数flatAmountOff）
{
m_thresholdInSeconds=thresholdInSeconds；
m_percentOff=percentOff；
m_flatAmountOff=flatAmountOff；
}
公共阈值
{
得到
{
返回m_thresholdInSeconds；
}
}
公共小数百分比
{
得到
{
返回m_百分比；
}
}
公共十进制FlataMontoff
{
得到
{
返回m_flatAmountOff；
}
}
}

根据问题编辑2编辑#2

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

现在----------------------------------------------------------------------表演时间

在这段时间内的任何时候，您可能已经超过了使您有资格享受折扣的阈值（检查点、边界等）

------------|------现在-----------------------------------------------ShowTime

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

也许您可以使用a使API更具表现力。

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

考虑以下事项：

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

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

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

---

我也喜欢长篇大论——但考虑到变量名，折扣是在达到阈值之前还是之后适用？我的读数将在达到阈值之后。如果是以前，我会称之为DiscountExpirationThresholdInsideonds。嗯，我对可以直接表达这一点的变量名很感兴趣，因此它是明确无误的。我非常感谢这里的讨论，我不想在编辑时进行诱饵和切换！事实上，在可能的情况下（如果阈值信息来自与折扣信息不同的来源，则不会如此），您建议的类设计可能会更出色，但是变量名仍然存在我试图解决的问题：ThresholdInsectonds不表示阈值与（事件）的关系，也不描述折扣应该在间隔之前还是之后应用。对我来说，这似乎是不成熟的普遍性。他的方法支持0、1或2个折扣期（您可以将折扣设置为0）。如果折扣期不太可能超过2个，为什么要编写更长、更不清晰的代码来支持不需要的功能？单词间隔很可能是解决方案的一部分，但这并不表示间隔适用于什么时期。我的一位同事提出了一个非常有趣的建议。我试图说服他发布它，但要点是，命名这个变量非常困难，因为类没有引用事件，而事件是模型的关键元素。试图将其硬塞进变量名中不可避免地会导致混淆。因此，他建议使用

hoursbevent

变量和（关键的）sing来创建类似于

TicketingPeriodStart

的类