/// <summary> /// Weeks the of year. /// </summary> /// <param name="datetime">The datetime.</param> /// <param name="firstDayOfWeek">The first day of week.</param> /// <returns></returns> public static int WeekOfYear(this DateTime datetime, DayOfWeek firstDayOfWeek) { DateTimeFormatInfo dateinf = new DateTimeFormatInfo(); CalendarWeekRule weekrule = dateinf.CalendarWeekRule; return(WeekOfYear(datetime, weekrule, firstDayOfWeek)); }
public DateTimeFormatInfo() { // Construct an invariant culture DateTimeFormatInfo char[] comma = new char[] { ',' }; this.isReadOnly = true; this.abbreviatedDayNames = "Sun,Mon,Tue,Wed,Thu,Fri,Sat".Split(comma); this.abbreviatedMonthGenitiveNames = "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,".Split(comma); this.abbreviatedMonthNames = "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,".Split(comma); this.amDesignator = "AM"; this.calendarWeekRule = CalendarWeekRule.FirstDay; this.dateSeparator = "/"; this.dayNames = "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".Split(comma); this.firstDayOfWeek = DayOfWeek.Sunday; this.fullDateTimePattern = "dddd, dd MMMM yyyy HH:mm:ss"; this.longDatePattern = "dddd, dd MMMM yyyy"; this.longTimePattern = "HH:mm:ss"; this.monthDayPattern = "MMMM dd"; this.monthGenitiveNames = "January,February,March,April,May,June,July,August,September,October,November,December,".Split(comma); this.monthNames = "January,February,March,April,May,June,July,August,September,October,November,December,".Split(comma); this.nativeCalendarName = "Gregorian Calendar"; this.pmDesignator = "PM"; this.rfc1123Pattern = "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'"; this.shortDatePattern = "MM/dd/yyyy"; this.shortestDayNames = "Su,Mo,Tu,We,Th,Fr,Sa".Split(comma); this.shortTimePattern = "HH:mm"; this.sortableDateTimePattern = "yyyy'-'MM'-'dd'T'HH':'mm':'ss"; this.timeSeparator = ":"; this.universalSortableDateTimePattern = "yyyy'-'MM'-'dd HH':'mm':'ss'Z'"; this.yearMonthPattern = "yyyy MMMM"; this.calendar = new GregorianCalendar(); }
public void Setup() { futureTimeUS = new DateTime(2015, 9, 1); us = CultureInfo.GetCultureInfo("en-us"); firstDayOfWeekUS = us.DateTimeFormat.FirstDayOfWeek; calendarWeekRuleUS = us.DateTimeFormat.CalendarWeekRule; }
/// <summary> /// Weeks the of year. /// </summary> /// <param name="datetime">The datetime.</param> /// <param name="weekRule">The weekRule.</param> /// <returns></returns> public static int WeekOfYear(this DateTime datetime, CalendarWeekRule weekRule) { DateTimeFormatInfo dateInfo = new DateTimeFormatInfo(); DayOfWeek firstDayOfWeek = dateInfo.FirstDayOfWeek; return(WeekOfYear(datetime, weekRule, firstDayOfWeek)); }
internal DateTimeFormatInfo(StreamReader s, string calendarName) { char[] comma = new char[] { ',' }; this.abbreviatedDayNames = s.ReadLine().Split(comma); this.abbreviatedMonthGenitiveNames = s.ReadLine().Split(comma); this.abbreviatedMonthNames = s.ReadLine().Split(comma); this.amDesignator = s.ReadLine(); this.calendarWeekRule = (CalendarWeekRule)int.Parse(s.ReadLine()); this.dateSeparator = s.ReadLine(); this.dayNames = s.ReadLine().Split(comma); this.firstDayOfWeek = (DayOfWeek)int.Parse(s.ReadLine()); this.fullDateTimePattern = s.ReadLine(); this.longDatePattern = s.ReadLine(); this.longTimePattern = s.ReadLine(); this.monthDayPattern = s.ReadLine(); this.monthGenitiveNames = s.ReadLine().Split(comma); this.monthNames = s.ReadLine().Split(comma); this.nativeCalendarName = s.ReadLine(); s.ReadLine(); // TODO: Appears to be a mistake in the culture files. Extra line added. this.pmDesignator = s.ReadLine(); this.rfc1123Pattern = s.ReadLine(); // This is always the same, so does it need to be in the culture file? this.shortDatePattern = s.ReadLine(); this.shortestDayNames = s.ReadLine().Split(comma); this.shortTimePattern = s.ReadLine(); this.sortableDateTimePattern = s.ReadLine(); // This is always the same this.timeSeparator = s.ReadLine(); this.universalSortableDateTimePattern = s.ReadLine(); // This is always the same this.yearMonthPattern = s.ReadLine(); this.calendar = Calendar.CreateByName(calendarName); }
} // GetWeekOfYear // ---------------------------------------------------------------------- public static void GetWeekOfYear(DateTime moment, CultureInfo culture, CalendarWeekRule weekRule, DayOfWeek firstDayOfWeek, YearWeekType yearWeekType, out int year, out int weekOfYear) { if (culture == null) { throw new ArgumentNullException("culture"); } if (yearWeekType == YearWeekType.Iso8601 && weekRule == CalendarWeekRule.FirstFourDayWeek && firstDayOfWeek == DayOfWeek.Monday) { // see http://blogs.msdn.com/b/shawnste/archive/2006/01/24/517178.aspx DayOfWeek day = culture.Calendar.GetDayOfWeek(moment); if (day >= DayOfWeek.Monday && day <= DayOfWeek.Wednesday) { moment = moment.AddDays(3); } } weekOfYear = culture.Calendar.GetWeekOfYear(moment, weekRule, firstDayOfWeek); year = moment.Year; if (weekOfYear >= 52 && moment.Month < 12) { year--; } } // GetWeekOfYear
} // GetStartOfYearWeek // ---------------------------------------------------------------------- public static DateTime GetStartOfYearWeek(int year, int weekOfYear, CultureInfo culture, CalendarWeekRule weekRule, DayOfWeek firstDayOfWeek, YearWeekType yearWeekType) { if (culture == null) { throw new ArgumentNullException("culture"); } if (weekOfYear < 1) { throw new ArgumentOutOfRangeException("weekOfYear"); } DateTime dateTime = new DateTime(year, 1, 1).AddDays(weekOfYear * TimeSpec.DaysPerWeek); int currentYear; int currentWeek; GetWeekOfYear(dateTime, culture, weekRule, firstDayOfWeek, yearWeekType, out currentYear, out currentWeek); // end date of week while (currentWeek != weekOfYear) { dateTime = dateTime.AddDays(-1); GetWeekOfYear(dateTime, culture, weekRule, firstDayOfWeek, yearWeekType, out currentYear, out currentWeek); } // end of previous week while (currentWeek == weekOfYear) { dateTime = dateTime.AddDays(-1); GetWeekOfYear(dateTime, culture, weekRule, firstDayOfWeek, yearWeekType, out currentYear, out currentWeek); } return(dateTime.AddDays(1)); } // GetStartOfYearWeek
public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { CheckTicksRange(time.Ticks); // Use GregorianCalendar to get around the problem that the implmentation in Calendar.GetWeekOfYear() // can call GetYear() that exceeds the supported range of the Gregorian-based calendars. return(GregorianCalendar.GetDefaultInstance().GetWeekOfYear(time, rule, firstDayOfWeek)); }
public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { if (firstDayOfWeek < DayOfWeek.Sunday || firstDayOfWeek > DayOfWeek.Saturday) { throw new ArgumentOutOfRangeException( nameof(firstDayOfWeek), firstDayOfWeek, SR.Format(SR.ArgumentOutOfRange_Range, DayOfWeek.Sunday, DayOfWeek.Saturday)); } switch (rule) { case CalendarWeekRule.FirstDay: return(GetFirstDayWeekOfYear(time, (int)firstDayOfWeek)); case CalendarWeekRule.FirstFullWeek: return(GetWeekOfYearFullDays(time, (int)firstDayOfWeek, 7)); case CalendarWeekRule.FirstFourDayWeek: return(GetWeekOfYearFullDays(time, (int)firstDayOfWeek, 4)); default: throw new ArgumentOutOfRangeException( nameof(rule), rule, SR.Format(SR.ArgumentOutOfRange_Range, CalendarWeekRule.FirstDay, CalendarWeekRule.FirstFourDayWeek)); } }
public static void GetWeekOfYear(this DateTime moment, CultureInfo culture, CalendarWeekRule weekRule, DayOfWeek firstDayOfWeek, WeekOfYearRuleKind weekOfYearRule, out int year, out int weekOfYear) { var yearAndWeek = WeekTool.GetYearAndWeek(moment, culture, weekOfYearRule); year = yearAndWeek.Year ?? 0; weekOfYear = yearAndWeek.Week ?? 0; //culture.ShouldNotBeNull("culture"); //// NOTE: ISO 8601이 FirstFourDayWeek, Monday를 기준으로 하는데 왜 이렇게 하는지 모르겠네? //// //if(weekOfYearRule == WeekOfYearRuleKind.Iso8601 && weekRule == CalendarWeekRule.FirstFourDayWeek && firstDayOfWeek == DayOfWeek.Monday) //{ // // // // NOTE: see http://blogs.msdn.com/b/shawnste/archive/2006/01/24/517178.aspx // // // var day = culture.Calendar.GetDayOfWeek(moment); // if(day >= DayOfWeek.Monday && day <= DayOfWeek.Wednesday) // { // moment = moment.AddDays(3); // } //} //weekOfYear = culture.Calendar.GetWeekOfYear(moment, weekRule, firstDayOfWeek); //year = moment.Year; //if(weekOfYear >= 52 && moment.Month < 12) //{ // year--; //} }
public static void GetStartAndEndOfWeek(int year, int week, out DateTime startOfWeek, out DateTime endOfWeek, CalendarWeekRule cwr, DayOfWeek firstDayOfWeek) { // find the first week. //CalendarWeekRule cwr = CultureInfo.CurrentCulture.DateTimeFormat.CalendarWeekRule; //DayOfWeek firstDayOfWeek = CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek; DateTime firstdayofyear = new DateTime(year, 1, 1); int offset = 0; if (firstdayofyear.DayOfWeek != firstDayOfWeek) { // find first first day. if (cwr == CalendarWeekRule.FirstFourDayWeek) { DateTime firstFullWeekStart = firstdayofyear; while (firstFullWeekStart.DayOfWeek != firstDayOfWeek) firstFullWeekStart = firstFullWeekStart.AddDays(1); if (firstFullWeekStart.Subtract(firstdayofyear).Days >= 4) offset = -1; } if (cwr == CalendarWeekRule.FirstDay) offset = -1; } startOfWeek = firstdayofyear.AddDays(7 * (week + offset)); while (startOfWeek != firstdayofyear && startOfWeek.DayOfWeek != firstDayOfWeek) startOfWeek = startOfWeek.AddDays(-1); endOfWeek = startOfWeek; do { endOfWeek = endOfWeek.AddDays(1); } while (endOfWeek < new DateTime(year + 1, 1, 1).AddDays(-1) && endOfWeek.AddDays(1).DayOfWeek != firstDayOfWeek); }
public void CalendarWeekRule_Set(CalendarWeekRule newCalendarWeekRule) { var format = new DateTimeFormatInfo(); format.CalendarWeekRule = newCalendarWeekRule; Assert.Equal(newCalendarWeekRule, format.CalendarWeekRule); }
/// <summary> /// A virtual method that gives the number of the week in the year. /// </summary> /// <param name="time">A /// <see cref="T:System.DateTime"/> representing the date. /// </param> /// <param name="rule">The /// <see cref="T:System.Globalization.CalendarWeekRule"/> /// to be used for the calculation. /// </param> /// <param name="firstDayOfWeek"> /// The <see cref="T:System.Globalization.DayOfWeek"/> /// specifying the first day in a week. /// </param> /// <returns>An integer representing the number of the week in the /// year, starting with 1. /// </returns> public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { if (firstDayOfWeek < DayOfWeek.Sunday || DayOfWeek.Saturday < firstDayOfWeek) { throw new ArgumentOutOfRangeException("firstDayOfWeek", "Value is not a valid day of week."); } int year = GetYear(time); int days; while (true) { DateTime secondWeek = M_GetFirstDayOfSecondWeekOfYear( year, rule, firstDayOfWeek); days = M_DiffDays(time, secondWeek) + M_DaysInWeek; if (days >= 0) { break; } year -= 1; } return(1 + days / M_DaysInWeek); }
public PagedList <WeekSummary> GetWeeklyReports(IEnumerable <Jogging> joggings, ReportParameters reportParameters) { List <WeekSummary> weekSummaries = new List <WeekSummary>(); CultureInfo myCI = new CultureInfo("en-US"); Calendar myCal = myCI.Calendar; CalendarWeekRule myCWR = myCI.DateTimeFormat.CalendarWeekRule; DayOfWeek myFirstDOW = myCI.DateTimeFormat.FirstDayOfWeek; var yearlyLookup = _joggings.ToLookup(j => j.JoggingDate.Year, j => j); int i = 1; foreach (var gr in yearlyLookup.OrderBy(y => y.Key)) { var weeklyLookup = gr.ToLookup(g => myCal.GetWeekOfYear(g.JoggingDate, myCWR, myFirstDOW), g => g); foreach (var week in weeklyLookup.OrderBy(w => w.Key)) { var weekSummary = GetWeekSummary(week.ToList()); weekSummary.WeekNumber = i; weekSummaries.Add(weekSummary); i++; } } return(PagedList <WeekSummary> .ToPagedList(weekSummaries, reportParameters.PageNumber, reportParameters.PageSize)); }
public void Page_Load(object sender, EventArgs e) { UserDetails user = new UserDetails(); user = (UserDetails)Session["LoggedUser"]; if (user == null) { Response.Redirect("Login.aspx"); } dashboardID = int.Parse(Request.QueryString["id"]); List <Dashboard> dashboardlist = new List <Dashboard>(); dashboardlist = user.UserDashboards.ToList(); count = dashboardlist.Count; Dashboard currentDashboard = new Dashboard(); currentDashboard = dashboardlist.Find(dash => dash.DashboardId == dashboardID); LblDashboardName.Text = currentDashboard.DashboardName; CalendarWeekRule weekRule = CalendarWeekRule.FirstFourDayWeek; DayOfWeek firstWeekDay = DayOfWeek.Monday; Calendar calendar = System.Threading.Thread.CurrentThread.CurrentCulture.Calendar; // currentWeek = calendar.GetWeekOfYear(DateTime.Now, weekRule, firstWeekDay); currentWeek = calendar.GetWeekOfYear(DateTime.Now, weekRule, firstWeekDay); UserID = user.UserId; AccessRight = currentDashboard.UserAccessRight.AccessRightName; CompanyId = user.CompanyId; }
// Returns the week of year for the specified DateTime. The returned value is an // integer between 1 and 53. // public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { if ((int)firstDayOfWeek < 0 || (int)firstDayOfWeek > 6) { throw new ArgumentOutOfRangeException( // TODO: SR //nameof(firstDayOfWeek), SR.Format(SR.ArgumentOutOfRange_Range, nameof(firstDayOfWeek), SR.Format("Valid values are between {0} and {1}, inclusive.", DayOfWeek.Sunday, DayOfWeek.Saturday)); } switch (rule) { case CalendarWeekRule.FirstDay: return(GetFirstDayWeekOfYear(time, (int)firstDayOfWeek)); case CalendarWeekRule.FirstFullWeek: return(GetWeekOfYearFullDays(time, (int)firstDayOfWeek, 7)); case CalendarWeekRule.FirstFourDayWeek: return(GetWeekOfYearFullDays(time, (int)firstDayOfWeek, 4)); } throw new ArgumentOutOfRangeException( // TODO: SR //nameof(rule), SR.Format(SR.ArgumentOutOfRange_Range, nameof(rule), SR.Format("Valid values are between {0} and {1}, inclusive.", CalendarWeekRule.FirstDay, CalendarWeekRule.FirstFourDayWeek)); }
private void InitializeControls() { int iYear = DateTime.Now.Year; for (int i = iYear; i <= iYear + 4; i++) { cmbxAnios.Items.Add(i.ToString()); } cmbxAnios.Text = DateTime.Now.Year.ToString(); //CALCULA Y LLENA EL NÚMERO TOTAL DE SEMANAS DEL AÑO cmbxSemanas.Items.Clear(); DateTimeFormatInfo dfi = DateTimeFormatInfo.CurrentInfo; DateTime date1 = new DateTime(int.Parse(cmbxAnios.Text), 12, 31); Calendar cal = dfi.Calendar; for (int i = 1; i < cal.GetWeekOfYear(date1, dfi.CalendarWeekRule, dfi.FirstDayOfWeek) + 1; i++) { cmbxSemanas.Items.Add(i); } //CALCULAR EL NÚMERO DE SEMANA EN CURSO CultureInfo _CultureInfo = new CultureInfo("en-US"); Calendar _Calendar = _CultureInfo.Calendar; CalendarWeekRule _CalendarWeekRule = _CultureInfo.DateTimeFormat.CalendarWeekRule; DayOfWeek _DayOfWeek = _CultureInfo.DateTimeFormat.FirstDayOfWeek; cmbxSemanas.Text = _Calendar.GetWeekOfYear(DateTime.Now, _CalendarWeekRule, _DayOfWeek).ToString(); txtNoFactura.Focus(); }
public void BclEquivalence( [ValueSource(typeof(BclCalendars), nameof(BclCalendars.MappedCalendars))] Calendar calendar, [ValueSource(nameof(CalendarWeekRules))] CalendarWeekRule bclRule, [ValueSource(nameof(BclDaysOfWeek))] DayOfWeek firstDayOfWeek) { var nodaCalendar = BclCalendars.CalendarSystemForCalendar(calendar) !; var nodaRule = WeekYearRules.FromCalendarWeekRule(bclRule, firstDayOfWeek); var startYear = new LocalDate(2016, 1, 1).WithCalendar(nodaCalendar).Year; for (int year = startYear; year < startYear + 30; year++) { var startDate = new LocalDate(year, 1, 1, nodaCalendar).PlusDays(-15); for (int day = 0; day < 30; day++) { var date = startDate.PlusDays(day); var bclDate = date.ToDateTimeUnspecified(); var bclWeek = calendar.GetWeekOfYear(bclDate, bclRule, firstDayOfWeek); // Weird... the BCL doesn't have a way of finding out which week-year we're in. // We're starting at "start of year - 15 days", so a "small" week-of-year // value means we're in "year", whereas a "large" week-of-year value means // we're in the "year-1". var bclWeekYear = bclWeek < 10 ? year : year - 1; Assert.AreEqual(bclWeek, nodaRule.GetWeekOfWeekYear(date), "Date: {0}", date); Assert.AreEqual(bclWeekYear, nodaRule.GetWeekYear(date), "Date: {0}", date); Assert.AreEqual(date, nodaRule.GetLocalDate(bclWeekYear, bclWeek, date.DayOfWeek, nodaCalendar), "Week-year:{0}; Week: {1}; Day: {2}", bclWeekYear, bclWeek, date.DayOfWeek); } } }
public void CalendarWeekRule_Set_GetReturnsExpected(CalendarWeekRule value) { var format = new DateTimeFormatInfo(); format.CalendarWeekRule = value; Assert.Equal(value, format.CalendarWeekRule); }
static DataService() { Barrel.ApplicationId = AppInfo.PackageName; barrel = Barrel.Create(FileSystem.AppDataDirectory); myCI = new CultureInfo("en-US"); myCWR = myCI.DateTimeFormat.CalendarWeekRule; myFirstDOW = myCI.DateTimeFormat.FirstDayOfWeek; }
public void GetLocalDate_Invalid( CalendarWeekRule bclRule, DayOfWeek firstDayOfWeek, int weekYear, int week, IsoDayOfWeek dayOfWeek) { var nodaRule = WeekYearRules.FromCalendarWeekRule(bclRule, firstDayOfWeek); Assert.Throws <ArgumentOutOfRangeException>(() => nodaRule.GetLocalDate(weekYear, week, dayOfWeek)); }
/// <summary> /// Returns the Week of a specific DateTime and Culture /// </summary> /// <param name="dt">The datetime</param> /// <param name="ci">The culture</param> /// <returns>An integer value with the week</returns> public static int GetWeekOfDate(DateTime dt, CultureInfo ci) { Calendar calendar = ci.Calendar; CalendarWeekRule calendarweekrule = ci.DateTimeFormat.CalendarWeekRule; DayOfWeek firstdayofweek = ci.DateTimeFormat.FirstDayOfWeek; return(calendar.GetWeekOfYear(dt, calendarweekrule, firstdayofweek)); }
public static void GetWeekInYear() { CultureInfo myCI = new CultureInfo("vi-VN"); Calendar myCal = myCI.Calendar; CalendarWeekRule myCWR = myCI.DateTimeFormat.CalendarWeekRule; CurrentWeekOfYear = myCal.GetWeekOfYear(DateTime.Now, myCWR, DayOfWeek.Monday); }
public static IList <Week> GetWeeks(int year, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { var from = new DateTime(year, 1, 1); var to = new DateTime(year, 12, 31); var weeks = GetWeeks(from, to, rule, firstDayOfWeek); return(weeks.Where(w => w.Year == year).ToList()); }
/// <summary> /// 取得本周在一年中的周数 /// </summary> /// <returns></returns> public static int GetThisWeekNo() { CultureInfo myCI = new CultureInfo("en-US"); Calendar myCal = myCI.Calendar; CalendarWeekRule myCWR = myCI.DateTimeFormat.CalendarWeekRule; return(myCal.GetWeekOfYear(DateTime.Now, myCWR, DayOfWeek.Sunday)); }
public static int WeekOfYear(this DateTime value, CalendarWeekRule rule = CalendarWeekRule.FirstDay, DayOfWeek firstDayOfWeek = DayOfWeek.Sunday) { return(CultureInfo .CurrentCulture .DateTimeFormat .Calendar .GetWeekOfYear(value, rule, firstDayOfWeek)); }
/// <summary> /// lấy ra tuần theo ngày hiện tại /// </summary> /// <param name="time"></param> /// <returns></returns> public static int GetWeekOrderInYear(DateTime time) { CultureInfo myCI = CultureInfo.CurrentCulture; System.Globalization.Calendar myCal = myCI.Calendar; CalendarWeekRule myCWR = myCI.DateTimeFormat.CalendarWeekRule; DayOfWeek myFirstDOW = myCI.DateTimeFormat.FirstDayOfWeek; return myCal.GetWeekOfYear(time, myCWR, myFirstDOW); }
public void TestLocaleFirstDay() { CultureInfo myTestCulture = new CultureInfo("en-US"); DateTimeFormatInfo dti = myTestCulture.DateTimeFormat; CalendarWeekRule actual = dti.CalendarWeekRule; Assert.Equal(CalendarWeekRule.FirstDay, actual); }
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 static int GetDayOfYearHelper(Calendar calendar, DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { int weekOfYear = calendar.GetWeekOfYear(time, rule, firstDayOfWeek); int dayOfYear = calendar.GetDayOfYear(time); // 1-based int dayOfWeek = calendar.GetDayOfWeek(time) - firstDayOfWeek + 1; // 1-based if (dayOfWeek <= 0) { dayOfWeek += DaysPerWeek; // Make it a positive value } int dayOfWeekForJan1 = dayOfWeek - (dayOfYear - 1) % DaysPerWeek; // 1-based if (dayOfWeekForJan1 <= 0) { dayOfWeekForJan1 += DaysPerWeek; // 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); } int offset = 0; switch (rule) { case CalendarWeekRule.FirstDay: offset = dayOfWeek - dayOfWeekForJan1; break; case CalendarWeekRule.FirstFourDayWeek: if (dayOfWeekForJan1 <= 4) { offset = dayOfWeek - dayOfWeekForJan1; } else { offset = dayOfWeek + DaysPerWeek - dayOfWeekForJan1; } break; case CalendarWeekRule.FirstFullWeek: if (dayOfWeekForJan1 == 1) { offset = dayOfWeek - dayOfWeekForJan1; } else { offset = dayOfWeek + DaysPerWeek - dayOfWeekForJan1; } break; } return((weekOfYear - 1) * DaysPerWeek + offset + 1);; }
/// <summary> /// Indicates whether the given date is in even week or not. /// </summary> /// <param name="dt">The date</param> /// <returns>A boolean value represents whether the given date is in even week or not</returns> public static bool IsEvenWeek(DateTime dt) { CultureInfo culture = new CultureInfo("de-DE"); Calendar calendar = culture.Calendar; CalendarWeekRule calendarWeekRule = culture.DateTimeFormat.CalendarWeekRule; DayOfWeek FirstDayOfWeek = culture.DateTimeFormat.FirstDayOfWeek; return(calendar.GetWeekOfYear(dt, calendarWeekRule, FirstDayOfWeek) % 2 == 0); }
//Get text represntation of the input parmeters private string GetParamsInfo(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { string str; str = string.Format("\nThe specified time: {0}).", time); str += string.Format("\nThe calendar week rule: {0}", rule); str += string.Format("\nThe first day of week: {0}", firstDayOfWeek); return(str); }
private void VerificationHelper(DateTimeFormatInfo info, CalendarWeekRule expected, bool setter) { if (setter) { info.CalendarWeekRule = expected; } CalendarWeekRule actual = info.CalendarWeekRule; Assert.Equal(expected, actual); }
/// <summary> /// Get the last date of the week for a certain date. /// /// Note that for ISO 8601 dates, iso8601 must be set to true. /// </summary> public static DateTime GetLastDateOfWeek(this DateTime date, bool iso8601 = false, CalendarWeekRule weekRule = CalendarWeekRule.FirstFourDayWeek, DayOfWeek firstDayOfWeek = DayOfWeek.Monday) { if (date == DateTime.MaxValue) return date; var week = date.GetWeekNumber(iso8601, weekRule, firstDayOfWeek); while (week == date.GetWeekNumber(iso8601, weekRule, firstDayOfWeek)) date = date.AddDays(1); return date.AddDays(-1); }
public SchedulerDisplayInfo(CultureInfo culture) { this.culture = culture; firstDayOfWeek = DayOfWeek.Monday; calendarWeekRule = CalendarWeekRule.FirstDay; workingDays = new bool[7]; for(int i=0;i<7;i++) workingDays[i] = ((DayOfWeek)i != DayOfWeek.Saturday) && ((DayOfWeek)i != DayOfWeek.Sunday); workingHoursFrom = new TimeSpan(8, 0, 0); workingHoursTo = new TimeSpan(17, 0, 0); }
private int GetWeekOfYearFullDays(DateTime time, CalendarWeekRule rule, int firstDayOfWeek, int fullDays) { GregorianCalendar gregorianCalendar = new GregorianCalendar(); // Make the day of year to be 0-based, so that 1/1 is day 0. int dayOfYear = gregorianCalendar.GetDayOfYear(time) - 1; // // 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. int dayForJan1 = (int)gregorianCalendar.GetDayOfWeek(time) - (dayOfYear % 7); // Now, calculate the offset. Subtract the first day of week from the dayForJan1. And make it a positive value. int 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. int 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. // Call this method again by passing the last day of previous year. return GetWeekOfYearFullDays(time.AddDays(-(dayOfYear + 1)), rule, firstDayOfWeek, fullDays); }
private static int GetDayOfYearHelper(Calendar calendar, DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { int weekOfYear = calendar.GetWeekOfYear(time, rule, firstDayOfWeek); int dayOfYear = calendar.GetDayOfYear(time); // 1-based int dayOfWeek = calendar.GetDayOfWeek(time) - firstDayOfWeek + 1; // 1-based if (dayOfWeek <= 0) dayOfWeek += DaysPerWeek; // Make it a positive value int dayOfWeekForJan1 = dayOfWeek - (dayOfYear - 1) % DaysPerWeek; // 1-based if (dayOfWeekForJan1 <= 0) dayOfWeekForJan1 += DaysPerWeek; // 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; } int offset = 0; switch (rule) { case CalendarWeekRule.FirstDay: offset = dayOfWeek - dayOfWeekForJan1; break; case CalendarWeekRule.FirstFourDayWeek: if (dayOfWeekForJan1 <= 4) { offset = dayOfWeek - dayOfWeekForJan1; } else { offset = dayOfWeek + DaysPerWeek - dayOfWeekForJan1; } break; case CalendarWeekRule.FirstFullWeek: if (dayOfWeekForJan1 == 1) { offset = dayOfWeek - dayOfWeekForJan1; } else { offset = dayOfWeek + DaysPerWeek - dayOfWeekForJan1; } break; } return (weekOfYear - 1) * DaysPerWeek + offset + 1;; }
public static DateTime FirstDateOfWeek(int year, int weekNum, CalendarWeekRule rule) { var jan1 = new DateTime(year, 1, 1); var daysOffset = DayOfWeek.Monday - jan1.DayOfWeek; var firstMonday = jan1.AddDays(daysOffset); var cal = CultureInfo.CurrentCulture.Calendar; var firstWeek = cal.GetWeekOfYear(jan1, rule, DayOfWeek.Monday); if (firstWeek <= 1) weekNum -= 1; return firstMonday.AddDays(weekNum * 7); }
/// <summary> /// <paramref name="weekOfYearRule"/> 에 따라 <paramref name="weekRule"/>과 <paramref name="firstDayOfWeek"/> 를 결정합니다. /// </summary> /// <param name="culture">문화권</param> /// <param name="weekOfYearRule">주차 계산을 위한 룰</param> /// <param name="weekRule">한해의 첫주를 산정하는 규칙</param> /// <param name="firstDayOfWeek">한주의 첫번째 요일</param> public static void GetCalendarWeekRuleAndFirstDayOfWeek(CultureInfo culture, WeekOfYearRuleKind? weekOfYearRule, out CalendarWeekRule weekRule, out DayOfWeek firstDayOfWeek) { if(weekOfYearRule.GetValueOrDefault(WeekOfYearRuleKind.Calendar) == WeekOfYearRuleKind.Calendar) { weekRule = culture.GetOrCurrentCulture().DateTimeFormat.CalendarWeekRule; firstDayOfWeek = culture.GetOrCurrentCulture().DateTimeFormat.FirstDayOfWeek; } else { weekRule = CalendarWeekRule.FirstFourDayWeek; firstDayOfWeek = DayOfWeek.Monday; } if(IsDebugEnabled) log.Debug("WeekOfyearRuleKind에 따른 CalendarWeekRule, FirstDayOfWeek 정보를 결정했습니다!!! " + @"culture=[{0}], weekOfYearRule=[{1}], weekRule=[{2}], firstDayOfWeek=[{3}]", culture, weekOfYearRule, weekRule, firstDayOfWeek); }
public void GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { Assert.InRange(rule, (CalendarWeekRule)0, (CalendarWeekRule)3); int expected = 0; if (rule == CalendarWeekRule.FirstDay) { expected = GetWeekOfYearFirstDay(time, (int)firstDayOfWeek); } else if (rule == CalendarWeekRule.FirstFullWeek) { expected = GetWeekOfYearFullDays(time, rule, (int)firstDayOfWeek, 7); } else { expected = GetWeekOfYearFullDays(time, rule, (int)firstDayOfWeek, 4); } Assert.Equal(expected, new TaiwanCalendar().GetWeekOfYear(time, rule, firstDayOfWeek)); }
//Initiate stuff public Main() { InitializeComponent(); button2.Enabled = false; this.comboBox1.Items.AddRange(loadNames()); myCI = new CultureInfo("en-US"); myCal = myCI.Calendar; // Gets the DTFI properties required by GetWeekOfYear. myCWR = myCI.DateTimeFormat.CalendarWeekRule; myFirstDOW = myCI.DateTimeFormat.FirstDayOfWeek; week = myCal.GetWeekOfYear(DateTime.Now, myCWR, myFirstDOW); numericUpDown2.Value = week; SetTitle(); loadWeekSales(); }
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; }
/// <summary> /// Returns the week of the year that includes the date in the specified DateTime value. /// </summary> /// <param name="time">A date and time value.</param> /// <param name="rule">An enumeration value that defines a calendar week.</param> /// <param name="firstDayOfWeek">An enumeration value that represents the first day of the week.</param> /// <returns>A positive integer that represents the week of the year /// that includes the date in the <paramref name="time"/> parameter.</returns> public static int GetWeekOfYear(this DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { return CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(time, rule, firstDayOfWeek); }
/// <summary> /// Returns the week of the year that includes the date in the specified DateTime value. /// </summary> /// <param name="time">A date and time value.</param> /// <param name="rule">An enumeration value that defines a calendar week.</param> /// <returns>A positive integer that represents the week of the year /// that includes the date in the <paramref name="time"/> parameter.</returns> public static int GetWeekOfYear(this DateTime time, CalendarWeekRule rule) { return GetWeekOfYear(time, rule, CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek); }
// ---------------------------------------------------------------------- public static bool IsSameWeek( DateTime left, DateTime right, CultureInfo culture, CalendarWeekRule weekRule, DayOfWeek firstDayOfWeek, YearWeekType weekType ) { if ( culture == null ) { throw new ArgumentNullException( "culture" ); } // left int leftWeekOfYear; int leftYear; TimeTool.GetWeekOfYear( left, culture, weekRule, firstDayOfWeek, weekType, out leftYear, out leftWeekOfYear ); // rught int rightWeekOfYear; int rightYear; TimeTool.GetWeekOfYear( right, culture, weekRule, firstDayOfWeek, weekType, out rightYear, out rightWeekOfYear ); return leftYear == rightYear && leftWeekOfYear == rightWeekOfYear; }
public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { CheckTicksRange(time.Ticks); // Use GregorianCalendar to get around the problem that the implmentation in Calendar.GetWeekOfYear() // can call GetYear() that exceeds the supported range of the Gregorian-based calendars. return (GregorianCalendar.GetDefaultInstance().GetWeekOfYear(time, rule, firstDayOfWeek)); }
// Returns the week of year for the specified DateTime. The returned value is an // integer between 1 and 53. // public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { if ((int)firstDayOfWeek < 0 || (int)firstDayOfWeek > 6) { throw new ArgumentOutOfRangeException( nameof(firstDayOfWeek), SR.Format(SR.ArgumentOutOfRange_Range, DayOfWeek.Sunday, DayOfWeek.Saturday)); } Contract.EndContractBlock(); switch (rule) { case CalendarWeekRule.FirstDay: return (GetFirstDayWeekOfYear(time, (int)firstDayOfWeek)); case CalendarWeekRule.FirstFullWeek: return (GetWeekOfYearFullDays(time, (int)firstDayOfWeek, 7)); case CalendarWeekRule.FirstFourDayWeek: return (GetWeekOfYearFullDays(time, (int)firstDayOfWeek, 4)); } throw new ArgumentOutOfRangeException( nameof(rule), SR.Format(SR.ArgumentOutOfRange_Range, CalendarWeekRule.FirstDay, CalendarWeekRule.FirstFourDayWeek)); }
public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { return default(int); }
internal int GetWeekOfYearFullDays(DateTime time, CalendarWeekRule rule, int firstDayOfWeek, int fullDays) { int num4 = this.GetDayOfYear(time) - 1; int num = ((int) this.GetDayOfWeek(time)) - (num4 % 7); int num2 = ((firstDayOfWeek - num) + 14) % 7; if ((num2 != 0) && (num2 >= fullDays)) { num2 -= 7; } int num3 = num4 - num2; if (num3 >= 0) { return ((num3 / 7) + 1); } return this.GetWeekOfYearFullDays(time.AddDays((double) -(num4 + 1)), rule, firstDayOfWeek, fullDays); }
public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { if ((firstDayOfWeek < DayOfWeek.Sunday) || (firstDayOfWeek > DayOfWeek.Saturday)) { throw new ArgumentOutOfRangeException("firstDayOfWeek", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), new object[] { DayOfWeek.Sunday, DayOfWeek.Saturday })); } switch (rule) { case CalendarWeekRule.FirstDay: return this.GetFirstDayWeekOfYear(time, (int) firstDayOfWeek); case CalendarWeekRule.FirstFullWeek: return this.GetWeekOfYearFullDays(time, rule, (int) firstDayOfWeek, 7); case CalendarWeekRule.FirstFourDayWeek: return this.GetWeekOfYearFullDays(time, rule, (int) firstDayOfWeek, 4); } throw new ArgumentOutOfRangeException("rule", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), new object[] { CalendarWeekRule.FirstDay, CalendarWeekRule.FirstFourDayWeek })); }
/// <summary> /// A virtual method that gives the number of the week in the year. /// </summary> /// <param name="time">A /// <see cref="T:System.DateTime"/> representing the date. /// </param> /// <param name="rule">The /// <see cref="T:System.Globalization.CalendarWeekRule"/> /// to be used for the calculation. /// </param> /// <param name="firstDayOfWeek"> /// The <see cref="T:System.Globalization.DayOfWeek"/> /// specifying the first day in a week. /// </param> /// <returns>An integer representing the number of the week in the /// year, starting with 1. /// </returns> public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { if (firstDayOfWeek < DayOfWeek.Sunday || DayOfWeek.Saturday < firstDayOfWeek) { throw new ArgumentOutOfRangeException("firstDayOfWeek", "Value is not a valid day of week."); } int year = GetYear(time); int days; while (true) { DateTime secondWeek = M_GetFirstDayOfSecondWeekOfYear( year, rule, firstDayOfWeek); days = M_DiffDays(time, secondWeek) + M_DaysInWeek; if (days >= 0) break; year -= 1; } return 1 + days/M_DaysInWeek; }
/// <summary> /// A protected method that gives the first day of the second week of /// the year. /// </summary> /// <param name="year">An integer that represents the year.</param> /// <param name="rule">The /// <see cref="T:System.Globalization.CalendarWeekRule"/> /// to be used for the calculation. /// </param> /// <param name="firstDayOfWeek"> /// The <see cref="T:System.Globalization.DayOfWeek"/> /// specifying the first day in a week. /// </param> /// <returns>The <see cref="T:System.DateTime"/> representing /// the first day of the second week of the year. /// </returns> internal DateTime M_GetFirstDayOfSecondWeekOfYear( int year, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { DateTime d1 = ToDateTime(year, 1, 1, 0, 0, 0, 0); int dow1 = (int)GetDayOfWeek(d1); int fdow = (int)firstDayOfWeek; int d = 0; switch (rule) { case CalendarWeekRule.FirstDay: if (fdow > dow1) { d += fdow - dow1; } else { d += fdow + M_DaysInWeek - dow1; } break; case CalendarWeekRule.FirstFullWeek: d = M_DaysInWeek; if (fdow >= dow1) { d += fdow - dow1; } else { d += fdow + M_DaysInWeek - dow1; } break; case CalendarWeekRule.FirstFourDayWeek: int dow4 = (dow1 + 3)%M_DaysInWeek; d = 3; if (fdow > dow4) { d += fdow - dow4; } else { d += fdow + M_DaysInWeek - dow4; } break; } return AddDays(d1, d); }
public virtual int GetWeekOfYear(System.DateTime time, CalendarWeekRule rule, System.DayOfWeek firstDayOfWeek) {}
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); }
//Get text represntation of the input parmeters private string GetParamsInfo(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { string str; str = string.Format("\nThe specified time: {0}).", time); str += string.Format("\nThe calendar week rule: {0}", rule); str += string.Format("\nThe first day of week: {0}", firstDayOfWeek); return str; }
/// <summary> /// 두 DateTime 값이 주(Week) 단위까지 같은지 판단합니다. /// </summary> public static bool IsSameWeek(this DateTime left, DateTime right, CultureInfo culture, CalendarWeekRule weekRule, DayOfWeek firstDayOfWeek, WeekOfYearRuleKind weekOfYearRuleKind) { culture = culture.GetOrCurrentCulture(); var leftYearWeek = GetWeekOfYear(left, culture, weekRule, firstDayOfWeek, weekOfYearRuleKind); var rightYearWeek = GetWeekOfYear(right, culture, weekRule, firstDayOfWeek, weekOfYearRuleKind); return Equals(leftYearWeek, rightYearWeek); }
public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek) { return (helper.GetWeekOfYear(time, rule, firstDayOfWeek)); }
private static int GCWeekOfYear(DateTime date, CalendarWeekRule rule, DayOfWeek firstDayOfWeek = (DayOfWeek)(-1)) { if (firstDayOfWeek == (DayOfWeek)(-1)) { firstDayOfWeek = CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek; } GregorianCalendar gc = new GregorianCalendar(GregorianCalendarTypes.Localized); return gc.GetWeekOfYear(date, rule, firstDayOfWeek); }