/// <summary> A DateTime extension method that rounds DateTimes to the nearest second. </summary>
        /// <remarks> 7/19/2011. </remarks>
        /// <param name="value">  Original DateTime value. </param>
        /// <returns> A new DateTime value rounded and truncated to the nearest second. </returns>
        public static DateTime RoundToNearestSecond(this DateTime value)
        {
            if (value.Millisecond >= 500)
            //account for tiny discrepancies with ms and ticks
            value = value.AddMilliseconds(502);

              return TruncateToSecond(value);
        }
	    public static DateTime RemoveMilliseconds(this DateTime dateTime)
	    {
	        if (dateTime.Millisecond > 0)
	        {
	            dateTime = dateTime.AddSeconds(1);
	            dateTime = dateTime.AddMilliseconds(-dateTime.Millisecond);
	        }

	        return dateTime;
	    }
Exemple #3
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;
 }
        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 SubtractMilliseconds(this DateTime date, double value) {
            if (value < 0)
                throw new ArgumentException("Value cannot be less than 0.", "value");

            return date.AddMilliseconds(value * -1);
        }
        public static DateTime ChangeMillisecond(this DateTime date, int millisecond) {
            if (millisecond < 0 || millisecond > 59)
                throw new ArgumentException("Value must be between 0 and 999.", "millisecond");

            return date.AddMilliseconds(millisecond - date.Millisecond);
        }
Exemple #7
0
 public static DateTime Round(this DateTime dateTime, Int32 milliseconds)
 {
     var tail = dateTime.Subtract(DateTime.MinValue).TotalMilliseconds % milliseconds;
     return dateTime.AddMilliseconds(tail / milliseconds >= 0.5 ? milliseconds - tail : -tail);
 }
 public static DateTime DiscardMilliseconds(this DateTime time)
 {
     return time.AddMilliseconds(-time.Millisecond);
 }
 public static DateTime TrimMilliseconds (this DateTime date)
 {
     return date.AddMilliseconds (-date.Millisecond);
 }
Exemple #10
0
 public static DateTime addTimeUnits(this DateTime date, TimeframeSymbol timeframe, int units)
 {
     if (units == 0) return date.AddMilliseconds(0);
     return Timeframe.addTimeUnits(date, timeframe, units);
 }
 public static DateTime RoundTo5Minutes(this DateTime dt)
 {
     return dt.AddMilliseconds(-dt.Millisecond).AddSeconds(-dt.Second).AddMinutes(-(dt.Minute%5));
 }
Exemple #12
0
 public static DateTime WaveMilliSeconds(this DateTime value)
 {
     return value.AddMilliseconds(-(value.Millisecond));
 }
Exemple #13
0
        ///////////////////////////////////////////////////////////////////////
        public static DateTime SetMillisecond(this DateTime dt, int msec)
        {
            if ((msec < 0) || (msec > 999)) {
                throw new ArgumentOutOfRangeException("msec");
            }

            int diff = msec - dt.Millisecond;
            return dt.AddMilliseconds(diff);
        }
 /// <summary>
 /// Return the date with milliseconds stripped
 /// </summary>
 public static DateTime StripMilliseconds(this DateTime @this)
 {
     return @this.AddMilliseconds([email protected]);
 }
Exemple #15
0
 public static DateTime StripMilliseconds(this DateTime dateTime)
 {
     return dateTime.AddMilliseconds(-dateTime.Millisecond).AddTicks(-dateTime.Ticks);
 }
 public static DateTime SubtractMilliseconds(this DateTime dateTime, double milliseconds)
 {
     return dateTime.AddMilliseconds(-milliseconds);
 }
 /// <summary>
 /// Subtracts given milliseconds from the given DateTime.
 /// </summary>
 /// <param name="date">The given DateTime.</param>
 /// <param name="milliSeconds">Number of milliseconds to be subtracted.</param>
 /// <returns>The DateTime after the given milliseconds are subtracted.</returns>
 public static DateTime SubtractMilliSeconds(this DateTime date, int milliSeconds)
 {
     return date.AddMilliseconds(milliSeconds.Negate());
 }
 public static DateTimeOffset SubtractMilliseconds(this DateTimeOffset dateTimeOffset, double milliseconds)
 {
     return dateTimeOffset.AddMilliseconds(-milliseconds);
 }