Time Utilities class provides date and time related routines.
using System;
using System.Globalization;
namespace Utils
{
public static class TimeHelper
{
public static DateTime MinDateValue = new DateTime(1900, 1, 1, 0, 0, 0, 0, CultureInfo.InvariantCulture.Calendar, DateTimeKind.Utc);
/// <summary>
/// Displays a date in friendly format.
/// </summary>
/// <param name="Date"></param>
/// <param name="ShowTime"></param>
/// <returns>Today,Yesterday,Day of week or a string day (Jul 15, 2008)</returns>
public static string FriendlyDateString(DateTime date, bool showTime)
{
if (date < TimeHelper.MinDateValue)
{
return string.Empty;
}
string formattedDate = string.Empty;
if (date.Date.Equals(DateTime.Today))
{
formattedDate = "Today";
}
else if (date.Date == DateTime.Today.AddDays(-1))
{
formattedDate = "Yesterday";
}
else if (date.Date > DateTime.Today.AddDays(-6))
{
// Show the Day of the week
formattedDate = date.ToString("dddd").ToString();
}
else
{
formattedDate = date.ToString("MMMM dd, yyyy");
}
if (showTime)
{
formattedDate += string.Format(" @ {0}", date.ToString("t").ToLower().Replace(" ", ""));
}
return formattedDate;
}
/// <summary>
/// Returns a short date time string
/// </summary>
/// <param name="date"></param>
/// <param name="showTime"></param>
/// <returns></returns>
public static string ShortDateString(DateTime date, bool showTime=false)
{
if (date < TimeHelper.MinDateValue)
{
return string.Empty;
}
string dateString = date.ToString("MMM dd, yyyy");
if (!showTime)
{
return dateString;
}
return string.Format("{0} - {1}", dateString, date.ToString("h:mmtt").ToLower());
}
/// <summary>
/// Returns a short date time string
/// </summary>
/// <param name="date"></param>
/// <param name="ShowTime"></param>
/// <returns></returns>
public static string ShortDateString(DateTime? date, bool showTime)
{
if (date == null || !date.HasValue)
{
return string.Empty;
}
return ShortDateString(date.Value, showTime);
}
/// <summary>
/// Displays a number of milliseconds as friendly seconds, hours, minutes
/// Pass -1 to get a blank date.
/// </summary>
/// <param name="milliSeconds">the elapsed milliseconds to display time for</param>
/// <returns>string in format of just now or 1m ago, 2h ago</returns>
public static string FriendlyElapsedTimeString(int milliSeconds)
{
if (milliSeconds < 0)
{
return string.Empty;
}
if (milliSeconds < 60000)
{
return "just now";
}
if (milliSeconds < 3600000)
{
return string.Format("{0}m ago", ((milliSeconds / 60000)).ToString());
}
return string.Format("{0}h ago", ((milliSeconds / 3600000)).ToString());
}
/// <summary>
/// Displays the elapsed time friendly seconds, hours, minutes
/// </summary>
/// <param name="elapsed">Timespan of elapsed time</param>
/// <returns>string in format of just now or 1m ago, 2h ago</returns>
public static string FriendlyElapsedTimeString(TimeSpan elapsed)
{
return FriendlyElapsedTimeString((int)elapsed.TotalMilliseconds);
}
/// <summary>
/// Converts a fractional hour value like 1.25 to 1:15 hours:minutes format
/// </summary>
/// <param name="hours">Decimal hour value</param>
/// <param name="format">An optional format string where {0} is hours and {1} is minutes (ie: "{0}h:{1}m").</param>
/// <returns></returns>
public static string FractionalHoursToString(decimal hours, string format)
{
if (string.IsNullOrEmpty(format))
{
format = "{0}:{1}";
}
TimeSpan tspan = TimeSpan.FromHours((double)hours);
// Account for rounding error
int minutes = tspan.Minutes;
if (tspan.Seconds > 29)
{
minutes++;
}
return string.Format(format, tspan.Hours + tspan.Days * 24, minutes);
}
/// <summary>
/// Converts a fractional hour value like 1.25 to 1:15 hours:minutes format
/// </summary>
/// <param name="hours">Decimal hour value</param>
public static string FractionalHoursToString(decimal hours)
{
return FractionalHoursToString(hours, null);
}
/// <summary>
/// Rounds an hours value to a minute interval
/// 0 means no rounding
/// </summary>
/// <param name="minuteInterval">Minutes to round up or down to</param>
/// <returns></returns>
public static decimal RoundDateToMinuteInterval(decimal hours, int minuteInterval,
RoundingDirection direction)
{
if (minuteInterval == 0)
{
return hours;
}
decimal fraction = 60 / minuteInterval;
switch (direction)
{
case RoundingDirection.Round:
return Math.Round(hours * fraction, 0) / fraction;
case RoundingDirection.RoundDown:
return Math.Truncate(hours * fraction) / fraction;
}
return Math.Ceiling(hours * fraction) / fraction;
}
/// <summary>
/// Rounds a date value to a given minute interval
/// </summary>
/// <param name="time">Original time value</param>
/// <param name="minuteInterval">Number of minutes to round up or down to</param>
/// <returns></returns>
public static DateTime RoundDateToMinuteInterval(DateTime time, int minuteInterval,
RoundingDirection direction)
{
if (minuteInterval == 0)
{
return time;
}
decimal interval = minuteInterval;
decimal actMinute = time.Minute;
if (actMinute == 0.00M)
{
return time;
}
int newMinutes = 0;
switch (direction)
{
case RoundingDirection.Round:
newMinutes = (int)(Math.Round(actMinute / interval, 0) * interval);
break;
case RoundingDirection.RoundDown:
newMinutes = (int)(Math.Truncate(actMinute / interval) * interval);
break;
case RoundingDirection.RoundUp:
newMinutes = (int)(Math.Ceiling(actMinute / interval) * interval);
break;
}
// strip time
time = time.AddMinutes(time.Minute * -1);
time = time.AddSeconds(time.Second * -1);
time = time.AddMilliseconds(time.Millisecond * -1);
// add new minutes back on
return time.AddMinutes(newMinutes);
}
/// <summary>
/// Creates a DateTime value from date and time input values.
/// </summary>
/// <param name="Date"></param>
/// <param name="Time"></param>
/// <returns></returns>
public static DateTime DateTimeFromDateAndTime(string date, string time)
{
return DateTime.Parse(string.Format("{0} {1}", date, time));
}
/// <summary>
/// Creates a DateTime Value from a DateTime date and a string time value.
/// </summary>
/// <param name="Date"></param>
/// <param name="Time"></param>
/// <returns></returns>
public static DateTime DateTimeFromDateAndTime(DateTime date, string time)
{
return DateTime.Parse(string.Format("{0} {1}", date.ToShortDateString(), time));
}
/// <summary>
/// Converts the passed date time value to Mime formatted time string.
/// </summary>
/// <param name="Time"></param>
public static string MimeDateTime(DateTime time)
{
TimeSpan offset = TimeZone.CurrentTimeZone.GetUtcOffset(time);
string sOffset = null;
if (offset.Hours < 0)
{
sOffset = string.Format("-{0}", (offset.Hours * -1).ToString().PadLeft(2, '0'));
}
else
{
sOffset = string.Format("+{0}", offset.Hours.ToString().PadLeft(2, '0'));
}
sOffset += offset.Minutes.ToString().PadLeft(2, '0');
return string.Format("Date: {0} {1}", time.ToString("ddd, dd MMM yyyy HH:mm:ss",
System.Globalization.CultureInfo.InvariantCulture), sOffset);
}
/// <summary>
/// Truncates a DateTime value to the nearest partial value.
/// </summary>
/// <remarks>
/// From: http://stackoverflow.com/questions/1004698/how-to-truncate-milliseconds-off-of-a-net-datetime
/// </remarks>
/// <param name="date"></param>
/// <param name="resolution"></param>
/// <returns></returns>
public static DateTime Truncate(DateTime date, DateTimeResolution resolution = DateTimeResolution.Second)
{
switch (resolution)
{
case DateTimeResolution.Year:
return new DateTime(date.Year, 1, 1, 0, 0, 0, 0, date.Kind);
case DateTimeResolution.Month:
return new DateTime(date.Year, date.Month, 1, 0, 0, 0, date.Kind);
case DateTimeResolution.Day:
return new DateTime(date.Year, date.Month, date.Day, 0, 0, 0, date.Kind);
case DateTimeResolution.Hour:
return date.AddTicks(-(date.Ticks % TimeSpan.TicksPerHour));
case DateTimeResolution.Minute:
return date.AddTicks(-(date.Ticks % TimeSpan.TicksPerMinute));
case DateTimeResolution.Second:
return date.AddTicks(-(date.Ticks % TimeSpan.TicksPerSecond));
case DateTimeResolution.Millisecond:
return date.AddTicks(-(date.Ticks % TimeSpan.TicksPerMillisecond));
case DateTimeResolution.Tick:
return date.AddTicks(0);
default:
throw new ArgumentException("unrecognized resolution", "resolution");
}
}
/// <summary>
/// Returns TimeZone adjusted time for a given from a Utc or local time.
/// Date is first converted to UTC then adjusted.
/// </summary>
/// <param name="time"></param>
/// <param name="timeZoneId"></param>
/// <returns></returns>
public static DateTime ToTimeZoneTime(this DateTime time, string timeZoneId = "Central Standard Time")
{
TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
return time.ToTimeZoneTime(tzi);
}
/// <summary>
/// Returns TimeZone adjusted time for a given from a Utc or local time.
/// Date is first converted to UTC then adjusted.
/// </summary>
/// <param name="time"></param>
/// <param name="timeZoneId"></param>
/// <returns></returns>
public static DateTime ToTimeZoneTime(this DateTime time, TimeZoneInfo tzi)
{
return TimeZoneInfo.ConvertTimeFromUtc(time, tzi);
}
}
}