public static DateTime RoundMinutes(this DateTime dateTime)
        {
            dateTime.AddSeconds(-dateTime.Second);
            dateTime.AddMilliseconds(-dateTime.Millisecond);

            var remainder = dateTime.Minute % 15;

            dateTime = dateTime.AddMinutes(remainder * -1);

            if (remainder > 7)
            {
                dateTime = dateTime.AddMinutes(15);
            }

            return dateTime;
        }
        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;
                case TimeUnits.Minutes:
                    result = instance.AddMinutes(increment);
                    break;
            }

            return result;
        }
Example #3
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;
 }
Example #4
0
 ///////////////////////////////////////////////////////////////////////
 public static DateTime NextMinute(this DateTime date)
 {
     DateTime next = date.AddMinutes(1);
     next = next.SetSecond(0);
     next = next.SetMillisecond(0);
     return next;
 }
        /// <summary>
        /// Generates a PartitionKey representation (in reverse order) based on the specified <see cref="DateTime"/>.
        /// </summary>
        /// <param name="dateTime">The DateTime.</param>
        /// <returns>A string representing the Partition Key (in reverse order).</returns>
        public static string GeneratePartitionKeyReversed(this DateTime dateTime)
        {
            dateTime = dateTime.AddMinutes(-1D);
            var pk = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, 0);

            return GetTicksReversed(pk);
        }
        public static DateTime Round(this DateTime dateTime)
        {
            DateTime result = dateTime.AddMinutes(dateTime.Minute >= 30 ? (60 - dateTime.Minute) : (30 - dateTime.Minute));
            result = result.AddSeconds(-1 * result.Second); // To reset seconds to 0
            result = result.AddMilliseconds(-1 * result.Millisecond); // To reset milliseconds to 0

            return result;
        }
        /// <summary>
        /// Converts the specified client time to UTC Date Time.
        /// </summary>
        /// <param name="dateTime">Date time object to be converted.</param>
        /// <returns>Date time in UTC time zone.</returns>
        public static DateTime ToUTCFromClientTime(this DateTime dateTime)
        {
            var timeOffSet = HttpContext.Current.Session["__TimezoneOffset"];

            if (timeOffSet != null)
            {
                var offset = int.Parse(timeOffSet.ToString());
                dateTime = dateTime.AddMinutes(1 * offset);
            }

            return dateTime;
        }
        /// <summary>
        /// Rounds the minute component to the nearest specified time. Defaults to 1 hour
        /// </summary>
        /// <param name="source"></param>
        /// <param name="rounding"></param>
        /// <returns></returns>
        public static DateTime RoundMinutes(this DateTime source, MinuteRounding rounding = MinuteRounding.Hour)
        {
            if (rounding == MinuteRounding.QuarterHour)
                throw new NotImplementedException("Coming soon");

            switch (rounding)
            {
                case MinuteRounding.Hour:
                    if (source.Minute >= 30)
                        return source.AddHours(1).AddMinutes(-source.Minute).TrimSeconds();
                    return source.AddMinutes(-source.Minute).TrimSeconds();
                case MinuteRounding.HalfHour:
                    if (source.Minute < 15)
                        return source.AddMinutes(-source.Minute).TrimSeconds();
                    if (source.Minute >= 15 && source.Minute < 45)
                        return source.AddMinutes(-source.Minute).AddMinutes(30).TrimSeconds();
                    return source.AddHours(1).AddMinutes(-source.Minute).TrimSeconds();
                default:
                    throw new ArgumentOutOfRangeException("rounding");
            }
        }
        public static DateTime LocalToUtc(this DateTime local, int utcOffset)
        {
            if (local != DateTime.MinValue && local != DateTime.MaxValue)
            {
                try
                {
                    return local.AddMinutes(0 - utcOffset);
                }
                catch
                {
                }
            }

            return local;
        }
Example #10
0
        // Convert the passed datetime into client timezone.
        
        public static string ToClientTime(this DateTime dt)
        {
            var timeOffSet = HttpContext.Current.Session["timezoneoffset"];  // read the value from session

            if (timeOffSet != null)
            {
                var offset = int.Parse(timeOffSet.ToString());
                dt = dt.AddMinutes(-1 * offset);

                return dt.ToString();
            }

            // if there is no offset in session return the datetime in server timezone
            return dt.ToLocalTime().ToString();
        }
Example #11
0
 /// <summary>
 /// Adds a generic AddType to a DateTime object
 /// </summary>
 /// <param name="now"><seealso cref="System.DateTime"/></param>
 /// <param name="adder">Type structure that acts as a switcher for what type of add to perform</param>
 /// <param name="much">How much AddType to add to each element for creating list of data</param>
 /// <returns>A DateTime object with the added AddType amounts</returns>
 public static DateTime Add(this DateTime now, AddType adder, double much)
 {
     DateTime ret = now;
     switch (adder)
     {
         case AddType.Years:
             {
                 ret = now.AddYears((int)much);
                 break;
             }
         case AddType.Months:
             {
                 ret = now.AddMonths((int)much);
                 break;
             }
         case AddType.Days:
             {
                 ret = now.AddDays(much);
                 break;
             }
         case AddType.Hours:
             {
                 ret = now.AddHours(much);
                 break;
             }
         case AddType.Minutes:
             {
                 ret = now.AddMinutes(much);
                 break;
             }
         case AddType.Seconds:
             {
                 ret = now.AddSeconds(much);
                 break;
             }
         case AddType.Milliseconds:
             {
                 ret = now.AddMilliseconds(much);
                 break;
             }
         case AddType.Ticks:
             {
                 ret = now.AddTicks((long)much);
                 break;
             }
     }
     return ret;
 }
Example #12
0
        public static IEnumerable<DateTime> GetQuarterHourIncrementsAfter(this DateTime dateTime, bool wrap = true)
        {
            var quarterHours = new List<DateTime>(QuarterHoursInDay);
            for (int i = 1; i <= QuarterHoursInDay; i++)
            {
                var newDateTime = dateTime.AddMinutes(i * 15);
                if (!wrap && newDateTime.Date.CompareTo(dateTime.Date) > 0)
                {
                    break;
                }

                quarterHours.Add(newDateTime);
            }

            return quarterHours;
        }
Example #13
0
 public static DateTime SubstractTimeStepUnit(this DateTime dt, TimeStepUnit tstep)
 {
   switch (tstep)
   {
     case TimeStepUnit.Year:
       return dt.AddYears(-1);
     case TimeStepUnit.Month:
       return dt.AddMonths(-1);
     case TimeStepUnit.Day:
       return dt.AddDays(-1);
     case TimeStepUnit.Hour:
       return dt.AddHours(-1);
     case TimeStepUnit.Minute:
       return dt.AddMinutes(-1);
     case TimeStepUnit.Second:
       return dt.AddSeconds(-1);
   }
   return dt;
 }
        public static bool MatchesCronExpression(this DateTime theDateTime, string cronExpression)
        {
            CrontabSchedule schedule;
            ExceptionProvider ex;
            var valueOrException = CrontabSchedule.TryParse(cronExpression,
                input =>
                {
                    schedule = input;
                    return true;
                },
                exception =>
                {
                    ex = exception;
                    ex.Invoke();
                    return false;
                });
            

            var cronSchedule = CrontabSchedule.Parse(cronExpression);
            var nextOccurrence = cronSchedule.GetNextOccurrence(theDateTime.AddMinutes(-1).AddSeconds(-1 * theDateTime.Second));
            var matches = Math.Abs((theDateTime.AddSeconds(-1*theDateTime.Second) - nextOccurrence).TotalMinutes) < 1 ;
            return matches;
        }
Example #15
0
        public static DateTime NearestQuarterHour(this DateTime source)
        {
            var Mins = source.Minute;
            int Upper = 15;
            bool Found = false;

            while (!Found)
            {
                if (Mins < (Upper - 10))
                {
                    Mins = Upper - 15;
                    Found = true;
                }
                else if (Mins < Upper)
                {
                    Mins = Upper;
                    Found = true;
                }

                Upper = Upper + 15;
            }

            return source.AddMinutes((source.Minute * -1) + Mins);
        }
 /// <summary>
 /// Returns a DateTime a number of minutes in the future. 
 /// </summary>
 /// <param name="self">The DateTime to move</param>
 /// <param name="minutes">Number of minutes</param>
 public static DateTime MinutesSince(this DateTime self, double minutes)
 {
     return self.AddMinutes(minutes);
 }
 /// <summary>
 /// Returns a DateTime a number of minutes in the past
 /// </summary>
 /// <param name="self">The DateTime to move</param>
 /// <param name="minutes">Number of minutes</param>
 public static DateTime MinutesAgo(this DateTime self, double minutes)
 {
     return self.AddMinutes(-minutes);
 }
        public static string TimeDuration(this DateTime sourcedate, int duration)
        {
            var startTime = String.Empty;
            var endTime = String.Empty;
            if (sourcedate.Minute == 0)
            {
                startTime = sourcedate.ToString("hh tt");
                endTime = duration % 60 > 0 ? sourcedate.AddMinutes(duration).ToString("hh:mm tt") : sourcedate.AddMinutes(duration).ToString("hh tt");
            }
            else
            {
                startTime = sourcedate.ToString("hh:mm tt");
                endTime = sourcedate.AddMinutes(duration).ToString("hh:mm tt");
            }

            if (startTime.Equals(endTime))
                return startTime;

            return startTime + " - " + endTime;
        }
 /// <summary>
 /// Adds 30 minutes to the given DateTime.
 /// </summary>
 /// <param name="date">The given DateTime.</param>
 /// <returns>The DateTime after 30 minutes are added.</returns>
 public static DateTime AddHalfAnHour(this DateTime date)
 {
     return date.AddMinutes(30);
 }
 /// <summary>
 /// Subtracts given minutes from the given DateTime.
 /// </summary>
 /// <param name="date">The given DateTime.</param>
 /// <param name="minutes">Number of minutes to be subtracted.</param>
 /// <returns>The DateTime after the given minutes are subtracted.</returns>
 public static DateTime SubtractMinutes(this DateTime date, int minutes)
 {
     return date.AddMinutes(minutes.Negate());
 }
 /// <summary>
 /// Adds one minute to the given DateTime.
 /// </summary>
 /// <param name="date">The given DateTime.</param>
 /// <returns>The DateTime after one minute is added.</returns>
 public static DateTime AddAMinute(this DateTime date)
 {
     return date.AddMinutes(1);
 }
        public static DateTime SubtractMinutes(this DateTime date, double value) {
            if (value < 0)
                throw new ArgumentException("Value cannot be less than 0.", "value");

            return date.AddMinutes(value * -1);
        }
Example #23
0
        /// <summary>
        /// 获取下一个交易分钟
        /// </summary>
        /// <param name="self"></param>
        /// <returns></returns>
        public static DateTime ToNextTradingMinute(this DateTime self)
        {
            if (self.IsTradingDate() == false)
            {
                self = self.ToNextTradingDate();
                return self.AddHours(9).AddMinutes(31);
            }

            DateTime time = self.AddMinutes(1);
            TimeSpan span = time.TimeOfDay;
            if (span < new TimeSpan(9, 31, 0))
            {
                return time.Date.AddHours(9).AddMinutes(31);
            }
            else if (span > new TimeSpan(11, 30, 0)
                && span < new TimeSpan(13, 0, 0))
            {
                return time.Date.AddHours(13).AddMinutes(1);
            }
            else if (span > new TimeSpan(15, 0, 0))
            {
                return time.Date.AddDays(1).ToNextTradingMinute();
            }

            return time;
        }
 /// <summary>
 /// Rounds the second component to the nearest specified time. Defaults to 1 second
 /// </summary>
 /// <param name="source"></param>
 /// <param name="rounding"></param>
 /// <returns></returns>
 public static DateTime RoundSeconds(this DateTime source, SecondRounding rounding = SecondRounding.Second)
 {
     switch (rounding)
     {
         case SecondRounding.Second:
             if (source.Second >= 30)
                 return source.AddMinutes(1).TrimSeconds();
             return source.AddSeconds(-source.Second).AddMilliseconds(-source.Millisecond);
         case SecondRounding.HalfSecond:
             if (source.Second < 15)
                 return source.TrimSeconds();
             if (source.Second >= 15 && source.Minute < 45)
                 return source.TrimSeconds().AddSeconds(30);
             return source.AddMinutes(1).TrimSeconds();
         default:
             throw new ArgumentOutOfRangeException("rounding");
     }
 }
Example #25
0
 public static DateTime SubtractMinutes(this DateTime dateTime, long minutes)
 {
     return dateTime.AddMinutes(minutes * -1);
 }
 public static DateTime SubtractMinutes(this DateTime dateTime, double minutes)
 {
     return dateTime.AddMinutes(-minutes);
 }
Example #27
0
 public static DateTime TurnToMultiplesOf5(this DateTime value)
 {
     if (value.Second > 0)
         value = DateTime.Parse(value.ToString("yyyy/MM/dd HH:mm:00"));
     var mod = -value.Minute % 5;
     return mod == 0 ? value : value.AddMinutes(mod);
 }
Example #28
0
        /// <summary>
        /// Warning: bug found. dt.Offset may be incorrect as offsets could be different if range crosses daylight saving switch, i.e. October - December, or month of November in the EST USA.
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="count"></param>
        /// <param name="unit"></param>
        /// <returns></returns>
        public static DateTimeOffset Add(this DateTimeOffset dt, int count, TimeUnits unit)
        {
            switch(unit)
            {
                case TimeUnits.Century:
                    return dt.AddYears(count*100);
                case TimeUnits.Day:
                    return dt.AddDays(count);
                case TimeUnits.Decade:
                    return dt.AddYears(count*10);
                case TimeUnits.Hour:
                    return dt.AddHours(count);
                case TimeUnits.Minute:
                    return dt.AddMinutes(count);
                case TimeUnits.Month:
                    return dt.AddMonths(count);
                case TimeUnits.Quarter:
                    return dt.AddMonths(count*3);
                case TimeUnits.Second:
                    return dt.AddSeconds(count);
                case TimeUnits.Week:
                    return dt.AddDays(count*7);
                case TimeUnits.Year:
                    return dt.AddYears(count);
            }

            throw new Exception("Adding \"{0}\" is not implemented.".SmartFormat(unit));
        }
 internal static DateTime ClearMinutesAndSeconds(this DateTime current)
 {
     return current.AddMinutes(-1 * current.Minute)
         .AddSeconds(-1 * current.Second)
         .AddMilliseconds(-1 * current.Millisecond);
 }
        public static DateTime ChangeMinute(this DateTime date, int minute) {
            if (minute < 0 || minute > 59)
                throw new ArgumentException("Value must be between 0 and 59.", "minute");

            return date.AddMinutes(minute - date.Minute);
        }