How to name variables that represent thresholds or limits?

Question

For example, say we have a ticketing system that can be configured to offer tickets at normal price, but once you're within X hours of the event, you offer them at a different price (it may be discounted or increased). We'll call this the 'rush price'. Moreover, once you're within Y hours of the event, you offer them at yet another price. We'll call this the 'emergency price'.

The class that represents this configuration information might look like this:

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

I'm finding it extremely difficult to come up with names for these variables (and properties) that are sufficiently expressive and complete, without reference to the code that uses them and without additional inference.

That is, someone that hasn't seen the rest of the code or know anything about its business requirements should be able to look at the variable names and understand that:

• Rush sales start X hours before the event, inclusive.
• Emergency sales start Y hours before the event, inclusive.

What are some names that would accomplish that?

Answer 1

Name it what it represents ... :D

RushTicketPolicyValidityIntervalLength

Okay, the class has already part of the information. So what about this?

ValidityIntervalLength

Or something similar.

Answer 2

I'm a fan of verbosity here:

DiscountThresholdInSeconds

Based on your edit #1:

If you have a class "Ticket," I would simply give it a collection of discounts:

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

Edit #2 based on question Edit #2

The difference between what you have listed and the code I provided is that yours only allows for two distinct discount periods while mine will support the tiered model. If we really are talking about tickets here, think about it like a timeline:

Now-------------------------------------------------------------------------ShowTime

At any time in that period, you may have surpassed a threshold (checkpoint, boundary, whatever) that qualifies you for a discount.

------------|------Now------------|------------------|---------------|---|---ShowTime

Since ShowTime is the stable piece of information in this time line, you need to capture "distance" from showtime and the applicable discount. The "distance" from ShowTime is the threshold that gets crossed.

Answer 3

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