| public abstract GetDayOfMonth ( 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;
}
public DayInformationModel()
{
_year = _myCal.GetYear(DateTime.Today);
_month = _myCal.GetMonth(DateTime.Today);
_day = _myCal.GetDayOfMonth(DateTime.Today);
_numDaysBeingDisplayed = 3;
InitModel();
}
/// <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 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)));
}
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)));
}
// 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 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;
}
public static string ToDayString(DateTime?date, CultureInfo culture)
{
string result = string.Empty;
DateTimeFormatInfo format = GetDateFormat(culture);
if (date.HasValue && format != null)
{
result = cal.GetDayOfMonth(date.Value).ToString(format);
}
return(result);
}
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);
}
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);
}
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
));
}
/// <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 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;
}
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 string GetDateInPersianCalendar(DateTime dateTime)
{
return($"{PersianCalendar.GetYear(dateTime):0000}/{PersianCalendar.GetMonth(dateTime):00}/{PersianCalendar.GetDayOfMonth(dateTime):00}");
}
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;
}
/////////////////////////////////////////////////////////////////////
// Helper functions
/////////////////////////////////////////////////////////////////////
// Return the first date of the input year and month
private DateTime EffectiveVisibleDate(DateTime visibleDate)
{
return(_threadCalendar.AddDays(
visibleDate,
-(_threadCalendar.GetDayOfMonth(visibleDate) - 1)));
}
/// <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);
}