/// <summary>
/// Check if this DateTime is before <paramref name="compareDateTime"></paramref>, optionally at
/// <paramref name="part"></paramref>
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="compareDateTime">Compare Date</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>boolean</returns>
/// <example>10/20/2010 isBefore 12/31/2010, DateTimeParts.Year = false</example>
/// <example>10/20/2010 isBefore 01/01/2011, DateTimeParts.Year = true</example>
public static bool IsBefore(this DateTime dateTime, DateTime compareDateTime,
DateTimeParts part = DateTimeParts.None)
{
if (part == DateTimeParts.None) return dateTime < compareDateTime;
return dateTime.EndOf(part) < compareDateTime;
}
/// <summary>
/// Check if this DateTime is after <paramref name="compareDateTime"></paramref>, optionally at
/// <paramref name="part"></paramref>
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="compareDateTime">date to compare</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>boolean</returns>
public static bool IsAfter(this DateTime dateTime, DateTime compareDateTime,
DateTimeParts part = DateTimeParts.None)
{
if (part == DateTimeParts.None) return dateTime > compareDateTime;
return compareDateTime < dateTime.StartOf(part);
}
/// <summary>
/// Formats a single date/time value using the current settings.
/// </summary>
private string FormatDateTime(DateTime dt, DateTimeParts parts)
{
StringBuilder sb = new StringBuilder();
if (parts.HasFlag(DateTimeParts.Day) && ShowDayOfWeek)
{
sb.Append(parts.HasFlag(DateTimeParts.Month) ? "dddd, " : "dddd ");
}
if (parts.HasFlag(DateTimeParts.Day))
{
if (parts.HasFlag(DateTimeParts.Month))
{
if (UseDayMonthFormat)
{
sb.Append(UseFullMonthName ? "d MMMM" : "d MMM");
}
else
{
sb.Append(UseFullMonthName ? "MMMM d" : "MMM d");
}
}
else
{
sb.Append("%d");
}
}
if (parts.HasFlag(DateTimeParts.Year))
{
sb.Append(UseDayMonthFormat ? " yyyy" : ", yyyy");
}
return(dt.ToString(sb.ToString()));
}
/// <summary>
/// Check if this DateTime is the same as <paramref name="compareDateTime"></paramref>, optionally at
/// <paramref name="part"></paramref>
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="compareDateTime">date to compare</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>boolean</returns>
public static bool IsSame(this DateTime dateTime, DateTime compareDateTime,
DateTimeParts part = DateTimeParts.None)
{
if (part == DateTimeParts.None) return dateTime == compareDateTime;
return dateTime.StartOf(part) <= compareDateTime && compareDateTime <= dateTime.EndOf(part);
}
/// <summary>
/// Get the end of <paramref name="part" /> from DateTime.UtcNow. E.g. EndOf(DateTimeParts.Year)
/// return a new <see cref="System.DateTime" /> at the end of the current year.
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>DateTime at the end of give <paramref name="part"/></returns>
public static DateTime EndOf(this DateTime dateTime, DateTimeParts part)
{
switch (part)
{
case DateTimeParts.Year:
return(StartOf(dateTime, DateTimeParts.Year).AddYears(1).AddSeconds(-1));
case DateTimeParts.Month:
return(StartOf(dateTime, DateTimeParts.Month).AddMonths(1).AddSeconds(-1));
case DateTimeParts.Quarter:
return(StartOf(dateTime, DateTimeParts.Quarter).AddMonths(3).AddSeconds(-1));
case DateTimeParts.Week:
return(StartOf(dateTime, DateTimeParts.Week).AddDays(7).AddSeconds(-1));
case DateTimeParts.Day:
return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59, 0));
case DateTimeParts.Hour:
return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, 59, 59, 0));
case DateTimeParts.Minute:
return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, 59,
0));
case DateTimeParts.Second:
return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute,
dateTime.Second, 999));
default:
throw new ArgumentException("No valid part was provided", "part");
}
}
public string ConvertToLocalizedString(DateTime?date, string format, DateLocalizationOptions options = null)
{
options = options ?? new DateLocalizationOptions();
if (!date.HasValue)
{
return(options.NullText);
}
var dateValue = date.Value;
var offset = TimeSpan.Zero;
if (options.EnableTimeZoneConversion)
{
dateValue = ConvertToSiteTimeZone(dateValue);
offset = CurrentTimeZone.GetUtcOffset(date.Value);
}
var parts = DateTimeParts.FromDateTime(dateValue, offset);
if (options.EnableCalendarConversion && !(CurrentCalendar is GregorianCalendar))
{
parts = ConvertToSiteCalendar(dateValue, offset);
}
return(_dateFormatter.FormatDateTime(parts, format));
}
/// <summary>
/// Get the end of <paramref name="part" /> from DateTime.UtcNow. E.g. EndOf(DateTimeParts.Year)
/// return a new <see cref="System.DateTime" /> at the end of the current year.
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>DateTime at the end of give <paramref name="part"/></returns>
public static DateTime EndOf(this DateTime dateTime, DateTimeParts part)
{
switch (part)
{
case DateTimeParts.Year:
return StartOf(dateTime, DateTimeParts.Year).AddYears(1).AddSeconds(-1);
case DateTimeParts.Month:
return StartOf(dateTime, DateTimeParts.Month).AddMonths(1).AddSeconds(-1);
case DateTimeParts.Quarter:
return StartOf(dateTime, DateTimeParts.Quarter).AddMonths(3).AddSeconds(-1);
case DateTimeParts.Week:
return StartOf(dateTime, DateTimeParts.Week).AddDays(7).AddSeconds(-1);
case DateTimeParts.Day:
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 23, 59, 59, 0);
case DateTimeParts.Hour:
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, 59, 59, 0);
case DateTimeParts.Minute:
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, 59,
0);
case DateTimeParts.Second:
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute,
dateTime.Second, 999);
default:
throw new ArgumentException("No valid part was provided", "part");
}
}
public void EqualsTest01()
{
var target = new DateTimeParts(2014, 5, 31, 10, 0, 0, 0, DateTimeKind.Unspecified, offset: TimeSpan.Zero);
var other = new DateTimeParts(2014, 5, 31, 10, 0, 0, 0, DateTimeKind.Unspecified, offset: TimeSpan.Zero);
var result = target.Equals(other);
Assert.IsTrue(result);
}
public DateTime?ConvertFromLocalizedString(string dateString, string timeString, DateLocalizationOptions options = null)
{
options = options ?? new DateLocalizationOptions();
var hasDate = dateString != null && dateString != options.NullText;
var hasTime = timeString != null && timeString != options.NullText;
if (!hasDate && !hasTime)
{
return(null);
}
var parts = new DateTimeParts(
hasDate ? _dateFormatter.ParseDate(dateString) : DateParts.MinValue,
hasTime ? _dateFormatter.ParseTime(timeString) : TimeParts.MinValue
);
DateTime dateValue;
if (hasDate && options.EnableCalendarConversion && !(CurrentCalendar is GregorianCalendar))
{
dateValue = ConvertFromSiteCalendar(parts);
}
else
{
dateValue = parts.ToDateTime(new GregorianCalendar());
}
if (hasTime && options.EnableTimeZoneConversion)
{
// If there is no date component (technically the date component is that of DateTime.MinValue)
// then we must employ some trickery. With an undefined date it does not make sense
// to consider DST variations throughout the year, so we will use an arbitrary (but fixed)
// non-DST date for the conversion to ensure DST is never applied during conversion. The
// date part is usually DateTime.MinValue which we should not use because time zone
// conversion cannot wrap DateTime.MinValue around to the previous day, resulting in
// an undefined result. Instead we convert the date to a hard-coded date of 2000-01-01
// before the conversion, and back to the original date after.
if (!hasDate)
{
dateValue = new DateTime(2000, 1, 1, dateValue.Hour, dateValue.Minute, dateValue.Second, dateValue.Millisecond, dateValue.Kind);
}
dateValue = ConvertFromSiteTimeZone(dateValue);
if (!hasDate)
{
dateValue = new DateTime(DateTime.MinValue.Year, DateTime.MinValue.Month, DateTime.MinValue.Day, dateValue.Hour, dateValue.Minute, dateValue.Second, dateValue.Millisecond, dateValue.Kind);
}
}
if (options.EnableTimeZoneConversion)
{
dateValue = DateTime.SpecifyKind(dateValue, DateTimeKind.Utc);
}
return(dateValue);
}
public void ConvertFromSiteCalendarTest02()
{
var container = TestHelpers.InitializeContainer(null, "PersianCalendar", TimeZoneInfo.Utc);
var dateTimePartsPersian = new DateTimeParts(1376, 10, 25, 21, 0, 0, 0, DateTimeKind.Utc, TimeSpan.Zero);
var target = container.Resolve <IDateLocalizationServices>();
var result = target.ConvertFromSiteCalendar(dateTimePartsPersian);
var expected = new DateTime(1998, 1, 15, 21, 0, 0, DateTimeKind.Utc);
Assert.AreEqual(expected, result);
}
/// <summary>
/// Check if this DateTime is the same as <paramref name="compareDateTime"></paramref>, optionally at
/// <paramref name="part"></paramref>
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="compareDateTime">date to compare</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>boolean</returns>
public static bool IsSame(this DateTime dateTime, DateTime compareDateTime,
DateTimeParts part = DateTimeParts.None)
{
if (part == DateTimeParts.None)
{
return(dateTime == compareDateTime);
}
return(dateTime.StartOf(part) <= compareDateTime && compareDateTime <= dateTime.EndOf(part));
}
/// <summary>
/// Check if this DateTime is after <paramref name="compareDateTime"></paramref>, optionally at
/// <paramref name="part"></paramref>
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="compareDateTime">date to compare</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>boolean</returns>
public static bool IsAfter(this DateTime dateTime, DateTime compareDateTime,
DateTimeParts part = DateTimeParts.None)
{
if (part == DateTimeParts.None)
{
return(dateTime > compareDateTime);
}
return(compareDateTime < dateTime.StartOf(part));
}
/// <summary>
/// Check if this DateTime is before <paramref name="compareDateTime"></paramref>, optionally at
/// <paramref name="part"></paramref>
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="compareDateTime">Compare Date</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>boolean</returns>
/// <example>10/20/2010 isBefore 12/31/2010, DateTimeParts.Year = false</example>
/// <example>10/20/2010 isBefore 01/01/2011, DateTimeParts.Year = true</example>
public static bool IsBefore(this DateTime dateTime, DateTime compareDateTime,
DateTimeParts part = DateTimeParts.None)
{
if (part == DateTimeParts.None)
{
return(dateTime < compareDateTime);
}
return(dateTime.EndOf(part) < compareDateTime);
}
static string CalcDateName(DateTimeParts part, DateTime value)
{
// Attempting to match T-SQL behavior
// For any given datepart, if the values fall in the same part, then the result is zero. Then add 1 for each additional part that elapses.
// E.g. jan-12 to dec-12 is zero years difference, but dec-11 to jan-13 is two years difference, even thought the gap is only 4 months longer.
string result;
switch (part)
{
case DateTimeParts.Year:
result = value.Year.ToString();
break;
case DateTimeParts.Quarter:
result = QuarterNode.CalculateQuarter(value).ToString();
break;
case DateTimeParts.Month:
result = value.ToString("MMMM");
break;
case DateTimeParts.Day:
result = value.Day.ToString();
break;
case DateTimeParts.Week:
result = WeekNode.CalculateWeek(value).ToString();
break;
case DateTimeParts.Hour:
result = value.Hour.ToString();
break;
case DateTimeParts.Minute:
result = value.Minute.ToString();
break;
case DateTimeParts.Second:
result = value.Second.ToString();
break;
case DateTimeParts.DayOfYear:
result = value.DayOfYear.ToString();
break;
case DateTimeParts.Weekday:
result = value.ToString("dddd");
break;
default:
throw new InvalidOperationException(part.ToString());
}
return(result);
}
public DateTime?ConvertFromLocalizedString(string dateString, string timeString, DateLocalizationOptions options = null)
{
options = options ?? new DateLocalizationOptions();
var hasDate = dateString != null && dateString != options.NullText;
var hasTime = timeString != null && timeString != options.NullText;
if (!hasDate && !hasTime)
{
return(null);
}
var parts = new DateTimeParts(
hasDate ? _dateFormatter.ParseDate(dateString) : DateParts.MinValue,
hasTime ? _dateFormatter.ParseTime(timeString) : TimeParts.MinValue
);
DateTime dateValue;
if (hasDate && options.EnableCalendarConversion && !(CurrentCalendar is GregorianCalendar))
{
dateValue = ConvertFromSiteCalendar(parts);
}
else
{
dateValue = parts.ToDateTime(new GregorianCalendar());
}
if (hasTime && options.EnableTimeZoneConversion)
{
// If there is no date component (technically the date component is that of DateTime.MinValue) then
// we must employ some trickery, for two reasons:
// * DST can be active or not dependeng on the time of the year. We want the conversion to always act as if the time represents today, but we don't want that date stored.
// * Time zone conversion cannot wrap DateTime.MinValue around to the previous day, resulting in undefined result.
// Therefore we convert the date to today's date before the conversion, and back to DateTime.MinValue after.
if (!hasDate)
{
var now = _clock.UtcNow;
dateValue = new DateTime(now.Year, now.Month, now.Day, dateValue.Hour, dateValue.Minute, dateValue.Second, dateValue.Millisecond, dateValue.Kind);
}
dateValue = ConvertFromSiteTimeZone(dateValue);
if (!hasDate)
{
dateValue = new DateTime(DateTime.MinValue.Year, DateTime.MinValue.Month, DateTime.MinValue.Day, dateValue.Hour, dateValue.Minute, dateValue.Second, dateValue.Millisecond, dateValue.Kind);
}
}
if (options.EnableTimeZoneConversion)
{
dateValue = DateTime.SpecifyKind(dateValue, DateTimeKind.Utc);
}
return(dateValue);
}
public void Trim_WhenCalled_TrimToGivenPrecisionAndReturn()
{
//Arrange
var date = new DateTime(2021, 5, 2, 21, 34, 55, 500);
const DateTimeParts precision = DateTimeParts.Date | DateTimeParts.Milliseconds;
var expected = new DateTime(1, 1, 1, 21, 34, 55, 0);
//Act
var result = date.Trim(precision);
result.Should().Be(expected);
}
public virtual DateTime ConvertFromSiteCalendar(DateTimeParts parts)
{
return(new DateTime(
parts.Date.Year,
parts.Date.Month,
parts.Date.Day,
parts.Time.Hour,
parts.Time.Minute,
parts.Time.Second,
parts.Time.Millisecond,
CurrentCalendar,
parts.Time.Kind));
}
public static bool CalculateInLocalTimeZone(DateTimeParts part)
{
switch (part)
{
case DateTimeParts.Year:
case DateTimeParts.Quarter:
case DateTimeParts.Month:
return(true);
default:
return(false);
}
}
static int CalcDifference(DateTimeParts part, DateTime left, DateTime right)
{
// Attempting to match T-SQL behavior
// For any given datepart, if the values fall in the same part, then the result is zero. Then add 1 for each additional part that elapses.
// E.g. jan-12 to dec-12 is zero years difference, but dec-11 to jan-13 is two years difference, even thought the gap is only 4 months longer.
int result;
switch (part)
{
case DateTimeParts.Year:
result = right.Year - left.Year;
break;
case DateTimeParts.Quarter:
result = (right.Year * 12 + right.Month - 1) / 3 - (left.Year * 12 + left.Month - 1) / 3;
break;
case DateTimeParts.Month:
result = right.Year * 12 + right.Month - left.Year * 12 - left.Month;
break;
case DateTimeParts.Day:
result = (int)((right.Ticks / TimeSpan.TicksPerDay) - (left.Ticks / TimeSpan.TicksPerDay));
break;
case DateTimeParts.Week:
result = (int)((right.Ticks / TimeSpan.TicksPerDay + 1) / 7 - (left.Ticks / TimeSpan.TicksPerDay + 1) / 7);
break;
case DateTimeParts.Hour:
result = (int)((right.Ticks / TimeSpan.TicksPerHour) - (left.Ticks / TimeSpan.TicksPerHour));
break;
case DateTimeParts.Minute:
result = (int)((right.Ticks / TimeSpan.TicksPerMinute) - (left.Ticks / TimeSpan.TicksPerMinute));
break;
case DateTimeParts.Second:
result = (int)((right.Ticks / TimeSpan.TicksPerSecond) - (left.Ticks / TimeSpan.TicksPerSecond));
break;
// Because SQL just treats them the same as 'day' anyway.
case DateTimeParts.DayOfYear:
case DateTimeParts.Weekday:
default:
throw new InvalidOperationException(part.ToString());
}
return(result);
}
static DateTime AdjustDate(DateTimeParts part, int number, DateTime value)
{
DateTime result;
switch (part)
{
case DateTimeParts.Year:
result = value.AddYears(number);
break;
case DateTimeParts.Quarter:
result = value.AddMonths(number * 3);
break;
case DateTimeParts.Month:
result = value.AddMonths(number);
break;
case DateTimeParts.Day:
result = value.AddDays(number);
break;
case DateTimeParts.Week:
result = value.AddDays(number * 7);
break;
case DateTimeParts.Hour:
result = value.AddHours(number);
break;
case DateTimeParts.Minute:
result = value.AddMinutes(number);
break;
case DateTimeParts.Second:
result = value.AddSeconds(number);
break;
// Because SQL just treats them the same as 'day' anyway.
case DateTimeParts.DayOfYear:
case DateTimeParts.Weekday:
default:
throw new InvalidOperationException(part.ToString());
}
return(result);
}
public virtual string FormatDateTime(DateTimeParts parts, string format)
{
var useMonthNameGenitive = GetUseGenitiveMonthName(format);
var replacements = GetDateFormatReplacements(useMonthNameGenitive).Concat(GetTimeFormatReplacements()).ToDictionary(item => item.Key, item => item.Value);
var formatString = ConvertToFormatString(format, replacements);
var calendar = CurrentCalendar;
int twoDigitYear, hour12, offsetHours, offsetMinutes;
bool isPm;
string monthName, monthNameShort, monthNameGenitive, monthNameShortGenitive, dayName, dayNameShort, eraName, eraNameShort, amPm, amPmShort, timeZone, offsetSign, fraction1Zero, fraction2Zero, fraction3Zero, fraction1Digit, fraction2Digit, fraction3Digit;
GetDateFormatValues(parts.Date, calendar, out twoDigitYear, out monthName, out monthNameShort, out monthNameGenitive, out monthNameShortGenitive, out dayName, out dayNameShort, out eraName, out eraNameShort);
GetTimeFormatValues(parts.Time, out isPm, out hour12, out amPm, out amPmShort, out timeZone, out offsetSign, out offsetHours, out offsetMinutes, out fraction1Zero, out fraction2Zero, out fraction3Zero, out fraction1Digit, out fraction2Digit, out fraction3Digit);
return(String.Format(formatString, parts.Date.Year, twoDigitYear, parts.Date.Month, monthName, monthNameShort, monthNameGenitive, monthNameShortGenitive, parts.Date.Day, dayName, dayNameShort, eraName, eraNameShort, parts.Time.Hour, hour12, parts.Time.Minute, parts.Time.Second, fraction1Zero, fraction2Zero, fraction3Zero, fraction1Digit, fraction2Digit, fraction3Digit, amPm, amPmShort, timeZone, offsetSign, offsetHours, offsetMinutes));
}
public string ConvertToLocalizedTimeString(DateTime?date, DateLocalizationOptions options = null)
{
options = options ?? new DateLocalizationOptions();
if (!date.HasValue)
{
return(options.NullText);
}
var dateValue = date.Value;
var offset = TimeSpan.Zero;
if (options.EnableTimeZoneConversion)
{
if (options.IgnoreDate)
{
// The caller has asked us to ignore the date part. This usually because the source
// is a time-only field. In such cases (with an undefined date) it does not make sense
// to consider DST variations throughout the year, so we will use an arbitrary (but fixed)
// non-DST date for the conversion to ensure DST is never applied during conversion. The
// date part is usually DateTime.MinValue which we should not use because time zone
// conversion cannot wrap DateTime.MinValue around to the previous day, resulting in
// an undefined result. Instead we convert the date to a hard-coded date of 2000-01-01
// before the conversion, and back to the original date after.
var tempDate = new DateTime(2000, 1, 1, dateValue.Hour, dateValue.Minute, dateValue.Second, dateValue.Millisecond, dateValue.Kind);
tempDate = ConvertToSiteTimeZone(tempDate);
dateValue = new DateTime(dateValue.Year, dateValue.Month, dateValue.Day, tempDate.Hour, tempDate.Minute, tempDate.Second, tempDate.Millisecond, tempDate.Kind);
}
else
{
dateValue = ConvertToSiteTimeZone(dateValue);
}
offset = CurrentTimeZone.GetUtcOffset(date.Value);
}
var parts = DateTimeParts.FromDateTime(dateValue, offset);
// INFO: No calendar conversion in this method - we expect the date component to be DateTime.MinValue and irrelevant anyway.
return(_dateFormatter.FormatDateTime(parts, _dateTimeFormatProvider.LongTimeFormat));
}
public string ConvertToLocalizedTimeString(DateTime?date, DateLocalizationOptions options = null)
{
options = options ?? new DateLocalizationOptions();
if (!date.HasValue)
{
return(options.NullText);
}
var dateValue = date.Value;
var offset = TimeSpan.Zero;
if (options.EnableTimeZoneConversion)
{
if (options.IgnoreDate)
{
// The caller has asked us to ignore the date part and assume it is today. This usually because the source
// is a time-only field, in which case the date part is usually DateTime.MinValue which we should not use
// for the following reasons:
// * DST can be active or not dependeng on the time of the year. We want the conversion to always act as if the time represents today, but we don't want that date stored.
// * Time zone conversion cannot wrap DateTime.MinValue around to the previous day, resulting in undefined result.
// Therefore we convert the date to today's date before the conversion, and back to the original date after.
var today = _clock.UtcNow.Date;
var tempDate = new DateTime(today.Year, today.Month, today.Day, dateValue.Hour, dateValue.Minute, dateValue.Second, dateValue.Millisecond, dateValue.Kind);
tempDate = ConvertToSiteTimeZone(tempDate);
dateValue = new DateTime(dateValue.Year, dateValue.Month, dateValue.Day, tempDate.Hour, tempDate.Minute, tempDate.Second, tempDate.Millisecond, tempDate.Kind);
}
else
{
dateValue = ConvertToSiteTimeZone(dateValue);
}
offset = CurrentTimeZone.GetUtcOffset(date.Value);
}
var parts = DateTimeParts.FromDateTime(dateValue, offset);
// INFO: No calendar conversion in this method - we expect the date component to be DateTime.MinValue and irrelevant anyway.
return(_dateFormatter.FormatDateTime(parts, _dateTimeFormatProvider.LongTimeFormat));
}
/// <summary>
/// Get the start of this <paramref name="dateTime" /> at <paramref name="part" />. E.g.
/// DateTime.Now.StartOf(DateTimeParts.Year)
/// return a new <see cref="System.DateTime" /> at the start of the current year.
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>DateTime at the start of give <paramref name="part"/></returns>
public static DateTime StartOf(this DateTime dateTime, DateTimeParts part)
{
switch (part)
{
case DateTimeParts.Year:
return(new DateTime(dateTime.Year, 1, 1));
case DateTimeParts.Month:
return(new DateTime(dateTime.Year, dateTime.Month, 1));
case DateTimeParts.Quarter:
return(new DateTime(dateTime.Year, ((dateTime.Month - 1) / 3) * 3 + 1, 1));
case DateTimeParts.Week:
dateTime = dateTime.StartOf(DateTimeParts.Day);
var ci = CultureInfo.CurrentCulture;
var first = (int)ci.DateTimeFormat.FirstDayOfWeek;
var current = (int)dateTime.DayOfWeek;
return(first <= current
? dateTime.AddDays(-1 *(current - first))
: dateTime.AddDays(first - current - 7));
case DateTimeParts.Day:
return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 0, 0, 0, 0));
case DateTimeParts.Hour:
return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, 0, 0, 0));
case DateTimeParts.Minute:
return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, 0,
0));
case DateTimeParts.Second:
return(new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute,
dateTime.Second, 0));
default:
throw new ArgumentException("No valid part was provided", "part");
}
}
/// <summary>
/// Extract the year/month/date and hours/minutes/seconds from a date timestamp. Examples to use: 2014-08-18T13:03:25Z or 2014/08/18T13:03:25Z
/// Try it as well with: 2014-08-18 or 2014/08/18
/// </summary>
/// <param name="dt"> Enter a Date Time Value </param>
/// <returns>DateTimeParts Class</returns>
public DateTimeParts GetRegExValue(DateTime dt)
{
//For the sake of example I put some logic in the controller
//If this were real world most if not all the logic would be held elsewhere.
var myClass = new DateTimeParts();
if (DateTime.TryParse(dt.ToString(CultureInfo.InvariantCulture), out _))
{
// Yay your are validated :)
var s = dt.ToString("yyyy-MM-dd-hh-mm-ss");
var r = new Regex(@"\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2}");
var m = r.Match(s);
var myList = new List <string>();
if (m.Success)
{
var input = m.ToString();
var pattern = "(-)";
var substrings = Regex.Split(input, pattern); // Split on hyphens
myList.AddRange(substrings.Where(match => match != "-"));
myClass.Year = Convert.ToInt32(myList[0]);
myClass.Month = Convert.ToInt32(myList[1]);
myClass.Day = Convert.ToInt32(myList[2]);
myClass.Hour = Convert.ToInt32(myList[3]);
myClass.Minute = Convert.ToInt32(myList[4]);
myClass.Second = Convert.ToInt32(myList[5]);
myClass.WeekDay = (int)dt.DayOfWeek;
myClass.DateTime = dt;
myClass.DayString = dt.DayOfWeek.ToString();
myClass.MonthString = dt.ToString("MMMM");
}
}
else
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
return(myClass);
}
/// <summary>
/// Formats a single date/time value using the current settings.
/// </summary>
private static string FormatDateTime(DateTime dt, DateTimeParts parts)
{
StringBuilder sb = new StringBuilder();
if (parts.HasFlag(DateTimeParts.Day))
{
if (parts.HasFlag(DateTimeParts.Month))
{
sb.Append("d MMM");
}
else
{
sb.Append("%d");
}
}
if (parts.HasFlag(DateTimeParts.Year))
{
sb.Append(" yyyy");
}
return(dt.ToString(sb.ToString()));
}
/// <summary>
/// Get the end of <paramref name="part" /> from DateTime.UtcNow. E.g. EndOf(DateTimeParts.Year)
/// return a new <see cref="System.DateTime" /> at the end of the current year.
/// </summary>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>DateTime at the end of give <paramref name="part"/></returns>
public static DateTime EndOf(DateTimeParts part)
{
return EndOf(DateTime.UtcNow, part);
}
/// <summary>
/// Get the start of this <paramref name="dateTime" /> at <paramref name="part" />. E.g.
/// DateTime.Now.StartOf(DateTimeParts.Year)
/// return a new <see cref="System.DateTime" /> at the start of the current year.
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>DateTime at the start of give <paramref name="part"/></returns>
public static DateTime StartOf(this DateTime dateTime, DateTimeParts part)
{
switch (part)
{
case DateTimeParts.Year:
return new DateTime(dateTime.Year, 1, 1);
case DateTimeParts.Month:
return new DateTime(dateTime.Year, dateTime.Month, 1);
case DateTimeParts.Quarter:
return new DateTime(dateTime.Year, ((dateTime.Month - 1)/3)*3 + 1, 1);
case DateTimeParts.Week:
dateTime = dateTime.StartOf(DateTimeParts.Day);
var ci = CultureInfo.CurrentCulture;
var first = (int) ci.DateTimeFormat.FirstDayOfWeek;
var current = (int) dateTime.DayOfWeek;
return first <= current
? dateTime.AddDays(-1*(current - first))
: dateTime.AddDays(first - current - 7);
case DateTimeParts.Day:
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, 0, 0, 0, 0);
case DateTimeParts.Hour:
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, 0, 0, 0);
case DateTimeParts.Minute:
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, 0,
0);
case DateTimeParts.Second:
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute,
dateTime.Second, 0);
default:
throw new ArgumentException("No valid part was provided", "part");
}
}
public void FormatDateTimeTest04()
{
var allCases = new ConcurrentBag <string>();
var failedCases = new ConcurrentDictionary <string, Exception>();
var maxFailedCases = 0;
var options = new ParallelOptions();
if (Debugger.IsAttached)
{
options.MaxDegreeOfParallelism = 1;
}
var allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
Parallel.ForEach(allCultures, options, culture => { // All cultures on the machine.
var container = TestHelpers.InitializeContainer(culture.Name, "GregorianCalendar", TimeZoneInfo.Utc);
var formats = container.Resolve <IDateTimeFormatProvider>();
var target = container.Resolve <IDateFormatter>();
foreach (var dateTimeFormat in formats.AllDateTimeFormats) // All date/time formats supported by the culture.
{
foreach (var millisecond in new[] { 0, 10, 500, 990, 999 }) // Enough values to cover all fraction rounding cases.
{
DateTime dateTime = new DateTime(1998, 1, 1, 10, 30, 30, millisecond);
DateTimeParts dateTimeParts = new DateTimeParts(1998, 1, 1, 10, 30, 30, millisecond, DateTimeKind.Unspecified, offset: TimeSpan.Zero);
// Print reference string using Gregorian calendar to avoid calendar conversion.
var cultureGregorian = (CultureInfo)culture.Clone();
cultureGregorian.DateTimeFormat.Calendar = cultureGregorian.OptionalCalendars.OfType <GregorianCalendar>().First();
var caseKey = String.Format("{0}___{1}___{2}", culture.Name, dateTimeFormat, dateTimeParts);
allCases.Add(caseKey);
//Debug.WriteLine(String.Format("{0} cases tested so far. Testing case {1}...", allCases.Count, caseKey));
try {
var result = target.FormatDateTime(dateTimeParts, dateTimeFormat);
var expected = dateTime.ToString(dateTimeFormat, cultureGregorian);
if (result != expected)
{
// The .NET date formatting logic contains a bug that causes it to recognize 'd' and 'dd'
// as numerical day specifiers even when they are embedded in literals. Our implementation
// does not contain this bug. If we encounter an unexpected result and the .NET reference
// result contains the genitive month name, replace it with the non-genitive month name
// before asserting.
var numericalDayPattern = @"(\b|[^d])d{1,2}(\b|[^d])";
var containsNumericalDay = Regex.IsMatch(dateTimeFormat, numericalDayPattern);
if (containsNumericalDay)
{
var monthName = formats.MonthNames[0];
var monthNameGenitive = formats.MonthNamesGenitive[0];
expected = expected.Replace(monthNameGenitive, monthName);
}
}
Assert.AreEqual(expected, result);
}
catch (Exception ex) {
failedCases.TryAdd(caseKey, ex);
}
}
}
});
if (failedCases.Count > maxFailedCases)
{
throw new AggregateException(String.Format("Format tests failed for {0} of {1} cases. Expected {2} failed cases or less.", failedCases.Count, allCases.Count, maxFailedCases), failedCases.Values);
}
}
public virtual string FormatDateTime(DateTimeParts parts)
{
return(FormatDateTime(parts, _dateTimeFormatProvider.ShortDateTimeFormat));
}
public void FormatDateTimeTest03()
{
var allCases = new ConcurrentBag <string>();
var failedCases = new ConcurrentDictionary <string, Exception>();
var maxFailedCases = 0;
var options = new ParallelOptions();
if (Debugger.IsAttached)
{
options.MaxDegreeOfParallelism = 1;
}
var allCultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
Parallel.ForEach(allCultures, options, culture => { // All cultures on the machine.
foreach (var timeZone in new[] { TimeZoneInfo.Utc, TimeZoneInfo.Local, TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"), TimeZoneInfo.FindSystemTimeZoneById("Iran Standard Time") }) // Enough time zones to get good coverage: UTC, local, one negative offset and one positive offset.
{
var container = TestHelpers.InitializeContainer(culture.Name, "GregorianCalendar", timeZone);
var formats = container.Resolve <IDateTimeFormatProvider>();
var target = container.Resolve <IDateFormatter>();
foreach (var dateTimeFormat in formats.AllDateTimeFormats) // All date/time formats supported by the culture.
// Unfortunately because the System.Globalization classes are tightly coupled to the
// configured culture, calendar and time zone of the local machine, it's not possible
// to test all scenarios and combinations while still relying on the .NET Framework
// date/time formatting logic for reference. Therefore the logic of this test code takes
// into account the configured local time zone of the machine when determining values for
// DateTimeKind and offset. Less than ideal, but there really is no way around it.
{
var kind = DateTimeKind.Unspecified;
var offset = timeZone.BaseUtcOffset;
if (timeZone == TimeZoneInfo.Utc)
{
kind = DateTimeKind.Utc;
}
else if (timeZone == TimeZoneInfo.Local)
{
kind = DateTimeKind.Local;
}
var dateTime = new DateTime(1998, 1, 1, 10, 30, 30, 678, kind);
var dateTimeOffset = new DateTimeOffset(dateTime, timeZone.BaseUtcOffset);
var dateTimeParts = DateTimeParts.FromDateTime(dateTime, offset);
// Print reference string using Gregorian calendar to avoid calendar conversion.
var cultureGregorian = (CultureInfo)culture.Clone();
cultureGregorian.DateTimeFormat.Calendar = cultureGregorian.OptionalCalendars.OfType <GregorianCalendar>().First();
var caseKey = String.Format("{0}___{1}___{2}", culture.Name, dateTimeFormat, dateTimeParts);
allCases.Add(caseKey);
//Debug.WriteLine(String.Format("{0} cases tested so far. Testing case {1}...", allCases.Count, caseKey));
try {
var result = target.FormatDateTime(dateTimeParts, dateTimeFormat);
var expected = dateTimeOffset.ToString(dateTimeFormat, cultureGregorian);
// The .NET DateTimeOffset class is buggy. Firstly, it does not preserve the DateTimeKind value of the
// DateTime from which it is created, causing it to never format "K" to "Z" for the UTC time zone. Secondly it
// does not properly format "K" to an empty string for DateTimeKind.Unspecified. Our implementation
// does not contain these bugs. Therefore for these two scenarios we use the DateTime formatting as a
// reference instead.
if (kind == DateTimeKind.Utc || (kind == DateTimeKind.Unspecified && dateTimeFormat.Contains('K')))
{
expected = dateTime.ToString(dateTimeFormat, cultureGregorian);
}
if (result != expected)
{
// The .NET date formatting logic contains a bug that causes it to recognize 'd' and 'dd'
// as numerical day specifiers even when they are embedded in literals. Our implementation
// does not contain this bug. If we encounter an unexpected result and the .NET reference
// result contains the genitive month name, replace it with the non-genitive month name
// before asserting.
var numericalDayPattern = @"(\b|[^d])d{1,2}(\b|[^d])";
var containsNumericalDay = Regex.IsMatch(dateTimeFormat, numericalDayPattern);
if (containsNumericalDay)
{
var monthName = formats.MonthNames[0];
var monthNameGenitive = formats.MonthNamesGenitive[0];
expected = expected.Replace(monthNameGenitive, monthName);
}
}
Assert.AreEqual(expected, result);
}
catch (Exception ex) {
failedCases.TryAdd(caseKey, ex);
}
}
}
});
if (failedCases.Count > maxFailedCases)
{
throw new AggregateException(String.Format("Format tests failed for {0} of {1} cases. Expected {2} failed cases or less.", failedCases.Count, allCases.Count, maxFailedCases), failedCases.Values);
}
}
/// <summary>
/// Check if this DateTime is between <paramref name="fromDate"></paramref> and <paramref name="toDate"></paramref>,
/// optionally at <paramref name="part"></paramref>
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="fromDate">Start Date</param>
/// <param name="toDate">End Date</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>boolean</returns>
public static bool IsBetween(this DateTime dateTime, DateTime fromDate, DateTime toDate,
DateTimeParts part = DateTimeParts.None)
{
return dateTime.IsAfter(fromDate, part) && dateTime.IsBefore(toDate, part);
}
/// <summary>
/// Get the end of <paramref name="part" /> from DateTime.UtcNow. E.g. EndOf(DateTimeParts.Year)
/// return a new <see cref="System.DateTime" /> at the end of the current year.
/// </summary>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>DateTime at the end of give <paramref name="part"/></returns>
public static DateTime EndOf(DateTimeParts part)
{
return(EndOf(DateTime.UtcNow, part));
}
/// <summary>
/// Get the start of <paramref name="part" /> from DateTime.UtcNow. E.g. StartOf(DateTimeParts.Year)
/// return a new <see cref="System.DateTime" /> at the start of the current year.
/// </summary>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>DateTime at the start of give <paramref name="part"/></returns>
public static DateTime StartOf(DateTimeParts part)
{
return(StartOf(DateTime.UtcNow, part));
}
/// <summary>
/// Check if this DateTime is between <paramref name="fromDate"></paramref> and <paramref name="toDate"></paramref>,
/// optionally at <paramref name="part"></paramref>
/// </summary>
/// <param name="dateTime">this DateTime</param>
/// <param name="fromDate">Start Date</param>
/// <param name="toDate">End Date</param>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>boolean</returns>
public static bool IsBetween(this DateTime dateTime, DateTime fromDate, DateTime toDate,
DateTimeParts part = DateTimeParts.None)
{
return(dateTime.IsAfter(fromDate, part) && dateTime.IsBefore(toDate, part));
}
/// <summary>
/// Get the start of <paramref name="part" /> from DateTime.UtcNow. E.g. StartOf(DateTimeParts.Year)
/// return a new <see cref="System.DateTime" /> at the start of the current year.
/// </summary>
/// <param name="part"><see cref="DateTimeParts"/></param>
/// <returns>DateTime at the start of give <paramref name="part"/></returns>
public static DateTime StartOf(DateTimeParts part)
{
return StartOf(DateTime.UtcNow, part);
}
/// <summary>
///
/// </summary>
/// <param name="datetime"></param>
/// <param name="parts"></param>
/// <param name="DateSpraster"></param>
/// <param name="TimeSp"></param>
/// <returns></returns>
public static string FormatAs(this DateTime datetime, DateTimeParts parts, char DateSpraster, char TimeSp)
{
return(string.Empty);
}
