C# this.AddTicks方法代码示例

		public static void ShouldMatch(this DateTime actual, DateTime expected)
		{
			actual = actual.AddTicks(-(actual.Ticks % TimeSpan.TicksPerMillisecond));
			expected = expected.AddTicks(-(expected.Ticks % TimeSpan.TicksPerMillisecond));

			ShouldBeTestExtensions.ShouldBe(actual, expected);
		}

		public static DateTime TruncateTo(this DateTime dateTime, TimeSpan timeSpan)
		{

			if (timeSpan == TimeSpan.Zero) return dateTime; 

			return dateTime.AddTicks(-(dateTime.Ticks % timeSpan.Ticks));
		}

        public static DateTime Truncate(this DateTime dateTime, TimeSpan timeSpan)
        {
            if (timeSpan == TimeSpan.Zero)
                return dateTime;

            return DateTime.SpecifyKind(dateTime.AddTicks(-(dateTime.Ticks % timeSpan.Ticks)), dateTime.Kind);
        }

 /// <summary>
 /// Extension method to round a datetime down by a timespan interval.
 /// </summary>
 /// <param name="dateTime">Base DateTime object we're rounding down.</param>
 /// <param name="interval">Timespan interval to round to.</param>
 /// <returns>Rounded datetime</returns>
 public static DateTime RoundDown(this DateTime dateTime, TimeSpan interval)
 {
     if (interval == TimeSpan.Zero)
     {
         // divide by zero exception
         return dateTime;
     }
     return dateTime.AddTicks(-(dateTime.Ticks % interval.Ticks));
 }

 /// <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;
 }

        /// <summary>
        /// Returns a new DateTime that adds the specified number of microseconds to the value of this instance.
        /// </summary>
        /// <param name="dateTime">The DateTime to add microseconds to.</param>
        /// <param name="value">A number of whole and fractional microseconds. The value parameter can be negative or positive. Note that this value is rounded to the nearest integer.</param>
        /// <returns>An object whose value is the sum of the date and time represented by this instance and the number of microseconds represented by value.</returns>
        public static DateTime AddMicroseconds(this DateTime dateTime, double value)
        {
            const long MaxValue = long.MaxValue / TimeSpanExtensions.TicksPerMicrosecond;
            if (value > MaxValue)
            {
                throw new ArgumentOutOfRangeException("value", value,
                                                      string.Format(CultureInfo.InvariantCulture, "Value cannot be bigger than {0}", MaxValue));
            }

            const long MinValue = long.MinValue / TimeSpanExtensions.TicksPerMicrosecond;
            if (value < MinValue)
            {
                throw new ArgumentOutOfRangeException("value", value,
                                                      string.Format(CultureInfo.InvariantCulture, "Value cannot be smaller than {0}", MinValue));
            }

            long roundedValue = (long)Math.Round(value);
            long ticks = roundedValue * TimeSpanExtensions.TicksPerMicrosecond;
            return dateTime.AddTicks(ticks);
        }

        public static DateTime SubtractTicks(this DateTime date, long value) {
            if (value < 0)
                throw new ArgumentException("Value cannot be less than 0.", "value");

            return date.AddTicks(value * -1);
        }

 internal static DateTime AddMicroseconds(this DateTime self, int microseconds)
 {
     return self.AddTicks(microseconds * ticksPerMicrosecond);
 }

 /// <summary>
 /// Retrieves the yesterday date.
 /// </summary>
 /// <param name="today">The today.</param>
 /// <returns>yesterday date</returns>
 public static DateTime RetrieveYesterdayDate(this DateTime today)
 {
     DateTime yesterdayDate = today.AddTicks(-1);
     return yesterdayDate;
 }

 /// <summary>
 /// Round the given DateTime object by the given time interval. i.e. 10:09 rounded by 10 minutes would be 10:10
 /// </summary>
 /// <param name="dt">The given DateTime object</param>
 /// <param name="interval">The time interval to round by</param>
 /// <returns>The new rounded DateTime object</returns>
 public static DateTime Round(this DateTime dt, TimeSpan interval)
 {
     var halfIntervalTicks = ((interval.Ticks + 1) >> 1);
       return dt.AddTicks(halfIntervalTicks - ((dt.Ticks + halfIntervalTicks) % interval.Ticks));
 }

 /// <summary>
 /// Floor the given DateTime object by the given time interval. i.e. 10:09 floored by 10 minutes would be 10:00
 /// </summary>
 /// <param name="dt">The given DateTime object</param>
 /// <param name="interval">The time interval to floor by</param>
 /// <returns>The new floored DateTime object</returns>
 public static DateTime Floor(this DateTime dt, TimeSpan interval)
 {
     return dt.AddTicks(-(dt.Ticks % interval.Ticks));
 }

		public static DateTime TruncSeconds(this DateTime dateTime)
		{
			return dateTime.AddTicks(-dateTime.Ticks % 600000000);
		}

        public static DateTimeOffset TruncateMilliseconds(this DateTimeOffset dto)
        {
            // From http://stackoverflow.com/a/1005222/335418

            return dto.AddTicks( - (dto.Ticks % TimeSpan.TicksPerSecond));
        }

 public static string ToSaml2DateTimeString(this DateTime dateTime)
 {
     return XmlConvert.ToString(dateTime.AddTicks(-(dateTime.Ticks % TimeSpan.TicksPerSecond)),
         XmlDateTimeSerializationMode.Utc);
 }

 public static DateTime SubtractTicks(this DateTime dateTime, long ticks)
 {
     return dateTime.AddTicks(-ticks);
 }