| public abstract GetDayOfYear ( DateTime time ) : int | ||
| time | DateTime | |
| return | int | |
public static bool IsSameDay(DateTime? date, DateTime? compareDate)
{
if (date is null || compareDate is null)
return false;
return IsSameYear(date, compareDate)
&& _calendar.GetDayOfYear(date.Value) == _calendar.GetDayOfYear(compareDate.Value);
}
internal static int InternalGetWeekOfYearFullDays(Calendar cal, DateTime time, int firstDayOfWeek, int fullDays, int daysOfMinYearMinusOne)
{
int daysInYear = cal.GetDayOfYear(time) - 1;
int num = ((int)cal.GetDayOfWeek(time)) - (daysInYear % 7);
int num2 = ((firstDayOfWeek - num) + 14) % 7;
if ((num2 != 0) && (num2 >= fullDays))
{
num2 -= 7;
}
int num3 = daysInYear - num2;
if (num3 < 0)
{
int year = cal.GetYear(time);
if (year <= cal.GetYear(cal.MinSupportedDateTime))
{
daysInYear = daysOfMinYearMinusOne;
}
else
{
daysInYear = cal.GetDaysInYear(year - 1);
}
num -= daysInYear % 7;
num2 = ((firstDayOfWeek - num) + 14) % 7;
if ((num2 != 0) && (num2 >= fullDays))
{
num2 -= 7;
}
num3 = daysInYear - num2;
}
return((num3 / 7) + 1);
}
private void ExecutePosTest(string errorNum1, string errorNum2, Calendar myCalendar, int year,
int month, int day, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
{
DateTime time;
int actualDayOfYear, expectedDayOfYear;
int weekOfYear;
time = myCalendar.ToDateTime(year, month, day, 0, 0, 0, 0);
expectedDayOfYear = myCalendar.GetDayOfYear(time);
weekOfYear = myCalendar.GetWeekOfYear(time, rule, firstDayOfWeek);
actualDayOfYear = this.GetDayOfYear(time, rule, firstDayOfWeek, weekOfYear, myCalendar);
Assert.Equal(expectedDayOfYear, actualDayOfYear);
}
private int GetDayOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek, int weekOfYear, Calendar myCalendar)
{
int retVal = -367;
int offset = 0;
int dayOfWeekForJan1, dayOfYear, dayOfWeek;
dayOfYear = myCalendar.GetDayOfYear(time); //1-based
dayOfWeek = (int)myCalendar.GetDayOfWeek(time) - (int)firstDayOfWeek + 1; //1-based
if (dayOfWeek <= 0)
dayOfWeek += c_DAYS_PER_WEEK; //Make it a positive value
dayOfWeekForJan1 = dayOfWeek - (dayOfYear - 1) % c_DAYS_PER_WEEK; //1-based
if (dayOfWeekForJan1 <= 0)
dayOfWeekForJan1 += c_DAYS_PER_WEEK; //Make it a positive value
// When the day of specific time falls on the previous year,
// return the number of days from January 1 directly.
// There could be 6 weeks within a month.
if (time.Month == 1 && weekOfYear > 6)
{
return dayOfWeek - dayOfWeekForJan1 + 1;
}
switch (rule)
{
case CalendarWeekRule.FirstDay:
offset = dayOfWeek - dayOfWeekForJan1;
break;
case CalendarWeekRule.FirstFourDayWeek:
if (dayOfWeekForJan1 <= 4)
{
offset = dayOfWeek - dayOfWeekForJan1;
}
else
{
offset = dayOfWeek + c_DAYS_PER_WEEK - dayOfWeekForJan1;
}
break;
case CalendarWeekRule.FirstFullWeek:
if (dayOfWeekForJan1 == 1)
{
offset = dayOfWeek - dayOfWeekForJan1;
}
else
{
offset = dayOfWeek + c_DAYS_PER_WEEK - dayOfWeekForJan1;
}
break;
}
retVal = (weekOfYear - 1) * c_DAYS_PER_WEEK + offset + 1;
return retVal;
}
private void VerificationHelper(Calendar calendar, DateTime time, int expected, string errorno)
{
int actual = calendar.GetDayOfYear(time);
Assert.Equal(expected, actual);
}
public static bool IsSameDay(DateTime date, DateTime compareDate)
{
return(IsSameYear(date, compareDate) &&
_calendar.GetDayOfYear(date) == _calendar.GetDayOfYear(compareDate));
}
public static DateTime StartOfYear( this DateTime date, Calendar calendar )
{
Arg.NotNull( calendar, nameof( calendar ) );
Contract.Ensures( calendar.GetYear( Contract.Result<DateTime>() ) == Contract.OldValue( calendar.GetYear( date ) ) );
return date.AddDays( (double) ( -calendar.GetDayOfYear( date ) + 1 ) );
}
// This is copied from the generic implementation of GetWeekOfYearFullDays() in Calendar.cs. The generic implementation is not good enough
// in the case of FristFullWeek and FirstFourDayWeek since it needs the data for B.C. year 1 near 0001/1/1.
// We override the generic implementation to handle this special case.
// Parameters
//
internal static int InternalGetWeekOfYearFullDays(Calendar cal, DateTime time, int firstDayOfWeek, int fullDays, int daysOfMinYearMinusOne) {
int dayForJan1;
int offset;
int day;
int dayOfYear = cal.GetDayOfYear(time) - 1; // Make the day of year to be 0-based, so that 1/1 is day 0.
//
// Calculate the number of days between the first day of year (1/1) and the first day of the week.
// This value will be a positive value from 0 ~ 6. We call this value as "offset".
//
// If offset is 0, it means that the 1/1 is the start of the first week.
// Assume the first day of the week is Monday, it will look like this:
// Sun Mon Tue Wed Thu Fri Sat
// 12/31 1/1 1/2 1/3 1/4 1/5 1/6
// +--> First week starts here.
//
// If offset is 1, it means that the first day of the week is 1 day ahead of 1/1.
// Assume the first day of the week is Monday, it will look like this:
// Sun Mon Tue Wed Thu Fri Sat
// 1/1 1/2 1/3 1/4 1/5 1/6 1/7
// +--> First week starts here.
//
// If offset is 2, it means that the first day of the week is 2 days ahead of 1/1.
// Assume the first day of the week is Monday, it will look like this:
// Sat Sun Mon Tue Wed Thu Fri Sat
// 1/1 1/2 1/3 1/4 1/5 1/6 1/7 1/8
// +--> First week starts here.
// Day of week is 0-based.
// Get the day of week for 1/1. This can be derived from the day of week of the target day.
// Note that we can get a negative value. It's ok since we are going to make it a positive value when calculating the offset.
dayForJan1 = (int)cal.GetDayOfWeek(time) - (dayOfYear % 7);
// Now, calucalte the offset. Substract the first day of week from the dayForJan1. And make it a positive value.
offset = (firstDayOfWeek - dayForJan1 + 14) % 7;
if (offset != 0 && offset >= fullDays)
{
//
// If the offset is greater than the value of fullDays, it means that
// the first week of the year starts on the week where Jan/1 falls on.
//
offset -= 7;
}
//
// Calculate the day of year for specified time by taking offset into account.
//
day = dayOfYear - offset;
if (day >= 0) {
//
// If the day of year value is greater than zero, get the week of year.
//
return (day/7 + 1);
}
//
// Otherwise, the specified time falls on the week of previous year.
// Note that it is not always week 52 or 53, because it depends on the calendar. Different calendars have different number of days in a year.
//
// Repeat the previous calculation logic using the previous year and calculate the week of year for the last day of previous year.
int year = cal.GetYear(time);
if (year <= cal.GetYear(cal.MinSupportedDateTime)) {
// This specified time is in 0001/1/1 ~ 0001/1/7.
dayOfYear = daysOfMinYearMinusOne;
} else {
dayOfYear = cal.GetDaysInYear(year - 1);
}
dayForJan1 = dayForJan1 - (dayOfYear % 7);
// Now, calucalte the offset. Substract the first day of week from the dayForJan1. And make it a positive value.
offset = (firstDayOfWeek - dayForJan1 + 14) % 7;
if (offset != 0 && offset >= fullDays)
{
//
// If the offset is greater than the value of fullDays, it means that
// the first week of the year starts on the week where Jan/1 falls on.
//
offset -= 7;
}
//
// Calculate the day of year for specified time by taking offset into account.
//
day = dayOfYear - offset;
return (day/7 + 1);
}
internal static int InternalGetWeekOfYearFullDays(Calendar cal, DateTime time, int firstDayOfWeek, int fullDays, int daysOfMinYearMinusOne)
{
int daysInYear = cal.GetDayOfYear(time) - 1;
int num = ((int) cal.GetDayOfWeek(time)) - (daysInYear % 7);
int num2 = ((firstDayOfWeek - num) + 14) % 7;
if ((num2 != 0) && (num2 >= fullDays))
{
num2 -= 7;
}
int num3 = daysInYear - num2;
if (num3 < 0)
{
int year = cal.GetYear(time);
if (year <= cal.GetYear(cal.MinSupportedDateTime))
{
daysInYear = daysOfMinYearMinusOne;
}
else
{
daysInYear = cal.GetDaysInYear(year - 1);
}
num -= daysInYear % 7;
num2 = ((firstDayOfWeek - num) + 14) % 7;
if ((num2 != 0) && (num2 >= fullDays))
{
num2 -= 7;
}
num3 = daysInYear - num2;
}
return ((num3 / 7) + 1);
}
// This is copied from the generic implementation of GetWeekOfYearFullDays() in Calendar.cs. The generic implementation is not good enough
// in the case of FristFullWeek and FirstFourDayWeek since it needs the data for B.C. year 1 near 0001/1/1.
// We override the generic implementation to handle this special case.
// Parameters
//
internal static int InternalGetWeekOfYearFullDays(Calendar cal, DateTime time, int firstDayOfWeek, int fullDays, int daysOfMinYearMinusOne)
{
int dayForJan1;
int offset;
int day;
int dayOfYear = cal.GetDayOfYear(time) - 1; // Make the day of year to be 0-based, so that 1/1 is day 0.
//
// Calculate the number of days between the first day of year (1/1) and the first day of the week.
// This value will be a positive value from 0 ~ 6. We call this value as "offset".
//
// If offset is 0, it means that the 1/1 is the start of the first week.
// Assume the first day of the week is Monday, it will look like this:
// Sun Mon Tue Wed Thu Fri Sat
// 12/31 1/1 1/2 1/3 1/4 1/5 1/6
// +--> First week starts here.
//
// If offset is 1, it means that the first day of the week is 1 day ahead of 1/1.
// Assume the first day of the week is Monday, it will look like this:
// Sun Mon Tue Wed Thu Fri Sat
// 1/1 1/2 1/3 1/4 1/5 1/6 1/7
// +--> First week starts here.
//
// If offset is 2, it means that the first day of the week is 2 days ahead of 1/1.
// Assume the first day of the week is Monday, it will look like this:
// Sat Sun Mon Tue Wed Thu Fri Sat
// 1/1 1/2 1/3 1/4 1/5 1/6 1/7 1/8
// +--> First week starts here.
// Day of week is 0-based.
// Get the day of week for 1/1. This can be derived from the day of week of the target day.
// Note that we can get a negative value. It's ok since we are going to make it a positive value when calculating the offset.
dayForJan1 = (int)cal.GetDayOfWeek(time) - (dayOfYear % 7);
// Now, calucalte the offset. Substract the first day of week from the dayForJan1. And make it a positive value.
offset = (firstDayOfWeek - dayForJan1 + 14) % 7;
if (offset != 0 && offset >= fullDays)
{
//
// If the offset is greater than the value of fullDays, it means that
// the first week of the year starts on the week where Jan/1 falls on.
//
offset -= 7;
}
//
// Calculate the day of year for specified time by taking offset into account.
//
day = dayOfYear - offset;
if (day >= 0)
{
//
// If the day of year value is greater than zero, get the week of year.
//
return(day / 7 + 1);
}
//
// Otherwise, the specified time falls on the week of previous year.
// Note that it is not always week 52 or 53, because it depends on the calendar. Different calendars have different number of days in a year.
//
// Repeat the previous calculation logic using the previous year and calculate the week of year for the last day of previous year.
int year = cal.GetYear(time);
if (year <= cal.GetYear(cal.MinSupportedDateTime))
{
// This specified time is in 0001/1/1 ~ 0001/1/7.
dayOfYear = daysOfMinYearMinusOne;
}
else
{
dayOfYear = cal.GetDaysInYear(year - 1);
}
dayForJan1 = dayForJan1 - (dayOfYear % 7);
// Now, calucalte the offset. Substract the first day of week from the dayForJan1. And make it a positive value.
offset = (firstDayOfWeek - dayForJan1 + 14) % 7;
if (offset != 0 && offset >= fullDays)
{
//
// If the offset is greater than the value of fullDays, it means that
// the first week of the year starts on the week where Jan/1 falls on.
//
offset -= 7;
}
//
// Calculate the day of year for specified time by taking offset into account.
//
day = dayOfYear - offset;
return(day / 7 + 1);
}
