Displaying TimeSpan as largest interval (with units) - Part II [This is a follow-up question to: Displaying TimeSpan as largest interval (with units). The code listed here has been refactored since the original question was posed. Please note that the scope of this question is limited to the declaration and implementation of the listed method.]

The method listed below is used in a call center application to display an approximation of remaining time. For example, a call center telephone operator might inform a caller that they could perform their desired action after N time has elapsed, e.g., "Yes, that's right, you can order samples again in 2 days." Some arbitrary rules revolving around the interpretation of time are embedded within the method, e.g., an interval greater than 50 minutes is considered to be one hour; these business rules need to remain as is.

With that in mind, are there any suggestions on how this routine might be further enhanced and/or made more efficient?

public static string LargestIntervalWithUnits(TimeSpan interval)
{
    if (interval &lt; TimeSpan.Zero)
    {
        throw new ArgumentOutOfRangeException("interval",
                                              "Negative Timespans are not supported.");
    }

    // Numeric literals defined per business rules
    const double MinimumHoursDeemedOneDay = 22.0;
    const double MinimumMinutesDeemedOneHour = 50.0;
    const double MinimumSecondsDeemedOneMinute = 40.0;
    const double MinimumMillisecondsDeemedOneSecond = 500.0;

    int timeValue;
    string timeUnits;

    if (interval.TotalHours &gt; MinimumHoursDeemedOneDay)
    {
        timeValue = (int)Math.Ceiling(interval.TotalDays);
        timeUnits = "day";
    }
    else if (interval.TotalMinutes &gt; MinimumMinutesDeemedOneHour)
    {
        timeValue = (int)Math.Ceiling(interval.TotalHours);
        timeUnits = "hour";
    }
    else if (interval.TotalSeconds &gt; MinimumSecondsDeemedOneMinute)
    {
        timeValue = (int)Math.Ceiling(interval.TotalMinutes);
        timeUnits = "minute";
    }
    else if (interval.TotalMilliseconds &gt; MinimumMillisecondsDeemedOneSecond)
    {
        timeValue = (int)Math.Ceiling(interval.TotalSeconds);
        timeUnits = "second";
    }
    else
    {
        return "now";
    }

    return string.Format("{0:#,##0} {1}{2}",
                         timeValue,
                         timeUnits,
                         (timeValue == 1 ? string.Empty : "s"));
}
Your code is looking good, but I find the control flow in this version a bit easier to follow:

// Defined per business rules.
private static readonly TimeSpan MinimumIntervalDeemedOneDay = TimeSpan.FromHours(22);
private static readonly TimeSpan MinimumIntervalDeemedOneHour = TimeSpan.FromMinutes(50);
private static readonly TimeSpan MinimumIntervalDeemedOneMinute = TimeSpan.FromSeconds(40);
private static readonly TimeSpan MinimumIntervalDeemedOneSecond = TimeSpan.FromMilliseconds(500);

public static string LargestIntervalWithUnits(TimeSpan interval)
{
    if (interval &lt; TimeSpan.Zero)
    {
        throw new ArgumentOutOfRangeException("interval",
                                              "Negative Timespans are not supported.");
    }

    if (interval &gt; MinimumIntervalDeemedOneDay)
    {
        return FormatTime(interval.TotalDays, "day");
    }

    if (interval &gt; MinimumIntervalDeemedOneHour)
    {
        return FormatTime(interval.TotalHours, "hour");
    }

    if (interval &gt; MinimumIntervalDeemedOneMinute)
    {
        return FormatTime(interval.TotalMinutes, "minute");
    }

    if (interval &gt; MinimumIntervalDeemedOneSecond)
    {
        return FormatTime(interval.TotalSeconds, "second");
    }

    return "now";
}

private static string FormatTime(double value, string units)
{
    var ceiling = (int)Math.Ceiling(value);
    return string.Format("{0:#,##0} {1}{2}",
                         ceiling,
                         units,
                         (ceiling == 1 ? string.Empty : "s"));
}