Example #1
0
        public static DateTime AddType(this DateTime instance, TimeUnits type, double increment)
        {
            DateTime result = instance;

            switch (type)
            {
                case TimeUnits.Days:
                    result = instance.AddDays(increment);
                    break;
                case TimeUnits.Months:
                    increment *= DateTime.DaysInMonth(instance.Year, instance.Month);
                    result = instance.AddDays((int)(Math.Floor(increment)));
                    break;
                case TimeUnits.Weeks:

                    result = instance.AddDays(increment * 7);
                    break;
                case TimeUnits.Years:
                    if (DateTime.IsLeapYear(instance.Year))
                        increment *= 366;
                    else
                        increment *= 365;

                    result = instance.AddDays((int)(Math.Floor(increment)));
                    break;
                case TimeUnits.Hours:
                    result = instance.AddHours(increment);
                    break;
            }

            return result;
        }
Example #2
0
 public static DateTime Interval(this DateTime date, DateTimePart? intervalType, int? intervalVal)
 {
     if (intervalType.HasValue && intervalVal.HasValue)
     {
         switch (intervalType.Value)
         {
             case DateTimePart.Year:
                 return date.AddYears(intervalVal.Value);
             case DateTimePart.Month:
                 return date.AddMonths(intervalVal.Value);
             case DateTimePart.Day:
                 return date.AddDays((double)intervalVal.Value);
             case DateTimePart.Hour:
                 return date.AddHours((double)intervalVal.Value);
             case DateTimePart.Munite:
                 return date.AddMinutes((double)intervalVal.Value);
             case DateTimePart.Second:
                 return date.AddSeconds((double)intervalVal.Value);
             case DateTimePart.Week:
                 return date.AddDays((double)intervalVal.Value * 7);
             case DateTimePart.Quarter:
                 return date.AddMonths(intervalVal.Value * 3);
         }
     }
     return date;
 }
        public static DateTime AddMonths(this DateTime value, double months, bool ignoreSundays)
        {
            if (months < 0)
                throw new NotImplementedException();        //# not implemented

            if (months == 0)
            {
                int extraDaysToAdd = 0;
                while (ignoreSundays && value.AddDays(extraDaysToAdd).DayOfWeek == DayOfWeek.Sunday)
                    extraDaysToAdd += 1;
                return value.AddDays(extraDaysToAdd);
            }

            if (months < 1)
            {
                const int fixedDaysInMonth = 30;
                int daysToAdd = (int)Math.Floor(fixedDaysInMonth * months);
                int extraDaysToAdd = 0;
                while (ignoreSundays && value.AddDays(daysToAdd + extraDaysToAdd).DayOfWeek == DayOfWeek.Sunday)
                    extraDaysToAdd += 1;
                return value.AddDays(daysToAdd + extraDaysToAdd);
            }
            else
            {
                int monthsFloor = (int)Math.Floor(months);
                return value.AddMonths(monthsFloor).AddMonths(months - monthsFloor, ignoreSundays);
            }
        }
Example #4
0
 /// <summary>
 /// 获取本周的开始时间和结束时间
 /// </summary>
 /// <param name="time">时间</param>
 /// <param name="begin">返回本周的开始时间</param>
 /// <param name="end">返回本周的结束时间</param>
 public static void GetWeekBeginAndEndTime(this DateTime time, out DateTime begin, out DateTime end)
 {
     var inWeekCount = time.GetTimeInWeekCount();
     if (inWeekCount == 0) inWeekCount = 7;
     begin = time.AddDays(-(inWeekCount - 1));
     end = time.AddDays((7 - inWeekCount));
 }
Example #5
0
 /// <summary>
 /// Returns the closest Weekday (Financial day) Date
 /// </summary>
 /// <param name="obj">DateTime Base, from where the calculation will be preformed.</param>
 /// <returns>Returns the closest Weekday (Financial day) Date</returns>
 public static DateTime FindClosestWeekDay(this DateTime obj)
 {
     if (obj.DayOfWeek == DayOfWeek.Saturday)
         return obj.AddDays(-1);
     if (obj.DayOfWeek == DayOfWeek.Sunday)
         return obj.AddDays(1);
     return obj;
 }
 public static DateTime ToNearestWorkingDay(this DateTime date)
 {
     switch (date.DayOfWeek)
     {
         case DayOfWeek.Saturday: return date.AddDays(2);
         case DayOfWeek.Sunday: return date.AddDays(1);
         default: return date;
     }
 }
 /// <summary>
 /// Extension method used to determine the closest working day to a specific date.
 /// </summary>
 /// <param name="dateToCheck">The DateTime variable that will use the extenison method.</param>
 /// <returns>A DateTime value that corresponds to the closest business day
 /// in relation to the supplied date. This does not take into consideration
 /// any holidays and assumes a Monday to Friday business week.</returns>
 public static DateTime ClosestBusinessDay(this DateTime dateToCheck)
 {
     if (dateToCheck.DayOfWeek == DayOfWeek.Saturday)
         return dateToCheck.AddDays(-1);
     else if (dateToCheck.DayOfWeek == DayOfWeek.Sunday)
         return dateToCheck.AddDays(1);
     else
         return dateToCheck;
 }
        /// <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);
        }
        private static DateTime AddDaysSkippingWeekends(this DateTime d, int numberOfDays, IEnumerable<DateTime> skipDays)
        {
            var nextDay = d.AddDays(numberOfDays);

            if (nextDay.DayOfWeek == DayOfWeek.Saturday || nextDay.DayOfWeek == DayOfWeek.Sunday || (skipDays != null && skipDays.Any(date => date == nextDay)))
            {
                return d.AddDaysSkippingWeekends(numberOfDays + 1, skipDays);
            }

            return d.AddDays(numberOfDays);
        }
        /// <summary>
        /// Returns the last occurance of the specified day
        /// </summary>
        /// <param name="dt">Start date</param>
        /// <param name="day">Day to find</param>
        /// <param name="ignoreCurrent">Ignore the current day if it matches</param>
        /// <returns></returns>
        public static DateTime PreviousOccurance(this DateTime dt, DayOfWeek day, bool ignoreCurrent = true)
        {
            if (!ignoreCurrent && dt.DayOfWeek == day)
                return dt.AddDays(-7);

            while (dt.DayOfWeek != day)
            {
                dt = dt.AddDays(-1);
            }

            return dt;
        }
 public static DateTime ToEndOfBusinessWeek(this DateTime endOfWeek)
 {
     while (endOfWeek.DayOfWeek == DayOfWeek.Saturday || endOfWeek.DayOfWeek == DayOfWeek.Sunday)
     {
         endOfWeek = endOfWeek.AddDays(-1);
     }
     while (endOfWeek.DayOfWeek != DayOfWeek.Friday)
     {
         endOfWeek = endOfWeek.AddDays(1);
     }
     return endOfWeek;
 }
		public static DateTimeOffset SkipToNextWorkDay(this DateTimeOffset date)
		{
			// we explicitly choose not to user the CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek
			// because we want it to be fixed for what we need, not whatever the user for this is set to.
			if (date.DayOfWeek == DayOfWeek.Saturday)
				return date.AddDays(2);

			if (date.DayOfWeek == DayOfWeek.Sunday)
				return date.AddDays(1);

			return date;
		}
 /// <summary>
 /// 	Gets the next week day after the given date
 /// </summary>
 public static DateTime GetNextWeekDay(this DateTime date)
 {
     if (date.DayOfWeek == DayOfWeek.Friday)
     {
         return date.AddDays(3);
     }
     if (date.DayOfWeek == DayOfWeek.Saturday)
     {
         return date.AddDays(2);
     }
     return date.AddDays(1);
 }
 /// <summary>
 /// 	Gets the previous week day before the given date
 /// </summary>
 public static DateTime GetPreviousWeekDay(this DateTime date)
 {
     if (date.DayOfWeek == DayOfWeek.Monday)
     {
         return date.AddDays(-3);
     }
     if (date.DayOfWeek == DayOfWeek.Sunday)
     {
         return date.AddDays(-2);
     }
     return date.AddDays(-1);
 }
        internal static DateTime NextNWeekday(this DateTime current, int toAdvance)
        {
            while (toAdvance >= 1)
            {
                toAdvance--;
                current = current.AddDays(1);

                while (!current.IsWeekday())
                    current = current.AddDays(1);
            }
            return current;
        }
Example #16
0
        /// <summary>
        /// –азрешает дату, относительно заданной
        /// </summary>
        /// <param name="source">исходна¤ дата</param>
        /// <param name="resolver">смещение</param>
        /// <returns></returns>
        public static DateTime resolveDateTime(this DateTime source, string resolver)
        {

            //если пр¤мо указана дата - берем ее
            DateTime directDate = new DateTime();
            var fullDefinition = DateTime.TryParseExact(resolver, "dd.MM.yyyy", CultureInfo.InvariantCulture, DateTimeStyles.None, out directDate);
            if (fullDefinition)
            {
                return directDate;
            }
            //если цифры, то "за столько дней назад"
            if (resolver.like(@"^-?\d+$")) return source.AddDays(-Int32.Parse(resolver));

            var c = 1;

            //если W -то "с начала недели", цифра показывает за сколько последних недель
            if (resolver.like(@"^[Ww]\d*"))
            {
                var cnt = resolver.find(@"\d+");
                if (cnt.hasContent())
                {
                    c = Int32.Parse(cnt);
                }
                var ds = 1 + (int)source.DayOfWeek;
                if (ds == 7) ds = 0;
                return source.AddDays(-7 * (c - 1) - ds);
            }
            //если M -то "с начала мес¤ца", цифра показывает за сколько последних мес¤цев
            if (resolver.like(@"^[Mm]\d*"))
            {
                var cnt = resolver.find(@"\d+");
                if (cnt.hasContent())
                {
                    c = Int32.Parse(cnt);
                }

                return new DateTime(source.Year, source.Month, 1).AddMonths(-(c - 1));
            }
            //если Y -то "с начала года", цифра показывает за сколько последних годов
            if (resolver.like(@"^[Yy]\d*"))
            {
                var cnt = resolver.find(@"\d+");
                if (cnt.hasContent())
                {
                    c = Int32.Parse(cnt);
                }

                return new DateTime(source.Year, 1, 1).AddYears(-(c - 1));
            }

            throw new InvalidOperationException("Ќеверный формат резольвера - " + resolver);
        }
        internal static DateTime WeekendDate(this DateTime date)
        {

            switch (date.DayOfWeek)
            {
                case DayOfWeek.Saturday:
                    return date.AddDays(2);
                case DayOfWeek.Sunday:
                    return date.AddDays(1);
                default:
                    return date;
            }
        }
 /// <summary>
 ///     This will add the given number of days excluding Saturday and Sunday.
 /// </summary>
 /// <param name="d"></param>
 /// <param name="days"></param>
 /// <returns></returns>
 public static DateTime AddWeekdays(this DateTime d, int days)
 {
     // http://www.extensionmethod.net/csharp/datetime/addworkdays
     // Lee Harding
     // start from a weekday
     while (d.DayOfWeek.IsWeekday()) d = d.AddDays(1.0);
     for (var i = 0; i < days; ++i)
     {
         d = d.AddDays(1.0);
         while (d.DayOfWeek.IsWeekday()) d = d.AddDays(1.0);
     }
     return d;
 }
Example #19
0
        public static DateTime AddWorkingDays(this DateTime dt, int workingDays)
        {
            var direction = workingDays < 0 ? -1 : 1;
            for (int i = 0; i < Math.Abs(workingDays); i++)
            {
                dt = dt.AddDays(direction);
                while (dt.DayOfWeek == DayOfWeek.Saturday || dt.DayOfWeek == DayOfWeek.Sunday)
                {
                    dt = dt.AddDays(direction);
                }
            }

            return dt;
        }
        public static DateTime[] GetNextWeekEnd(this DateTime date)
        {
            if (date.IsWeekEnd())
            {
                date = date.AddDays(3);
            }

            while (date.DayOfWeek != DayOfWeek.Friday)
            {
                date = date.AddDays(1);
            }

            return new[] { date.AddDays(2), date.AddDays(1), date };
        }
        public static DateTime[] GetLastWeekEnd(this DateTime date)
        {
            if (date.IsWeekEnd())
            {
                date = date.AddDays(-3);
            }

            while (date.DayOfWeek != DayOfWeek.Sunday)
            {
                date = date.AddDays(-1);
            }

            return new[] { date.AddDays(-2), date.AddDays(-1), date };
        }
Example #22
0
        public static DateTime FindNext(this DateTime now, DayOfWeek dayOfWeek, bool includeToday = false)
        {
            if (includeToday)
            {
                now = now.AddDays(-1);
            }

            do
            {
                now = now.AddDays(1);
                if (now.DayOfWeek == dayOfWeek)
                    return now;
            } while (true);
        }
 /// <summary>
 /// Add an interval of time (or some multiple thereof) to a DateTime.
 /// </summary>
 public static DateTime AddInterval(this DateTime dt, Time.IntervalType interval, int numberOfIntervals)
 {
     if (interval == Time.IntervalType.Day)
         return dt.AddDays(numberOfIntervals);
     else if (interval == Time.IntervalType.Week)
         return dt.AddDays(7 * numberOfIntervals);
     else if (interval == Time.IntervalType.Month)
         return dt.AddMonths(numberOfIntervals);
     else if (interval == Time.IntervalType.Quarter) // won't necessarily work for qtr end dates
         return dt.AddMonths(3 * numberOfIntervals);
     else if (interval == Time.IntervalType.Year)
         return dt.AddYears(numberOfIntervals);
     else
         return dt;
 }
Example #24
0
 /// <summary>
 /// Get the closet date for target DayOfWeek
 /// </summary>
 /// <param name="date">The originial date</param>
 /// <param name="target">The target of DayOfWeek</param>
 /// <returns>The closet date which is target day of week</returns>
 public static DateTime GetClosetDate(this DateTime date, DayOfWeek target)
 {
     if (date.DayOfWeek == target)
     {
         return date;
     }
     if (date.DayOfWeek > target)
     {
         return date.AddDays(target - date.DayOfWeek).Date;
     }
     else
     {
         return date.AddDays(target - date.DayOfWeek - 7).Date;
     }
 }
Example #25
0
        public static DateTime DiaUtilBancario(this DateTime data)
        {
            while (data.DayOfWeek == DayOfWeek.Saturday || data.DayOfWeek == DayOfWeek.Sunday || data.EhFeriadoBancario())
                data = data.AddDays(1);

            return data;
        }
Example #26
0
        /// <summary>
        /// Tests if a date is within the last number of specified days.
        /// </summary>
        /// <param name="date">The date.</param>
        /// <param name="days">The number of days.</param>
        /// <returns>
        /// Returns true or false depending on if the date is within the last number of days.
        /// </returns>
        public static bool DateWithinLastDays(this DateTime date, int days)
        {
            var lastDays    = (double)0 - days;
            var startDate   = date.AddDays(lastDays);

            return (date >= startDate);
        }
        /// <summary>
        /// Gets the last.
        /// </summary>
        /// <param name="input">    The date/ time.</param>
        /// <param name="dayOfWeek">The day of week.</param>
        /// <returns>DateTime.</returns>
        public static DateTime GetLast(this DateTime input, DayOfWeek dayOfWeek)
        {
            Contract.Requires<ArgumentOutOfRangeException>(Enum.IsDefined(typeof(DayOfWeek), input));

            var daysToSubtract = input.DayOfWeek > dayOfWeek ? input.DayOfWeek - dayOfWeek : (7 - (int)dayOfWeek) + (int)input.DayOfWeek;
            return input.AddDays(daysToSubtract * -1);
        }
Example #28
0
 public static DateTime NextMonth(this DateTime date)
 {
     if (date.Day != DateTime.DaysInMonth(date.Year, date.Month))
         return date.AddMonths(1);
     else
         return date.AddDays(1).AddMonths(1).AddDays(-1);
 }
Example #29
0
 public static DateTime PrevWeekDay(this DateTime self)
 {
   DateTime d = self.AddDays(-1d);
   while (d.DayOfWeek == DayOfWeek.Saturday || d.DayOfWeek == DayOfWeek.Sunday)
     d = d.AddDays(-1d);
   return d;
 }
Example #30
0
 public static DateTime StartOfWeek(this DateTime dt, DayOfWeek startOfWeek)
 {
     int diff = dt.DayOfWeek - startOfWeek;
     if (diff < 0)
         diff += 7;
     return dt.AddDays(-1 * diff).Date;
 }