// -------------------------------------------------------------------------------- public static DateTimeOffset Round(this DateTimeOffset dto, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: { dto = dto.AddTicks(5000); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, dto.Millisecond, dto.Offset)); } case DateTimeFieldEnum.SECOND: { dto = dto.AddMilliseconds(500); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, 0, dto.Offset)); } case DateTimeFieldEnum.MINUTE: { dto = dto.AddSeconds(30); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, 0, 0, dto.Offset)); } case DateTimeFieldEnum.HOUR: { dto = dto.AddMinutes(30); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, 0, 0, 0, dto.Offset)); } case DateTimeFieldEnum.DAY: case DateTimeFieldEnum.DATE: { dto = dto.Add(TimeSpan.FromSeconds(43200)); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, 0, 0, 0, 0, dto.Offset)); } case DateTimeFieldEnum.MONTH: { var stMonth = dto.Month; var stYear = dto.Year; var stDate = new DateTimeOffset(stYear, stMonth, 1, 0, 0, 0, 0, dto.Offset); var edMonth = stMonth == 12 ? 1 : stMonth + 1; var edYear = stMonth == 12 ? stYear + 1 : stYear; var edDate = new DateTimeOffset(edYear, edMonth, 1, 0, 0, 0, 0, dto.Offset); var ticksInHalfMonth = (edDate.Ticks - stDate.Ticks) / 2; dto = dto.AddTicks(ticksInHalfMonth); return(new DateTimeOffset(dto.Year, dto.Month, 1, 0, 0, 0, 0, dto.Offset)); } case DateTimeFieldEnum.YEAR: { var stYear = dto.Year; var stDate = new DateTimeOffset(stYear, 1, 1, 0, 0, 0, 0, dto.Offset); var edDate = new DateTimeOffset(stYear + 1, 1, 1, 0, 0, 0, 0, dto.Offset); var ticksInHalfYear = (edDate.Ticks - stDate.Ticks) / 2; dto = dto.AddTicks(ticksInHalfYear); return(new DateTimeOffset(dto.Year, 1, 1, 0, 0, 0, 0, dto.Offset)); } default: throw new NotSupportedException(); } }
/// <summary> /// Rounds the given datetime by a given timespan. /// </summary> /// <param name="dateTime">The datetime to round.</param> /// <param name="roundBy">The time span to round by.</param> /// <returns>The rounded time.</returns> public static DateTimeOffset Round(this DateTimeOffset dateTime, TimeSpan roundBy) { long remainderTicks = dateTime.Ticks % roundBy.Ticks; if (remainderTicks < roundBy.Ticks / 2) { // round down return(dateTime.AddTicks(-remainderTicks)); } // round up return(dateTime.AddTicks(roundBy.Ticks - remainderTicks)); }
/// <summary> /// Sets the time to the previous factor of <see cref="timeSpan"/>. /// </summary> /// <param name="value"></param> /// <param name="timeSpan"></param> /// <param name="roundUp"></param> /// <returns></returns> private static DateTimeOffset DoRound(this DateTimeOffset value, TimeSpan timeSpan, bool?roundUp) { if (timeSpan.Ticks == 0) { return(value); } var(previous, next) = value.GetDeltaTicks(timeSpan); return(roundUp ?? (next <= previous) ? (next == 0 ? value : value.AddTicks(next)) : (previous == 0 ? value : value.AddTicks(-previous))); }
public void Compare_Test2() { var dt0 = new DateTimeOffset(1582, 10, 15, 0, 0, 0, TimeSpan.Zero); var arr = new [] { TimeUuid.NewId(dt0.AddTicks(0x00000000007fffL)), TimeUuid.NewId(dt0.AddTicks(0x00ff0000000000L)), TimeUuid.NewId(dt0.AddTicks(0x07ff0000000000L)), TimeUuid.NewId(dt0.AddTicks(0x07ff0000ff0000L)) }; var actual = (TimeUuid[])arr.Clone(); Array.Sort(actual); CollectionAssert.AreEqual(arr, actual); }
public void MergeTwoStreams_7() { var result = new List <string>(); var errors = new List <Exception>(); var start = new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.Zero); using (var waitHandle = new ManualResetEvent(false)) using (var intSubject = new Subject <Timestamped <int> >()) using (var stringSubject = new Subject <Timestamped <string> >()) using (var playback = new Playback()) { ((IPlaybackConfiguration)playback).AddInput( () => stringSubject, new ITypeMap <Timestamped <string> >[] { new TimestampedTypeMap <string>() }); ((IPlaybackConfiguration)playback).AddInput( () => intSubject, new ITypeMap <Timestamped <int> >[] { new TimestampedTypeMap <int>() }); using (playback.GetObservable <string>() .Merge(playback.GetObservable <int>().Select(i => i.ToString()), playback.Scheduler) .Subscribe( Observer.Create <string>( result.Add, errors.Add, () => waitHandle.Set()))) { playback.Start(); stringSubject.OnNext(new Timestamped <string>("1", start)); intSubject.OnNext(new Timestamped <int>(2, start.AddTicks(1))); stringSubject.OnNext(new Timestamped <string>("3", start.AddTicks(2))); intSubject.OnNext(new Timestamped <int>(4, start.AddTicks(3))); stringSubject.OnCompleted(); intSubject.OnCompleted(); var notTimeouted = waitHandle.WaitOne(TimeSpan.FromSeconds(1)); Assert.IsTrue(notTimeouted); } } Assert.AreEqual(0, errors.Count); Assert.AreEqual(4, result.Count); Assert.AreEqual("1", result[0]); Assert.AreEqual("2", result[1]); Assert.AreEqual("3", result[2]); Assert.AreEqual("4", result[3]); }
public static DateTimeOffset TruncateTo(this DateTimeOffset dateTimeOffset, TimeSpan span, DateTimeOffset?epoch = null) { var diff = dateTimeOffset - (epoch ?? DefaultDateTimeOffsetEpoch); var excess = diff.Ticks % span.Ticks; return(excess == 0 ? dateTimeOffset : dateTimeOffset.AddTicks(-excess)); }
public async Task ExpiresOnlyCorrectEntities(int entitiesToAdd, int entitiesToExpire) { for (int i = 0; i < entitiesToAdd; i++) { MockTokenGenerator .Setup(generator => generator.Next) .Returns(i.ToString()); DateTimeOffset entityStoreTime = TestTime.AddTicks(i); MockTime .Setup(time => time.Current) .Returns(entityStoreTime); TestObject.Store(TestEntity); } DateTimeOffset expirationTime = TestTime .AddMinutes(TestExpiration) .AddTicks(entitiesToExpire); MockTime .Setup(time => time.Current) .Returns(expirationTime); await Task.Delay(TimeToWaitForSleepInMs); Assert.AreEqual(entitiesToAdd - entitiesToExpire, TestObject.Count); }
/// <summary> /// Converts the value of the current <see cref="PartialDateTime"/> object to a <see cref="DateTimeOffset"/> value. /// </summary> /// <param name="defaultMonth">The value to use if month component missing.</param> /// <param name="defaultDaySelector">A selector to get the value to use if day component is missing.</param> /// <param name="defaultHour">The value to use if hour component is missing.</param> /// <param name="defaultMinute">The value to use if minute component is missing.</param> /// <param name="defaultSecond">The value to use if second component is missing.</param> /// <param name="defaultFraction">The value to use if fraction component is missing.</param> /// <param name="defaultUtcOffset">The value to use if UTC offset component is missing.</param> /// <returns>An object that represents the date and time of the current <see cref="PartialDateTime"/> object.</returns> public DateTimeOffset ToDateTimeOffset( int defaultMonth, DaySelector defaultDaySelector, int defaultHour, int defaultMinute, int defaultSecond, decimal defaultFraction, TimeSpan defaultUtcOffset) { int month = Month ?? defaultMonth; var offset = new DateTimeOffset( Year, month, Day ?? defaultDaySelector(Year, month), Hour ?? defaultHour, Minute ?? defaultMinute, Second ?? defaultSecond, UtcOffset ?? defaultUtcOffset); // Add second, millisecond, and fraction. decimal fraction = Fraction ?? defaultFraction; offset = offset.AddTicks((long)(fraction * TimeSpan.TicksPerSecond)); return(offset); }
private static void Dump(TimeZoneInfo zone, Options options, TextWriter writer) { writer.Write($"{zone.Id}\n"); // This will be a bit odd using Windows time zones, as most have permanent // daylight saving rules... but for tz data, it should be okay. var initial = new DateTimeOffset(2, 1, 1, 0, 0, 0, 0, TimeSpan.Zero); var initialOffset = zone.GetUtcOffset(initial); var initialDaylight = zone.IsDaylightSavingTime(initial); writer.Write("Initially: {0} {1} {2}\n", (initialOffset.Ticks >= 0 ? "+" : "-") + initialOffset.ToString("hh':'mm':'ss", CultureInfo.InvariantCulture), initialDaylight ? "daylight" : "standard", initialDaylight ? zone.DaylightName : zone.StandardName); int fromYear = options.FromYear ?? 1800; DateTimeOffset start = new DateTimeOffset(fromYear, 1, 1, 0, 0, 0, TimeSpan.Zero); DateTimeOffset end = new DateTimeOffset(options.ToYear, 1, 1, 0, 0, 0, TimeSpan.Zero); DateTimeOffset? transition = GetNextTransition(zone, start.AddTicks(-1), end); while (transition != null) { var offset = zone.GetUtcOffset(transition.Value); var isDaylight = zone.IsDaylightSavingTime(transition.Value); // It's unfortunate that TimeZoneInfo doesn't support the idea of different names // for different periods in history. Never mind - this is better than nothing, // for diagnostic purposes. writer.Write("{0} {1} {2} {3}\n", transition.Value.ToString("yyyy-MM-dd HH:mm:ss'Z'", CultureInfo.InvariantCulture), (offset.Ticks >= 0 ? "+" : "-") + offset.ToString("hh':'mm':'ss", CultureInfo.InvariantCulture), isDaylight ? "daylight" : "standard", isDaylight ? zone.DaylightName : zone.StandardName); transition = GetNextTransition(zone, transition.Value, end); } writer.Write("\n"); }
public void TimeAddNanoseconds() { DateTimeOffset offset = stored.AddTicks(-1); #if !EFOLD var q = this.Entities .Where(x => DbFunctions.AddNanoseconds(x.Offset, -100) == offset); #else var q = this.Entities .Where(x => EntityFunctions.AddNanoseconds(x.Offset, -100) == offset); #endif q.Should().NotBeEmpty(); }
internal static DateTimeOffset AdjustPrecision(DateTimeOffset value, byte precision) { if (precision > 6) { return(value); } var delta = value.Ticks % 10000000; switch (precision) { case 1: delta %= 1000000; break; case 2: delta %= 100000; break; case 3: delta %= 10000; break; case 4: delta %= 1000; break; case 5: delta %= 100; break; case 6: delta %= 10; break; } return(delta != 0 ? value.AddTicks(-delta) : value); }
/// <summary> /// Parse the given string representation into a <see cref="DateTimeOffset"/> value. /// </summary> /// <param name="value">A string representation of a date time.</param> /// <returns>A <see cref="DateTimeOffset"/> value.</returns> public DateTimeOffset ParseDateTimeOffset(string value) { int year, month, day, hour, minute, second, offsetHours, offsetMinutes; long ticks; DateTimeKind dateTimeKind; GetDateTimeComponents(value, out year, out month, out day, out hour, out minute, out second, out ticks, out offsetHours, out offsetMinutes, out dateTimeKind); TimeSpan utcOffset; switch (dateTimeKind) { case DateTimeKind.Unspecified: utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now); break; case DateTimeKind.Utc: case DateTimeKind.Local: utcOffset = new TimeSpan(offsetHours, offsetMinutes, 0); break; default: throw new ArgumentOutOfRangeException(); } var dateTimeOffset = new DateTimeOffset(year, month, day, hour, minute, second, utcOffset); dateTimeOffset = dateTimeOffset.AddTicks(ticks); return(dateTimeOffset); }
public static CappedLogMessage ToLogMessage(this string message, DateTimeOffset now) { var diff = now.Ticks % TimeSpan.TicksPerMillisecond; var off = Interlocked.Increment(ref _prevTime) % TimeSpan.TicksPerMillisecond; return(new CappedLogMessage(now.AddTicks(off - diff), message)); }
public void GivenAPartialDateTimeWithMissingComponents_WhenToDateTimeOffsetIsCalled_ThenCorrectDateTimeOffsetIsReturned() { const int expectedMonth = 2; const int expectedDay = 10; const int expectedHour = 15; const int expectedMinute = 13; const int expectedSecond = 12; const decimal expectedFraction = 0.3009953m; var expectedUtcOffset = TimeSpan.FromMinutes(30); var dateTime = PartialDateTime.Parse("2013"); var actualOffset = dateTime.ToDateTimeOffset( expectedMonth, (year, month) => expectedDay, expectedHour, expectedMinute, expectedSecond, expectedFraction, expectedUtcOffset); var expectedOffset = new DateTimeOffset( 2013, expectedMonth, expectedDay, expectedHour, expectedMinute, expectedSecond, expectedUtcOffset); expectedOffset = expectedOffset.AddTicks((long)(expectedFraction * TimeSpan.TicksPerSecond)); Assert.Equal(expectedOffset, actualOffset); }
public void GivenAPartialDateTimeWithNoMissingComponent_WhenToDateTimeOffsetIsCalled_ThenCorrectDateTimeOffsetIsReturned() { var dateTime = PartialDateTime.Parse("2013-10-12T23:01:35.9995555+02:00"); var actualOffset = dateTime.ToDateTimeOffset( 2, (year, month) => 10, 15, 13, 12, 0.300250m, TimeSpan.FromMinutes(30)); var expectedOffset = new DateTimeOffset( 2013, 10, 12, 23, 01, 35, TimeSpan.FromMinutes(120)); expectedOffset = expectedOffset.AddTicks((long)(0.9995555m * TimeSpan.TicksPerSecond)); Assert.Equal(expectedOffset, actualOffset); }
public async Task LowerDigitsAreIgnoredAsync() { if (!Dialect.SupportsDateTimeScale) { Assert.Ignore("Lower digits cannot be ignored when dialect does not support scale"); } var baseDate = new DateTimeOffset(2017, 10, 01, 17, 55, 24, 548, TimeSpan.FromHours(2)); var entity = new DateTimeOffsetClass { Id = AdditionalDateId, Value = baseDate.AddTicks(TimeSpan.TicksPerMillisecond / 3) }; Assert.That(entity.Value, Is.Not.EqualTo(baseDate)); using (var s = OpenSession()) using (var t = s.BeginTransaction()) { await(s.SaveAsync(entity)); await(t.CommitAsync()); } using (var s = OpenSession()) using (var t = s.BeginTransaction()) { var retrieved = await(s.LoadAsync <DateTimeOffsetClass>(AdditionalDateId)); Assert.That(retrieved.Value, Is.EqualTo(baseDate)); await(t.CommitAsync()); } }
public void GivenAPartialDateTimeWithNoMissingComponent_WhenToDateTimeOffsetIsCalled_ThenCorrectDateTimeOffsetIsReturned() { PartialDateTime dateTime = _builder.ToPartialDateTime(); DateTimeOffset actualOffset = dateTime.ToDateTimeOffset( 2, (year, month) => 10, 15, 13, 12, 0.300250m, TimeSpan.FromMinutes(30)); DateTimeOffset expectedOffset = new DateTimeOffset( DefaultYear, DefaultMonth, DefaultDay, DefaultHour, DefaultMinute, DefaultSecond, DefaultUtcOffset); expectedOffset = expectedOffset.AddTicks((long)(DefaultFraction * TimeSpan.TicksPerSecond)); Assert.Equal(expectedOffset, actualOffset); }
// -------------------------------------------------------------------------------- public static DateTimeOffset Ceiling(this DateTimeOffset dto, DateTimeFieldEnum field) { switch (field) { case DateTimeFieldEnum.MILLISEC: { dto = dto.AddTicks(9999); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, dto.Millisecond, dto.Offset)); } case DateTimeFieldEnum.SECOND: { dto = dto.AddMilliseconds(999); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, 0, dto.Offset)); } case DateTimeFieldEnum.MINUTE: { dto = dto.AddSeconds(59); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, 0, 0, dto.Offset)); } case DateTimeFieldEnum.HOUR: { dto = dto.AddMinutes(59); return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, 0, 0, 0, dto.Offset)); } case DateTimeFieldEnum.DAY: case DateTimeFieldEnum.DATE: { var baseDto = new DateTimeOffset(dto.Year, dto.Month, dto.Day, 0, 0, 0, 0, dto.Offset); if (baseDto == dto) { return(baseDto); } return(baseDto.AddDays(1)); } case DateTimeFieldEnum.MONTH: { var baseDto = new DateTimeOffset(dto.Year, dto.Month, 1, 0, 0, 0, 0, dto.Offset); if (baseDto == dto) { return(baseDto); } return(baseDto.AddMonths(1)); } case DateTimeFieldEnum.YEAR: { var baseDto = new DateTimeOffset(dto.Year, 1, 1, 0, 0, 0, 0, dto.Offset); if (baseDto == dto) { return(baseDto); } return(baseDto.AddYears(1)); } default: throw new NotSupportedException(); } }
private static DateTimeOffset CeilingCore(DateTimeOffset dateTime, [NonNegativeValue] long ticksModule) { Code.InRange(ticksModule, nameof(ticksModule), 1, long.MaxValue); var overflow = dateTime.Ticks % ticksModule; return(overflow == 0 ? dateTime : dateTime.AddTicks(ticksModule - overflow)); }
public static DateTimeOffset Truncate(this DateTimeOffset dateTime, TimeSpan timeSpan) { if (timeSpan == TimeSpan.Zero) { return(dateTime); } return(dateTime.AddTicks(-(dateTime.Ticks % timeSpan.Ticks))); }
private static DateTimeOffset FloorCore(DateTimeOffset dateTime, long ticksModule) { Code.InRange(ticksModule, nameof(ticksModule), 1, long.MaxValue); var overflow = dateTime.Ticks % ticksModule; return(dateTime.AddTicks(-overflow)); }
/// <summary> /// Round this <see cref="DateTimeOffset"/> to the specified <see cref="TimeSpan"/> precision. /// </summary> /// <param name="DateTimeOffset"></param> /// <param name="precision"></param> /// <returns></returns> public static DateTimeOffset Round(this DateTimeOffset DateTimeOffset, TimeSpan precision) { var delta = DateTimeOffset.Ticks % precision.Ticks; var shouldRoundUp = delta > (precision.Ticks / 2L); var offset = shouldRoundUp ? precision.Ticks : 0L; return(DateTimeOffset.AddTicks(offset - delta)); }
public static bool WithinSkew(DateTimeOffset now, DateTimeOffset ctime, int usec, TimeSpan skew) { ctime = ctime.AddTicks(usec / 10); var skewed = TimeSpan.FromMilliseconds(Math.Abs((now - ctime).TotalMilliseconds)); return(skewed <= skew); }
public static DateTimeOffset Timestamp(long elapsedTicks) { // Stopwatch ticks are different from DateTime.Ticks. // Each tick in the DateTime.Ticks value represents one 100-nanosecond interval. // Each tick in the ElapsedTicks value represents the time interval equal to // 1 second divided by the Frequency. return(StartTime.AddTicks(Convert.ToInt64(elapsedTicks * HundredNanosecondsPerTick))); }
public DateTimeOffset DurationForPlayer(string playerId, IList <POPpicGameMove> gameMoves) { DateTimeOffset duration = DateTimeOffset.MinValue; var ticks = gameMoves.Where((POPpicGameMove m) => m.UserId == playerId).Sum((POPpicGameMove m) => m.MoveDuration.Ticks); duration.AddTicks(ticks); return(duration); }
public static DateTimeOffset Truncate(this DateTimeOffset dateTime, TimeSpan timeSpanTruncation) { if (dateTime == DateTimeOffset.MinValue || dateTime == DateTimeOffset.MaxValue) { return(dateTime); // do not modify guard values } return(dateTime.AddTicks(-(dateTime.Ticks % timeSpanTruncation.Ticks))); }
/// <summary> /// Fakes the current time to the time specified, making slight increments in time for each invocation /// (the slight increments can be turned off by setting <paramref name="incrementSlightlyOnEachInvocation"/> to false) /// </summary> public static void FakeIt(DateTimeOffset fakeTime, bool incrementSlightlyOnEachInvocation = true) { RebusTime.CurrentTimeFactory = () => { var timeToReturn = fakeTime; fakeTime = fakeTime.AddTicks(1); return timeToReturn; }; }
private static DateTimeOffset RoundAwayFromZeroCore(DateTimeOffset dateTime, [NonNegativeValue] long ticksModule) { Code.InRange(ticksModule, nameof(ticksModule), 1, long.MaxValue); var halfIntervalTicks = (ticksModule + 1) >> 1; var halfIntervalOverflow = (dateTime.Ticks + halfIntervalTicks) % ticksModule; return(dateTime.AddTicks(halfIntervalTicks - halfIntervalOverflow)); }
private static DateTimeOffset Truncate(DateTimeOffset dateTime) { if (dateTime == DateTimeOffset.MinValue || dateTime == DateTimeOffset.MaxValue) { return(dateTime); } return(dateTime.AddTicks(-(dateTime.Ticks % TimeSpan.FromSeconds(1).Ticks))); }
public static DateTimeOffset EndOfDay(this DateTimeOffset date) { var endOfDay = new DateTimeOffset(date.Year, date.Month, date.Day, 0, 0, 0, date.Offset); endOfDay = endOfDay.AddDays(1); endOfDay = endOfDay.AddTicks(-1); return(endOfDay); }
public void CorrectConversionTest(DateTimeOffset date, string timezone) { // Truncate milliseconds since we don't use them for the UNIX timestamps. var dateTimeOffset = date.AddTicks(-(date.Ticks % TimeSpan.TicksPerSecond)); var convertedDate = dateTimeOffset.ToUnixTimeSeconds().ToDateTimeOffsetFromUnixTimestamp(timezone); Assert.Equal(dateTimeOffset, convertedDate); }
public static DateTimeOffset SubtractTicks(this DateTimeOffset date, long value) { if (value < 0) { throw new ArgumentException("Value cannot be less than 0.", "value"); } return(date.AddTicks(value * -1)); }
public override object ConvertToStorageType(object value) { if (value != null) { var dateTime = new DateTimeOffset(new DateTime(1753, 1, 1)); if (dateTime > (DateTimeOffset)value) { var time = ((DateTimeOffset)value).TimeOfDay; DateTimeOffset storageType = dateTime.AddTicks(time.Ticks); return storageType.DateTime; } dateTime = new DateTimeOffset(new DateTime(9999, 12, 31)); return dateTime < (DateTimeOffset)value ? dateTime.DateTime : ((DateTimeOffset)value).DateTime; } return null; }
public void From_FromFixedDateTime_Tests(int value) { var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero); Assert.AreEqual(value.Years().From(originalPointInTime), originalPointInTime.AddYears(value)); Assert.AreEqual(value.Months().From(originalPointInTime), originalPointInTime.AddMonths(value)); Assert.AreEqual(value.Weeks().From(originalPointInTime), originalPointInTime.AddDays(value*DaysPerWeek)); Assert.AreEqual(value.Days().From(originalPointInTime), originalPointInTime.AddDays(value)); Assert.AreEqual(value.Hours().From(originalPointInTime), originalPointInTime.AddHours(value)); Assert.AreEqual(value.Minutes().From(originalPointInTime), originalPointInTime.AddMinutes(value)); Assert.AreEqual(value.Seconds().From(originalPointInTime), originalPointInTime.AddSeconds(value)); Assert.AreEqual(value.Milliseconds().From(originalPointInTime), originalPointInTime.AddMilliseconds(value)); Assert.AreEqual(value.Ticks().From(originalPointInTime), originalPointInTime.AddTicks(value)); }
/// <summary> /// Parse the given string representation into a <see cref="DateTimeOffset"/> value. /// </summary> /// <param name="value">A string representation of a date time.</param> /// <returns>A <see cref="DateTimeOffset"/> value.</returns> public DateTimeOffset ParseDateTimeOffset(string value) { int year, month, day, hour, minute, second, offsetHours, offsetMinutes; long ticks; DateTimeKind dateTimeKind; GetDateTimeComponents(value, out year, out month, out day, out hour, out minute, out second, out ticks, out offsetHours, out offsetMinutes, out dateTimeKind); var offset = new TimeSpan(offsetHours, offsetMinutes, 0); var dateTimeOffset = new DateTimeOffset(year, month, day, hour, minute, second, offset); dateTimeOffset = dateTimeOffset.AddTicks(ticks); return dateTimeOffset; }
//// BUTTONCLICK HANDLERS /////////////////////////////////////////////// public DialogResult OKButton_Click(object sender, EventArgs e) { DialogResult dr = DialogResult.Cancel; if (ap.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AcquireParametersMap().Add(sel, ap); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(ap, det.ListMode); } // The acquire is set to occur, build up the measurement state AnalysisWizard.ResetMeasurement(); Integ.BuildMeasurement(ap, det, mo); switch (ap.data_src) { case ConstructedSource.Live: // set up the instrument list for the action controller UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (det.ListMode) { // patch override lm.Interval with run_count_time from dialog NC.App.Opstate.Measurement.AcquireState.lm.Interval = NC.App.Opstate.Measurement.AcquireState.run_count_time; // Check NC.App.Opstate.Measurement.AnalysisParams for at least one VSR // If not present, inform and pop up the wizard // If present, inform with new dialog, do not pop up the wizard if (NC.App.Opstate.Measurement.AnalysisParams.HasMultiplicity()) { dr = DialogResult.OK; } else { AnalysisWizard awl = new AnalysisWizard(AnalysisWizard.AWSteps.Step2B, ap, det); // analyzers are created in here, placed on global measurement dr = awl.ShowDialog(); if (dr == DialogResult.OK) { NC.App.DB.UpdateAcquireParams(ap); //update it again NC.App.DB.UpdateDetector(det); } } if (dr == DialogResult.OK) { // if ok, the analyzers are set up, so can kick it off now. UIIntegration.Controller.ActivateDetector(det); } } else { SRInstrument sri = new SRInstrument(det); sri.selected = true; sri.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri)) Instruments.All.Add(sri); // add to global runtime list dr = DialogResult.OK; } break; case ConstructedSource.DB: NC.App.AppContext.DBDataAssay = true; UIIntegration.Controller.file = true; IDDAcquireDBMeas dbdlg = new IDDAcquireDBMeas(this); if (dbdlg.HasItems()) { dr = dbdlg.ShowDialog(); if (dr == DialogResult.OK) { DateTimeOffset dto = dbdlg.measurementId.MeasDateTime; DateTimeOffset cur = new DateTimeOffset(dto.Ticks, dto.Offset); NC.App.Logger(NCCReporter.LMLoggers.AppSection.App).TraceEvent(NCCReporter.LogLevels.Info, 87654, "Using " + dto.ToString("MMM dd yyy HH:mm:ss.ff K")); // get the cycles for the selected measurement from the database, and add them to the current measurement CycleList cl = NC.App.DB.GetCycles(det, dbdlg.measurementId); foreach(Cycle cycle in cl) // add the necessary meta-data to the cycle identifier instance { cycle.UpdateDataSourceId(ap.data_src, det.Id.SRType, cur.AddTicks(cycle.TS.Ticks), det.Id.FileName); cur = cycle.DataSourceId.dt; } NC.App.Opstate.Measurement.Add(cl); // TODO: for Reanalysis, a full reconstruction of the measurement state based on the ResultsRec state and the method parameter map contents (for Calib and Verif) } } else MessageBox.Show("No items found in database matching these parameters", "WARNING"); break; case ConstructedSource.Manual: UIIntegration.Controller.file = true; NC.App.AppContext.DBDataAssay = true; IDDManualDataEntry mdlg = new IDDManualDataEntry(); mdlg.AH = this; dr = mdlg.ShowDialog(); if (dr == DialogResult.OK) { // the work is done in the dialog class } break; case ConstructedSource.CycleFile: NC.App.AppContext.TestDataFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select a test data (disk) file", NC.App.AppContext.FileInput, "INCC5 Test data (disk)", "dat"); break; case ConstructedSource.ReviewFile: NC.App.AppContext.ReviewFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select an NCC file", NC.App.AppContext.FileInput, "INCC5 Review", "NCC"); break; case ConstructedSource.NCDFile: NC.App.AppContext.NCDFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select NCD files or folder", NC.App.AppContext.FileInput, "LMMM NCD", "ncd"); } break; case ConstructedSource.SortedPulseTextFile: NC.App.AppContext.PulseFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw1 = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw1.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select pulse files or folder", NC.App.AppContext.FileInput, "pulse", "txt"); } break; case ConstructedSource.PTRFile: NC.App.AppContext.PTRFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw2 = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw2.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select PTR-32 files or folder", NC.App.AppContext.FileInput, "PTR-32", "bin", "chn"); } break; case ConstructedSource.NILAFile: NC.App.AppContext.NILAFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFilesFolder("Select NILA files or folder", NC.App.AppContext.FileInput, "MTS NILA", "dat"); //dr = DialogResult.Cancel; break; default: break; } return dr; }
public void CanAddTicksAcrossDstTransition() { var tz = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time"); var dto = new DateTimeOffset(2015, 3, 8, 1, 59, 59, 999, TimeSpan.FromHours(-8)).AddTicks(9999); var result = dto.AddTicks(1, tz); var expected = new DateTimeOffset(2015, 3, 8, 3, 0, 0, TimeSpan.FromHours(-7)); Assert.Equal(expected, result); Assert.Equal(expected.Offset, result.Offset); }
public static void AddTicks(DateTimeOffset dateTimeOffset, long ticks, DateTimeOffset expected) { Assert.Equal(expected, dateTimeOffset.AddTicks(ticks)); }
/// <summary> /// Parse the given string representation into a <see cref="DateTimeOffset"/> value. /// </summary> /// <param name="value">A string representation of a date time.</param> /// <returns>A <see cref="DateTimeOffset"/> value.</returns> public DateTimeOffset ParseDateTimeOffset(string value) { int year, month, day, hour, minute, second, offsetHours, offsetMinutes; long ticks; DateTimeKind dateTimeKind; GetDateTimeComponents(value, out year, out month, out day, out hour, out minute, out second, out ticks, out offsetHours, out offsetMinutes, out dateTimeKind); TimeSpan utcOffset; switch (dateTimeKind) { case DateTimeKind.Unspecified: utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now); break; case DateTimeKind.Utc: case DateTimeKind.Local: utcOffset = new TimeSpan(offsetHours, offsetMinutes, 0); break; default: throw new ArgumentOutOfRangeException(); } var dateTimeOffset = new DateTimeOffset(year, month, day, hour, minute, second, utcOffset); dateTimeOffset = dateTimeOffset.AddTicks(ticks); return dateTimeOffset; }
//[Variation("ToString(DateTimeOffset, format) - valid cases")] public int ToType57() { var dto = new DateTimeOffset(); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM"), "0001-01", "datetimeOffset1"); dto = new DateTimeOffset(); CError.Equals(XmlConvert.ToString(dto, "yyyy"), "0001", "datetimeOffset2"); dto = new DateTimeOffset(); CError.Equals(XmlConvert.ToString(dto, null), "01/01/0001 00:00:00 +00:00", "datetimeOffset3"); string s = XmlConvert.ToString(XmlConvert.ToDateTimeOffset("2002-12-30"), "yyyy-MM-dd"); CError.Equals(s, "2002-12-30", "datetimeOffset"); dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "2002-12-30T23:15:55+00:00", "datetimeOffset4"); dto = new DateTimeOffset(1, 1, 1, 23, 59, 59, TimeSpan.Zero); dto = dto.AddTicks(9999999); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "0001-01-01T23:59:59+00:00", "datetimeOffset5"); dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "2002-12-30T23:15:55+00:00", "datetimeOffset6"); dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-dd"), "2002-12-30", "datetimeOffset7"); dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero); CError.Equals(XmlConvert.ToString(dto, "HH:mm:ss"), "23:15:55", "datetimeOffset8"); dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero); CError.Equals(XmlConvert.ToString(dto, "HH:mm:ssZ"), "23:15:55Z", "datetimeOffset9"); dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, TimeSpan.FromMinutes(0)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "0001-01-01T00:00:00+00:00", "datetimeOffset10"); dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, TimeSpan.FromMinutes(-840)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "0001-01-01T00:00:00-14:00", "datetimeOffset11"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromMinutes(840)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "9999-12-31T23:59:59+14:00", "datetimeOffset12"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromMinutes(840)); CError.Equals(XmlConvert.ToString(dto, null), "12/31/9999 23:59:59 +14:00", "datetimeOffset13"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromMinutes(0)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "9999-12-31T23:59:59+00:00", "datetimeOffset14"); dto = DateTimeOffset.MaxValue; CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "9999-12-31T23:59:59+00:00", "datetimeOffset16"); dto = DateTimeOffset.MaxValue; CError.Equals(XmlConvert.ToString(dto, null), "12/31/9999 23:59:59 +00:00", "datetimeOffset18"); dto = DateTimeOffset.MinValue; CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "0001-01-01T00:00:00+00:00", "datetimeOffset19"); dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, 1, TimeSpan.FromHours(-0)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "0001-01-01T00:00:00.001+00:00", "datetimeOffset22"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 999, TimeSpan.FromHours(14)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "9999-12-31T23:59:59.999+14:00", "datetimeOffset23"); dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, 999, TimeSpan.FromHours(-14)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "0001-01-01T00:00:00.999-14:00", "datetimeOffset24"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 125, TimeSpan.FromHours(14)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "9999-12-31T23:59:59.125+14:00", "datetimeOffset25"); dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 999, TimeSpan.FromHours(-14)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "2000-02-29T23:59:59.999-14:00", "datetimeOffset26"); dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 444, TimeSpan.FromHours(+14)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "2000-02-29T23:59:59.444+14:00", "datetimeOffset27"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 999, TimeSpan.FromHours(14)); CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "9999-12-31T23:59:59.999+14:00", "datetimeOffset28"); return TEST_PASS; }
//[Variation("ToString(DateTimeOffset) - valid cases")] public int ToType56() { var dto = new DateTimeOffset(); CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00Z", "datetimeOffset1"); dto = new DateTimeOffset(2002, 12, 30, 0, 0, 0, 0, TimeSpan.FromHours(-8)); CError.Equals(XmlConvert.ToString(dto), "2002-12-30T00:00:00-08:00", "datetimeOffset2"); dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, 556, TimeSpan.Zero); CError.Equals(XmlConvert.ToString(dto), "2002-12-30T23:15:55.556Z", "datetimeOffset3"); dto = new DateTimeOffset(1, 1, 1, 23, 59, 59, TimeSpan.Zero); dto = dto.AddTicks(9999999); CError.Equals(XmlConvert.ToString(dto), "0001-01-01T23:59:59.9999999Z", "milisecs"); dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero); CError.Equals(XmlConvert.ToString(dto), "2002-12-30T23:15:55Z", "datetimeOffset4"); dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, TimeSpan.FromHours(0)); CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00Z", "datetimeOffset5"); dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, TimeSpan.FromHours(-14)); CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00-14:00", "datetimeOffset6"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromHours(14)); CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59+14:00", "datetimeOffset7"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromHours(0)); CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59Z", "datetimeOffset8"); dto = DateTimeOffset.MaxValue; CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59.9999999Z", "datetimeOffset10"); dto = DateTimeOffset.MinValue; CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00Z", "datetimeOffset11"); dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, 1, TimeSpan.FromHours(-0)); CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00.001Z", "datetimeOffset14"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 999, TimeSpan.FromHours(14)); CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59.999+14:00", "datetimeOffset15"); dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, 999, TimeSpan.FromHours(-14)); CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00.999-14:00", "datetimeOffset16"); dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 125, TimeSpan.FromHours(14)); CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59.125+14:00", "datetimeOffset17"); dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 999, TimeSpan.FromHours(-14)); CError.Equals(XmlConvert.ToString(dto), "2000-02-29T23:59:59.999-14:00", "datetimeOffset18"); dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 444, TimeSpan.FromHours(+14)); CError.Equals(XmlConvert.ToString(dto), "2000-02-29T23:59:59.444+14:00", "datetimeOffset19"); dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 999, TimeSpan.FromHours(-14)); CError.Equals(XmlConvert.ToString(dto), "2000-02-29T23:59:59.999-14:00", "datetimeOffset20"); return TEST_PASS; }
public void DATETIMEOFFSET_Data_ScriptsCorrectly() { DateTimeOffset baseData = new DateTimeOffset(2000, 10, 31, 2, 33, 44, new TimeSpan(3,0,0)); object data = baseData; var fieldInfo = SchemaScriptingTests.FakeColumn("test", "test", 32, "datetimeoffset", false, 0, 0); Assert.AreEqual("'2000-10-31T02:33:44+03:00'", FieldScripting.valueAsTSQLLiteral(data, fieldInfo), "datetimeoffset no fractional seconds"); Assert.AreEqual("2000-10-31T02:33:44+03:00", FieldScripting.formatDatetimeoffset(data, false), "datetimeoffset no fractional seconds"); baseData = baseData.AddTicks(1234567); data = baseData; Assert.AreEqual("'2000-10-31T02:33:44.1234567+03:00'", FieldScripting.valueAsTSQLLiteral(data, fieldInfo), "datetimeoffset fractional seconds"); Assert.AreEqual("2000-10-31T02:33:44.1234567+03:00", FieldScripting.formatDatetimeoffset(data, false), "datetimeoffset fractional seconds"); }