How to name variables that represent thresholds or limits? - language-agnostic

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

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

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

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 4

Perhaps you could use a fluent interface to make the API a bit more expressive.
Consider the following:
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";
}
}
}
What an implementation of the TicketPolicy class that looks something like this:
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;
}
}
The interfaces are used to help intellisense navigate the user through the API and may not be necessary. They might look something like this:
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);
}