| public abstract GetMonth ( DateTime time ) : int | ||
| time | DateTime | |
| return | int | |
/// <summary>
/// Initializes a new instance of <see cref="Age"/>.
/// </summary>
/// <param name="start">The date and time when the age started.</param>
/// <param name="end">The date and time when the age ended.</param>
/// <param name="calendar">Calendar used to calculate age.</param>
public Age(DateTime start, DateTime end, Calendar calendar)
{
if (start > end) throw new ArgumentException("The starting date cannot be later than the end date.");
var startDate = start.Date;
var endDate = end.Date;
_years = _months = _days = 0;
_days += calendar.GetDayOfMonth(endDate) - calendar.GetDayOfMonth(startDate);
if (_days < 0)
{
_days += calendar.GetDaysInMonth(calendar.GetYear(startDate), calendar.GetMonth(startDate));
_months--;
}
_months += calendar.GetMonth(endDate) - calendar.GetMonth(startDate);
if (_months < 0)
{
_months += calendar.GetMonthsInYear(calendar.GetYear(startDate));
_years--;
}
_years += calendar.GetYear(endDate) - calendar.GetYear(startDate);
var ts = endDate.Subtract(startDate);
_totalDays = (Int32)ts.TotalDays;
}
CalendarDay getDay(DateTime d, DateTime todaysDate, DateTime visibleDate, System.Globalization.Calendar threadCalendar)
{
int dayOfWeek = (int)threadCalendar.GetDayOfWeek(d);
int dayOfMonth = threadCalendar.GetDayOfMonth(d);
string dayNumberText = d.ToString("dd", CultureInfo.CurrentCulture);
int visibleDateMonth = threadCalendar.GetMonth(visibleDate);
return(new CalendarDay(d,
(dayOfWeek == 0 || dayOfWeek == 6), // IsWeekend
d.Equals(todaysDate), // IsToday
threadCalendar.GetMonth(d) != visibleDateMonth, // IsOtherMonth
dayNumberText // Number Text
));
}
public virtual DateTime GetToDate(DateTime dt, System.Globalization.Calendar calendar)
{
if (this.Order == 1 && this.FromMonth > this.ToMonth)
{
if (calendar.GetMonth(dt) == 12)
{
//در اولین بازه محدوده، ماه شروع در سال قبل قرار گرفته
dt = calendar.AddYears(dt, 1);
}
}
if (this.Order == 12 && this.FromMonth > this.ToMonth)
{
if (calendar.GetMonth(dt) == 12)
{
//در آخرین بازه محدوده، ماه پایان در سال بعد قرار گرفته
dt = calendar.AddYears(dt, 1);
}
}
else if (this.Order == 0 && this.FromMonth >= this.ToMonth)
{
//بازه سالانه است و پایان در سال بعد قرار گرفته
dt = calendar.AddYears(dt, 1);
}
if (calendar is PersianCalendar)
{
if (calendar.IsLeapYear(calendar.GetYear(dt)) && this.ToMonth == 12 && this.ToDay == 29)
{
return(calendar.ToDateTime(calendar.GetYear(dt), this.ToMonth, 30, 0, 0, 0, 0));
}
else
{
return(calendar.ToDateTime(calendar.GetYear(dt), this.ToMonth, this.ToDay, 0, 0, 0, 0));
}
}
else
{
if (calendar.IsLeapYear(dt.Year) && this.ToMonth == 2 && this.ToDay == 28)
{
//اگر سال کبسه بود و برای ماه فوریه روز 28 انتخاب شده بود
//به صورت خودکار با روز 29 جایگزین می شود
return(calendar.ToDateTime(dt.Year, this.ToMonth, 29, 0, 0, 0, 0));
}
else
{
return(calendar.ToDateTime(dt.Year, this.ToMonth, this.ToDay, 0, 0, 0, 0));
}
}
}
private string GetDateInCalendar(System.Globalization.Calendar calendar, DateTime dateTime)
{
return(string.Format("{0:0000}/{1:00}/{2:00}",
calendar.GetYear(dateTime),
calendar.GetMonth(dateTime),
calendar.GetDayOfMonth(dateTime)));
}
/// <summary>
/// Checks that each day from the given start year to the end year (inclusive) is equal
/// between the BCL and the Noda Time calendar. Additionally, the number of days in each month and year
/// and the number of months (and leap year status) in each year is checked.
/// </summary>
internal static void AssertEquivalent(Calendar bcl, CalendarSystem noda, int fromYear, int toYear)
{
// We avoid asking the BCL to create a DateTime on each iteration, simply
// because the BCL implementation is so slow. Instead, we just check at the start of each month that
// we're at the date we expect.
DateTime bclDate = bcl.ToDateTime(fromYear, 1, 1, 0, 0, 0, 0);
for (int year = fromYear; year <= toYear; year++)
{
Assert.AreEqual(bcl.GetDaysInYear(year), noda.GetDaysInYear(year), "Year: {0}", year);
Assert.AreEqual(bcl.GetMonthsInYear(year), noda.GetMonthsInYear(year), "Year: {0}", year);
for (int month = 1; month <= noda.GetMonthsInYear(year); month++)
{
// Sanity check at the start of each month. Even this is surprisingly slow.
// (These three tests make up about 20% of the total execution time for the test.)
Assert.AreEqual(year, bcl.GetYear(bclDate));
Assert.AreEqual(month, bcl.GetMonth(bclDate));
Assert.AreEqual(1, bcl.GetDayOfMonth(bclDate));
Assert.AreEqual(bcl.GetDaysInMonth(year, month), noda.GetDaysInMonth(year, month),
"Year: {0}; Month: {1}", year, month);
Assert.AreEqual(bcl.IsLeapYear(year), noda.IsLeapYear(year), "Year: {0}", year);
for (int day = 1; day <= noda.GetDaysInMonth(year, month); day++)
{
LocalDate nodaDate = new LocalDate(year, month, day, noda);
Assert.AreEqual(bclDate, nodaDate.ToDateTimeUnspecified(),
"Original calendar system date: {0:yyyy-MM-dd}", nodaDate);
Assert.AreEqual(nodaDate, LocalDate.FromDateTime(bclDate, noda));
Assert.AreEqual(year, nodaDate.Year);
Assert.AreEqual(month, nodaDate.Month);
Assert.AreEqual(day, nodaDate.Day);
bclDate = bclDate.AddDays(1);
}
}
}
}
private string GetDateTimeInPersianCalendar(DateTime dateTime)
{
return(string.Format("{0:0000}/{1:00}/{2:00}-{3:00}:{4:00}",
PersianCalendar.GetYear(dateTime),
PersianCalendar.GetMonth(dateTime),
PersianCalendar.GetDayOfMonth(dateTime),
PersianCalendar.GetHour(dateTime), PersianCalendar.GetMinute(dateTime)));
}
public DateTimePickerControl()
{
InitializeComponent();
monthNumber = currentCalendar.GetMonth(DateTime.Today);
yearNumber = currentCalendar.GetYear(DateTime.Today);
var months = CultureInfo.CurrentCulture.DateTimeFormat.MonthNames;
Array.Resize <string>(ref months, 12);
monthBox.ItemsSource = months;
yearBox.Text = $"{currentCalendar.GetYear(SelectedDate)}";
monthBox.SelectedIndex = monthNumber - 1;
Update();
}
// Token: 0x06002F19 RID: 12057 RVA: 0x000B4AF4 File Offset: 0x000B2CF4
internal void TimeToLunar(DateTime time, ref int year, ref int month, ref int day)
{
Calendar defaultInstance = GregorianCalendar.GetDefaultInstance();
int year2 = defaultInstance.GetYear(time);
int month2 = defaultInstance.GetMonth(time);
int dayOfMonth = defaultInstance.GetDayOfMonth(time);
this.GregorianToLunar(year2, month2, dayOfMonth, ref year, ref month, ref day);
}
public DayInformationModel()
{
_year = _myCal.GetYear(DateTime.Today);
_month = _myCal.GetMonth(DateTime.Today);
_day = _myCal.GetDayOfMonth(DateTime.Today);
_numDaysBeingDisplayed = 3;
InitModel();
}
public void FromDateTime(Calendar cal, DateTime time) {
Date dmy = new Date();
dmy.Day = cal.GetDayOfMonth(time);
dmy.Month = cal.GetMonth(time);
dmy.Year = cal.GetYear(time);
dmy.Era = cal.GetEra(time);
Day = dmy.Day;
Month = dmy.Month;
Year = dmy.Year;
Era = dmy.Era;
}
internal void TimeToLunar(DateTime time, ref int year, ref int month, ref int day)
{
int gy = 0; int gm = 0; int gd = 0;
Calendar Greg = GregorianCalendar.GetDefaultInstance();
gy = Greg.GetYear(time);
gm = Greg.GetMonth(time);
gd = Greg.GetDayOfMonth(time);
GregorianToLunar(gy, gm, gd, ref year, ref month, ref day);
}
internal void TimeToLunar(DateTime time, ref int year, ref int month, ref int day)
{
Calendar defaultInstance = GregorianCalendar.GetDefaultInstance();
DateTime time1 = time;
int year1 = defaultInstance.GetYear(time1);
DateTime time2 = time;
int month1 = defaultInstance.GetMonth(time2);
DateTime time3 = time;
int dayOfMonth = defaultInstance.GetDayOfMonth(time3);
this.GregorianToLunar(year1, month1, dayOfMonth, ref year, ref month, ref day);
}
internal void TimeToLunar(DateTime time, ref int year, ref int month, ref int day)
{
int nSYear = 0;
int nSMonth = 0;
int nSDate = 0;
Calendar defaultInstance = GregorianCalendar.GetDefaultInstance();
nSYear = defaultInstance.GetYear(time);
nSMonth = defaultInstance.GetMonth(time);
nSDate = defaultInstance.GetDayOfMonth(time);
this.GregorianToLunar(nSYear, nSMonth, nSDate, ref year, ref month, ref day);
}
public virtual DateTime GetFromDate(DateTime dt, System.Globalization.Calendar calendar)
{
if (this.Order == 1 && this.FromMonth > this.ToMonth)
{
if (calendar.GetMonth(dt) == 1)
{
//در اولین بازه محدوده، ماه شروع در سال قبل قرار گرفته
dt = calendar.AddYears(dt, -1);
}
}
else if (this.Order == 0 && this.FromMonth >= this.ToMonth)
{
//بازه سالانه است و شروع در سال قبل قرار گرفته
dt = calendar.AddYears(dt, -1);
}
return(calendar.ToDateTime(calendar.GetYear(dt), this.FromMonth, this.FromDay, 0, 0, 0, 0));
}
public static DateTime?SetYearMonth(DateTime date, DateTime yearMonth)
{
DateTime?target = SetYear(date, yearMonth);
if (target.HasValue)
{
int month = cal.GetMonth(date);
int newMonth = cal.GetMonth(yearMonth);
target = DateTimeHelper.AddMonths(target.Value, newMonth - month);
}
return(target);
}
/// <summary>
/// Initializes a new instance of the <see cref="MonthCalendarDate"/> class.
/// </summary>
/// <param name="cal">The calendar to use.</param>
/// <param name="date">The gregorian date.</param>
/// <exception cref="ArgumentNullException">If <paramref name="cal"/> is <c>null</c>.</exception>
public MonthCalendarDate(Calendar cal, DateTime date)
{
if (cal == null)
{
throw new ArgumentNullException("cal", "parameter 'cal' cannot be null.");
}
if (date < cal.MinSupportedDateTime)
{
date = cal.MinSupportedDateTime;
}
if (date > cal.MaxSupportedDateTime)
{
date = cal.MaxSupportedDateTime;
}
this.Year = cal.GetYear(date);
this.Month = cal.GetMonth(date);
this.Day = cal.GetDayOfMonth(date);
this.Era = cal.GetEra(date);
this.calendar = cal;
}
private static int ToDateTimeMonth( Calendar calendar, DateTime value )
{
Contract.Requires( calendar != null );
Contract.Ensures( Contract.Result<int>() > 0 );
var epoch = calendar.FirstMonthOfYear();
var month = calendar.GetMonth( value );
var actual = ( epoch + month ) - 1;
return actual > 12 ? ( actual - 12 ) : actual;
}
// ----------------------------------------------------------------------
// extract of DateDiff.CalcYears()
private static int YearDiff( DateTime date1, DateTime date2, Calendar calendar )
{
if ( date1.Equals( date2 ) )
{
return 0;
}
int year1 = calendar.GetYear( date1 );
int month1 = calendar.GetMonth( date1 );
int year2 = calendar.GetYear( date2 );
int month2 = calendar.GetMonth( date2 );
// find the the day to compare
int compareDay = date2.Day;
int compareDaysPerMonth = calendar.GetDaysInMonth( year1, month1 );
if ( compareDay > compareDaysPerMonth )
{
compareDay = compareDaysPerMonth;
}
// build the compare date
DateTime compareDate = new DateTime( year1, month2, compareDay,
date2.Hour, date2.Minute, date2.Second, date2.Millisecond );
if ( date2 > date1 )
{
if ( compareDate < date1 )
{
compareDate = compareDate.AddYears( 1 );
}
}
else
{
if ( compareDate > date1 )
{
compareDate = compareDate.AddYears( -1 );
}
}
return year2 - calendar.GetYear( compareDate );
}
/// <summary>
/// DateDiff in SQL style.
/// Date-part implemented:
/// "year" (abbr. "yy", "yyyy"),
/// "quarter" (abbr. "qq", "q"),
/// "month" (abbr. "mm", "m"),
/// "day" (abbr. "dd", "d"),
/// "week" (abbr. "wk", "ww"),
/// "hour" (abbr. "hh"),
/// "minute" (abbr. "mi", "n"),
/// "second" (abbr. "ss", "s"),
/// "millisecond" (abbr. "ms").
/// </summary>
/// <param name="startDate">The start date.</param>
/// <param name="endDate">The end date.</param>
/// <param name="datePart">The date part.</param>
/// <returns>Date Difference in System.long</returns>
/// <exception cref="Exception"></exception>
public static long DateDiff(this DateTime startDate, DateTime endDate, string datePart)
{
long DateDiffVal = 0;
System.Globalization.Calendar cal = System.Threading.Thread.CurrentThread.CurrentCulture.Calendar;
TimeSpan ts = new TimeSpan(endDate.Ticks - startDate.Ticks);
switch (datePart.ToLower().Trim())
{
#region year
case "year":
case "yy":
case "yyyy":
DateDiffVal = (long)(cal.GetYear(endDate) - cal.GetYear(startDate));
break;
#endregion
#region quarter
case "quarter":
case "qq":
case "q":
DateDiffVal = (long)((((cal.GetYear(endDate)
- cal.GetYear(startDate)) * 4)
+ ((cal.GetMonth(endDate) - 1) / 3))
- ((cal.GetMonth(startDate) - 1) / 3));
break;
#endregion
#region month
case "month":
case "mm":
case "m":
DateDiffVal = (long)(((cal.GetYear(endDate)
- cal.GetYear(startDate)) * 12
+ cal.GetMonth(endDate))
- cal.GetMonth(startDate));
break;
#endregion
#region day
case "day":
case "d":
case "dd":
DateDiffVal = (long)ts.TotalDays;
break;
#endregion
#region week
case "week":
case "wk":
case "ww":
DateDiffVal = (long)(ts.TotalDays / 7);
break;
#endregion
#region hour
case "hour":
case "hh":
DateDiffVal = (long)ts.TotalHours;
break;
#endregion
#region minute
case "minute":
case "mi":
case "n":
DateDiffVal = (long)ts.TotalMinutes;
break;
#endregion
#region second
case "second":
case "ss":
case "s":
DateDiffVal = (long)ts.TotalSeconds;
break;
#endregion
#region millisecond
case "millisecond":
case "ms":
DateDiffVal = (long)ts.TotalMilliseconds;
break;
#endregion
default:
throw new Exception(string.Format("DatePart \"{0}\" is unknown", datePart));
}
return(DateDiffVal);
}
private string GetDateInPersianCalendar(DateTime dateTime)
{
return($"{PersianCalendar.GetYear(dateTime):0000}/{PersianCalendar.GetMonth(dateTime):00}/{PersianCalendar.GetDayOfMonth(dateTime):00}");
}
public static DateTime EndOfMonth( this DateTime date, Calendar calendar )
{
Arg.NotNull( calendar, nameof( calendar ) );
Contract.Ensures( calendar.GetYear( Contract.Result<DateTime>() ) == Contract.OldValue( calendar.GetYear( date ) ) );
Contract.Ensures( calendar.GetMonth( Contract.Result<DateTime>() ) == Contract.OldValue( calendar.GetMonth( date ) ) );
return calendar.AddMonths( date.StartOfMonth( calendar ), 1 ).AddTicks( -1L );
}
/// <summary>
/// Get's this week for a date.
/// </summary>
/// <param name="dateTime">The date time.</param>
/// <param name="calendar">The calendar.</param>
/// <param name="calendarWeekRule">The calendar week rule.</param>
/// <param name="firstDayOfWeek">The first day of week.</param>
/// <returns>The week.</returns>
public static int WeekNumber(
this DateTime dateTime,
Calendar calendar = null,
CalendarWeekRule calendarWeekRule = CalendarWeekRule.FirstFourDayWeek,
DayOfWeek firstDayOfWeek = DayOfWeek.Sunday)
{
if (calendar == null)
calendar = CultureInfo.CurrentCulture.Calendar;
int weekNum = calendar.GetWeekOfYear(dateTime, calendarWeekRule, firstDayOfWeek);
return ((weekNum > 51) && (calendar.GetMonth(dateTime) < 12)) ? 0 : weekNum;
}
public void UpdateMonthMode()
{
Debug.Assert(this._owner.DisplayDate != null);
_currentMonth = (DateTime)this._owner.DisplayDate;
_firstDayOfWeek = this._owner.FirstDayOfWeek;
if (_currentMonth != null)
{
int year = _calendar.GetYear(_currentMonth);
int month = _calendar.GetMonth(_currentMonth);
DateTime firstDayOfMonth = new DateTime(year, month, 1);
if (this._headerButton != null)
{
this._headerButton.Content = string.Format(CultureInfo.CurrentCulture, Resource.Calendar_MonthViewHeaderText,
CultureInfo.CurrentCulture.DateTimeFormat.MonthNames[month - 1],
year.ToString(CultureInfo.CurrentCulture));
this._headerButton.IsEnabled = true;
}
int lastMonthToDisplay = PreviousMonthDays(firstDayOfMonth);
DateTime dateToAdd = _calendar.AddDays(firstDayOfMonth, -lastMonthToDisplay);
DateTime firstDayOfNextMonth = _calendar.AddMonths(firstDayOfMonth, 1);
// check to see if Prev/Next Buttons will be displayed
if (_previousButton != null)
{
if (DateTime.Compare(_owner.DisplayDateStart.GetValueOrDefault(DateTime.MinValue), firstDayOfMonth) > -1)
{
_previousButton.IsEnabled = false;
}
else
{
_previousButton.IsEnabled = true;
}
}
if (_nextButton != null)
{
if (DateTime.Compare(_owner.DisplayDateEnd.GetValueOrDefault(DateTime.MaxValue), firstDayOfNextMonth) < 0)
{
_nextButton.IsEnabled = false;
}
else
{
_nextButton.IsEnabled = true;
}
}
int count = 0;
if (_monthGrid != null)
{
Debug.Assert(_monthGrid.Children.Count == COLS * ROWS);
//Set the day titles
foreach (object child in _monthGrid.Children)
{
if (count < (COLS))
{
//this assumes that the day titles are always text blocks
TextBlock daytitle = child as TextBlock;
Debug.Assert(daytitle != null);
daytitle.Text = CultureInfo.CurrentCulture.DateTimeFormat.AbbreviatedDayNames[(count + (int)_firstDayOfWeek) % NUMBER_OF_DAYS_IN_WEEK];
}
else
{
DayButton mybutton = child as DayButton;
Debug.Assert(mybutton != null);
SetButtonState(mybutton, dateToAdd);
mybutton.IsTabStop = false;
if (_currentButton == null)
{
if (_owner.SelectedDate == null && mybutton.IsToday)
{
mybutton.IsTabStop = true;
_currentButton = mybutton;
mybutton.IsCurrent = true;
}
else
{
if (mybutton.IsSelected)
{
mybutton.IsTabStop = true;
_currentButton = mybutton;
mybutton.IsCurrent = true;
}
}
}
mybutton.Content = String.Format(CultureInfo.CurrentCulture, "{0,2}", dateToAdd.Day);
mybutton.DataContext = dateToAdd;
dateToAdd = _calendar.AddDays(dateToAdd, 1);
}
count++;
}
}
}
}
/// <summary>
/// Get's the next valid second after the current .
/// </summary>
/// <param name="dateTime">The date time (fractions of a second are removed).</param>
/// <param name="month">The month.</param>
/// <param name="week">The week.</param>
/// <param name="day">The day.</param>
/// <param name="weekDay">The week day.</param>
/// <param name="hour">The hour.</param>
/// <param name="minute">The minute.</param>
/// <param name="second">The second.</param>
/// <param name="calendar">The calendar.</param>
/// <param name="calendarWeekRule">The calendar week rule.</param>
/// <param name="firstDayOfWeek">The first day of week.</param>
/// <param name="inclusive">if set to <c>true</c> can return the time specified, otherwise, starts at the next second..</param>
/// <returns>
/// The next valid date (or <see cref="DateTime.MaxValue"/> if none).
/// </returns>
public static DateTime NextValid(
this DateTime dateTime,
Month month = Month.Every,
Week week = Week.Every,
Day day = Day.Every,
WeekDay weekDay = WeekDay.Every,
Hour hour = Hour.Zeroth,
Minute minute = Minute.Zeroth,
Second second = Second.Zeroth,
Calendar calendar = null,
CalendarWeekRule calendarWeekRule = CalendarWeekRule.FirstFourDayWeek,
DayOfWeek firstDayOfWeek = DayOfWeek.Sunday,
bool inclusive = false)
{
// Never case, if any are set to never, we'll never get a valid date.
if ((month == Month.Never) || (week == Week.Never) ||
(day == Day.Never) || (weekDay == WeekDay.Never) || (hour == Hour.Never) ||
(minute == Minute.Never) ||
(second == Second.Never))
return DateTime.MaxValue;
if (calendar == null)
calendar = CultureInfo.CurrentCulture.Calendar;
// Set the time to this second (or the next one if not inclusive), remove fractions of a second.
dateTime = new DateTime(
dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second);
if (!inclusive)
dateTime = calendar.AddSeconds(dateTime, 1);
// Every second case.
if ((month == Month.Every) && (day == Day.Every) && (weekDay == WeekDay.Every) && (hour == Hour.Every) &&
(minute == Minute.Every) && (second == Second.Every) &&
(week == Week.Every))
return calendar.AddSeconds(dateTime, 1);
// Get days and months.
IEnumerable<int> days = day.Days().OrderBy(dy => dy);
IEnumerable<int> months = month.Months();
// Remove months where the first day isn't in the month.
int firstDay = days.First();
if (firstDay > 28)
{
// 2000 is a leap year, so February has 29 days.
months = months.Where(mn => calendar.GetDaysInMonth(2000, mn) >= firstDay);
if (months.Count() < 1)
return DateTime.MaxValue;
}
// Get remaining date components.
int y = calendar.GetYear(dateTime);
int m = calendar.GetMonth(dateTime);
int d = calendar.GetDayOfMonth(dateTime);
int h = calendar.GetHour(dateTime);
int n = calendar.GetMinute(dateTime);
int s = calendar.GetSecond(dateTime);
IEnumerable<int> weeks = week.Weeks();
IEnumerable<DayOfWeek> weekDays = weekDay.WeekDays();
IEnumerable<int> hours = hour.Hours().OrderBy(i => i);
IEnumerable<int> minutes = minute.Minutes().OrderBy(i => i);
IEnumerable<int> seconds = second.Seconds();
do
{
foreach (int currentMonth in months)
{
if (currentMonth < m)
continue;
if (currentMonth > m)
{
d = 1;
h = n = s = 0;
}
m = currentMonth;
foreach (int currentDay in days)
{
if (currentDay < d)
continue;
if (currentDay > d)
h = n = s = 0;
d = currentDay;
// Check day is valid for this month.
if ((d > 28) && (d > calendar.GetDaysInMonth(y, m)))
break;
// We have a potential day, check week and week day
dateTime = new DateTime(y, m, d, h, n, s);
if ((week != Week.Every) &&
(!weeks.Contains(dateTime.WeekNumber(calendar, calendarWeekRule, firstDayOfWeek))))
continue;
if ((weekDay != WeekDay.Every) &&
(!weekDays.Contains(calendar.GetDayOfWeek(dateTime))))
continue;
// We have a date match, check time.
foreach (int currentHour in hours)
{
if (currentHour < h) continue;
if (currentHour > h)
n = s = 0;
h = currentHour;
foreach (int currentMinute in minutes)
{
if (currentMinute < n) continue;
if (currentMinute > n)
s = 0;
n = currentMinute;
foreach (int currentSecond in seconds)
{
if (currentSecond < s) continue;
return new DateTime(y, m, d, h, n, currentSecond, calendar);
}
n = s = 0;
}
h = n = s = 0;
}
d = 1;
}
d = 1;
h = n = s = 0;
}
y++;
// Don't bother checking max year.
if (y > 9998)
return DateTime.MaxValue;
// Start next year
m = d = 1;
h = n = s = 0;
} while (true);
}
private static bool CheckDefaultDateTime(ref DateTimeResult result, ref Calendar cal, DateTimeStyles styles) {
if ((result.flags & ParseFlags.CaptureOffset) != 0) {
// DateTimeOffset.Parse should allow dates without a year, but only if there is also no time zone marker;
// e.g. "May 1 5pm" is OK, but "May 1 5pm -08:30" is not. This is somewhat pragmatic, since we would
// have to rearchitect parsing completely to allow this one case to correctly handle things like leap
// years and leap months. Is is an extremely corner case, and DateTime is basically incorrect in that
// case today.
//
// values like "11:00Z" or "11:00 -3:00" are also acceptable
//
// if ((month or day is set) and (year is not set and time zone is set))
//
if ( ((result.Month != -1) || (result.Day != -1))
&& ((result.Year == -1 || ((result.flags & ParseFlags.YearDefault) != 0)) && (result.flags & ParseFlags.TimeZoneUsed) != 0) ) {
result.SetFailure(ParseFailureKind.Format, "Format_MissingIncompleteDate", null);
return false;
}
}
if ((result.Year == -1) || (result.Month == -1) || (result.Day == -1)) {
/*
The following table describes the behaviors of getting the default value
when a certain year/month/day values are missing.
An "X" means that the value exists. And "--" means that value is missing.
Year Month Day => ResultYear ResultMonth ResultDay Note
X X X Parsed year Parsed month Parsed day
X X -- Parsed Year Parsed month First day If we have year and month, assume the first day of that month.
X -- X Parsed year First month Parsed day If the month is missing, assume first month of that year.
X -- -- Parsed year First month First day If we have only the year, assume the first day of that year.
-- X X CurrentYear Parsed month Parsed day If the year is missing, assume the current year.
-- X -- CurrentYear Parsed month First day If we have only a month value, assume the current year and current day.
-- -- X CurrentYear First month Parsed day If we have only a day value, assume current year and first month.
-- -- -- CurrentYear Current month Current day So this means that if the date string only contains time, you will get current date.
*/
DateTime now = GetDateTimeNow(ref result, ref styles);
if (result.Month == -1 && result.Day == -1) {
if (result.Year == -1) {
if ((styles & DateTimeStyles.NoCurrentDateDefault) != 0) {
// If there is no year/month/day values, and NoCurrentDateDefault flag is used,
// set the year/month/day value to the beginning year/month/day of DateTime().
// Note we should be using Gregorian for the year/month/day.
cal = GregorianCalendar.GetDefaultInstance();
result.Year = result.Month = result.Day = 1;
} else {
// Year/Month/Day are all missing.
result.Year = cal.GetYear(now);
result.Month = cal.GetMonth(now);
result.Day = cal.GetDayOfMonth(now);
}
} else {
// Month/Day are both missing.
result.Month = 1;
result.Day = 1;
}
} else {
if (result.Year == -1) {
result.Year = cal.GetYear(now);
}
if (result.Month == -1) {
result.Month = 1;
}
if (result.Day == -1) {
result.Day = 1;
}
}
}
// Set Hour/Minute/Second to zero if these value are not in str.
if (result.Hour == -1) result.Hour = 0;
if (result.Minute == -1) result.Minute = 0;
if (result.Second == -1) result.Second = 0;
if (result.era == -1) result.era = Calendar.CurrentEra;
return true;
}
private void VerifyAddMonthsResult(Calendar calendar, DateTime oldTime, DateTime newTime, int months)
{
int oldYear = calendar.GetYear(oldTime);
int oldMonth = calendar.GetMonth(oldTime);
int oldDay = calendar.GetDayOfMonth(oldTime);
long oldTicksOfDay = oldTime.Ticks % TimeSpan.TicksPerDay;
int newYear = calendar.GetYear(newTime);
int newMonth = calendar.GetMonth(newTime);
int newDay = calendar.GetDayOfMonth(newTime);
long newTicksOfDay = newTime.Ticks % TimeSpan.TicksPerDay;
Assert.Equal(oldTicksOfDay, newTicksOfDay);
Assert.False(newDay > oldDay);
Assert.False(newYear * 12 + newMonth != oldYear * 12 + oldMonth + months);
}
private static void CheckDefaultDateTime(ref DateTimeResult result, ref Calendar cal, DateTimeStyles styles) {
if ((result.Year == -1) || (result.Month == -1) || (result.Day == -1)) {
/*
The following table describes the behaviors of getting the default value
when a certain year/month/day values are missing.
An "X" means that the value exists. And "--" means that value is missing.
Year Month Day => ResultYear ResultMonth ResultDay Note
X X X Parsed year Parsed month Parsed day
X X -- Parsed Year Parsed month First day If we have year and month, assume the first day of that month.
X -- X Parsed year First month Parsed day If the month is missing, assume first month of that year.
X -- -- Parsed year First month First day If we have only the year, assume the first day of that year.
-- X X CurrentYear Parsed month Parsed day If the year is missing, assume the current year.
-- X -- CurrentYear Parsed month First day If we have only a month value, assume the current year and current day.
-- -- X CurrentYear First month Parsed day If we have only a day value, assume current year and first month.
-- -- -- CurrentYear Current month Current day So this means that if the date string only contains time, you will get current date.
*/
DateTime now = DateTime.Now;
if (result.Month == -1 && result.Day == -1) {
if (result.Year == -1) {
if ((styles & DateTimeStyles.NoCurrentDateDefault) != 0) {
// If there is no year/month/day values, and NoCurrentDateDefault flag is used,
// set the year/month/day value to the beginning year/month/day of DateTime().
// Note we should be using Gregorian for the year/month/day.
cal = GregorianCalendar.GetDefaultInstance();
result.Year = result.Month = result.Day = 1;
} else {
// Year/Month/Day are all missing.
result.Year = cal.GetYear(now);
result.Month = cal.GetMonth(now);
result.Day = cal.GetDayOfMonth(now);
}
} else {
// Month/Day are both missing.
result.Month = 1;
result.Day = 1;
}
} else {
if (result.Year == -1) {
result.Year = cal.GetYear(now);
}
if (result.Month == -1) {
result.Month = 1;
}
if (result.Day == -1) {
result.Day = 1;
}
}
}
// Set Hour/Minute/Second to zero if these value are not in str.
if (result.Hour == -1) result.Hour = 0;
if (result.Minute == -1) result.Minute = 0;
if (result.Second == -1) result.Second = 0;
if (result.era == -1) result.era = Calendar.CurrentEra;
}
public static int Month( this DateTime date, Calendar calendar )
{
Arg.NotNull( calendar, nameof( calendar ) );
Contract.Ensures( Contract.Result<int>() > 0 );
Contract.Ensures( Contract.Result<int>() <= calendar.GetMonthsInYear( date.Year ) );
return calendar.GetMonth( date );
}
public static DateTime StartOfMonth( this DateTime date, Calendar calendar )
{
Arg.NotNull( calendar, nameof( calendar ) );
Contract.Ensures( calendar.GetYear( Contract.Result<DateTime>() ) == Contract.OldValue( calendar.GetYear( date ) ) );
Contract.Ensures( calendar.GetMonth( Contract.Result<DateTime>() ) == Contract.OldValue( calendar.GetMonth( date ) ) );
var year = calendar.GetYear( date );
var month = calendar.GetMonth( date );
return calendar.ToDateTime( year, month, 1, date.Hour, date.Minute, date.Second, date.Millisecond );
}
private static bool CheckDefaultDateTime(ref DateTimeResult result, ref Calendar cal, DateTimeStyles styles)
{
if ((result.flags & ParseFlags.CaptureOffset) != (ParseFlags)0 && (result.Month != -1 || result.Day != -1) && (result.Year == -1 || (result.flags & ParseFlags.YearDefault) != (ParseFlags)0) && (result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0)
{
result.SetFailure(ParseFailureKind.Format, "Format_MissingIncompleteDate", null);
return false;
}
if (result.Year == -1 || result.Month == -1 || result.Day == -1)
{
DateTime dateTimeNow = DateTimeParse.GetDateTimeNow(ref result, ref styles);
if (result.Month == -1 && result.Day == -1)
{
if (result.Year == -1)
{
if ((styles & DateTimeStyles.NoCurrentDateDefault) != DateTimeStyles.None)
{
cal = GregorianCalendar.GetDefaultInstance();
result.Year = (result.Month = (result.Day = 1));
}
else
{
result.Year = cal.GetYear(dateTimeNow);
result.Month = cal.GetMonth(dateTimeNow);
result.Day = cal.GetDayOfMonth(dateTimeNow);
}
}
else
{
result.Month = 1;
result.Day = 1;
}
}
else
{
if (result.Year == -1)
{
result.Year = cal.GetYear(dateTimeNow);
}
if (result.Month == -1)
{
result.Month = 1;
}
if (result.Day == -1)
{
result.Day = 1;
}
}
}
if (result.Hour == -1)
{
result.Hour = 0;
}
if (result.Minute == -1)
{
result.Minute = 0;
}
if (result.Second == -1)
{
result.Second = 0;
}
if (result.era == -1)
{
result.era = 0;
}
return true;
}
public static int Semester( this DateTime date, Calendar calendar )
{
Arg.NotNull( calendar, nameof( calendar ) );
Contract.Ensures( Contract.Result<int>() > 0 );
Contract.Ensures( Contract.Result<int>() < 3 );
var month = (double) calendar.GetMonth( date );
return (int) Math.Ceiling( month / 6.0 );
}
