4795return new TimeSpan(i64ProcessorTime);

1766TimeSpan controlCWaitTime = new TimeSpan(0, 0, 30); // 30 seconds

97TimeSpan offset = new TimeSpan(m_ticksOffset); 221delta = new TimeSpan(rawData[16] * TicksPerMinute); 239return new TimeSpan(TimeZone.CalculateUtcOffset(time, GetDaylightChanges(time.Year)).Ticks + m_ticksOffset);

1254return new TimeSpan(InternalTicks % TicksPerDay); 1333return new TimeSpan(InternalTicks - value.InternalTicks); 1504return new TimeSpan(d1.InternalTicks - d2.InternalTicks);

76offset = new TimeSpan(0); 312return new TimeSpan(0, m_offsetMinutes, 0);

560result = new TimeSpan(hourOffset, minuteOffset, 0); 1062result.timeZoneOffset = new TimeSpan(0); 3029result = (new TimeSpan(hourOffset, minuteOffset, 0)); 3482result.timeZoneOffset = new TimeSpan(0); 3724TimeSpan tempTimeZoneOffset = new TimeSpan(0); 3744result.timeZoneOffset = new TimeSpan(0); 3767result.timeZoneOffset = new TimeSpan(0); 3772TimeSpan tempTimeZoneOffset = new TimeSpan(0);

391return new DateTime(DateToTicks(year, month, day) + (new TimeSpan(0, hour, minute, second, millisecond)).Ticks);

643return new TimeSpan(_store.ReadInt64()); 737return new TimeSpan(ticks);

380return new TimeSpan(ticks);

357return new TimeSpan(ReadInt64());

21public static readonly TimeSpan InfiniteTimeSpan = new TimeSpan(0, 0, 0, 0, Timeout.Infinite);

66public static readonly TimeSpan Zero = new TimeSpan(0); 68public static readonly TimeSpan MaxValue = new TimeSpan(Int64.MaxValue); 69public static readonly TimeSpan MinValue = new TimeSpan(Int64.MinValue); 160return new TimeSpan(result); 201return new TimeSpan(_ticks >= 0? _ticks: -_ticks); 236return new TimeSpan((long)millis * TicksPerMillisecond); 251return new TimeSpan(-_ticks); 265return new TimeSpan(result); 269return new TimeSpan(value); 343return new TimeSpan(-t._ticks);

1094m_baseUtcOffset = new TimeSpan(0, -(zone.Bias), 0); 1382new TimeSpan(0, defaultBaseUtcOffset - timeZoneInformation.Bias, 0)); // Bias delta is all what we need from this rule 1406new TimeSpan(0, -timeZoneInformation.DaylightBias, 0), 1409new TimeSpan(0, defaultBaseUtcOffset - timeZoneInformation.Bias, 0)); 2815new TimeSpan(0, -(defaultTimeZoneInformation.Bias), 0), 3902return new TimeSpan(0 /* hours */, token /* minutes */, 0 /* seconds */);

407return new TimeSpan(GetI8FromVar());

135return new TimeSpan(0, 0, 1);

58_repeatDuration = new TimeSpan(0); 70if (duration < new TimeSpan(0))

80_globalTime = new TimeSpan(-1); 81_lastTickTime = new TimeSpan(-1); 84ParallelTimeline timeManagerTimeline = new ParallelTimeline(new TimeSpan(0), Duration.Forever);

1143_throttleBackgroundTimer.Interval = new TimeSpan(0, 0, _throttleBackgroundSeconds);

99_throttleBackgroundTimer.Interval = new TimeSpan(0, 0, (int)_throttleBackgroundSeconds);

2049_browserCallbackSponsor = new SponsorHelper(lease, new TimeSpan(0, 5, 0));

69_position = new SettableState<TimeSpan>(new TimeSpan(0));

501plainText = (string)Dispatcher.Invoke(DispatcherPriority.Send, new TimeSpan(0, 0, 0, 0, 20), new DispatcherOperationCallback(delegate(object o) {

407Dispatcher.Invoke(DispatcherPriority.Send, new TimeSpan(0, 0, 0, 0, 20), new DispatcherOperationCallback(delegate(object o)

351Dispatcher.Invoke(DispatcherPriority.Send, new TimeSpan(0, 0, 0, 0, 20), new DispatcherOperationCallback(delegate(object o)

2924internal static TimeSpan AnimationDelayTime = new TimeSpan(0, 0, 0, 0, AnimationDelay);

395Dispatcher.Invoke(DispatcherPriority.Send, new TimeSpan(0, 0, 0, 0, 20), new DispatcherOperationCallback(delegate(object o)

314Dispatcher.Invoke(DispatcherPriority.Send, new TimeSpan(0, 0, 0, 0, 20), new DispatcherOperationCallback(delegate(object o)

10261bamlType.DefaultConstructor = delegate() { return new System.TimeSpan(); };

90private Duration _generatedDuration = new Duration(new TimeSpan());

6784_taskbarRetryTimer = new DispatcherTimer { Interval = new TimeSpan(0, 1, 0) };

259connectionLifetime = new TimeSpan(0, 0, 0, 0, timeout);

93new TimeSpanValidator(new TimeSpan(0, 0, 0), TimeSpan.MaxValue, false),

70return new TimeSpan(0, 0, (int)timeouts[(int)type]);

96tempTimeZoneOffsetLookup.Add("EDT", new TimeSpan(-4, 0, 0)); // -0400 97tempTimeZoneOffsetLookup.Add("EST", new TimeSpan(-5, 0, 0)); // -0500 98tempTimeZoneOffsetLookup.Add("CDT", new TimeSpan(-5, 0, 0)); // -0500 99tempTimeZoneOffsetLookup.Add("CST", new TimeSpan(-6, 0, 0)); // -0600 100tempTimeZoneOffsetLookup.Add("MDT", new TimeSpan(-6, 0, 0)); // -0600 101tempTimeZoneOffsetLookup.Add("MST", new TimeSpan(-7, 0, 0)); // -0700 102tempTimeZoneOffsetLookup.Add("PDT", new TimeSpan(-7, 0, 0)); // -0700 103tempTimeZoneOffsetLookup.Add("PST", new TimeSpan(-8, 0, 0)); // -0800 391timeZone = new TimeSpan((int) hours, (int) minutes, 0); 415TimeSpan sanitizedTimeSpan = new TimeSpan(span.Days, span.Hours, span.Minutes, 0, 0);

1579(m_LastDnsResolve + new TimeSpan(0, 0, 0, 0, dnsRefreshTimeout)) < DateTime.UtcNow;

326TimeSpan timeout = new TimeSpan(timeoutTicks);

1142new TimeSpan(0, 0, 0), // default

660new TimeSpan(0, 0, 0), // default

134m_timeout = new TimeSpan(0, 0, 0); // default timeout

2816return new TimeSpan(kernel); 2822return new TimeSpan(user); 2828return new TimeSpan(user + kernel);

121get { return new TimeSpan( GetElapsedDateTimeTicks()); }

60private TimeSpan _startupTimeout = new TimeSpan(0, 0, 10);

2427private static readonly TimeSpan x_timeMax = new TimeSpan(TimeSpan.TicksPerDay - 1);

555return new TimeSpan((Int64)(Int32)value); 557return new TimeSpan((Int64)value); 700return new TimeSpan((Int64)(Int32)value); 702return new TimeSpan((Int64)value);

170return new TimeSpan((Int64)((Int32)value)); 173return new TimeSpan((Int64)value);

480return new DateTimeOffset((DateTime)argumentValues[0], new TimeSpan((int)argumentValues[1], (int)argumentValues[2], 0));

606return new TimeSpan(

36_loadBalanceTimeout = new TimeSpan(0, 0, loadBalanceTimeout);

1032return new TimeSpan(InternalAdjustTimeTicks(value.Ticks)); 1478private static readonly TimeSpan x_timeMax = new TimeSpan(TimeSpan.TicksPerDay - 1);

402return new TimeSpan(_value._timeInfo.ticks); 414TimeSpan offset = new TimeSpan(0, _value._dateTimeOffsetInfo.offset, 0);

171private static readonly TimeSpan _dbAuthenticationContextLockedRefreshTimeSpan = new TimeSpan(hours: 0, minutes: 45, seconds: 00); 175private static readonly TimeSpan _dbAuthenticationContextUnLockedRefreshTimeSpan = new TimeSpan(hours: 0, minutes: 10, seconds: 00);

220return new TimeSpan(value.m_day * TimeSpan.TicksPerDay +

554TimeSpan offsetTimeSpan = new TimeSpan(offsetHours, offsetMinutes, 0); 593TimeSpan ts = new TimeSpan(hour, minute, second); 594ts = ts.Add(new TimeSpan(ticks));

240value = new TimeSpan(temp.Ticks);

124return new TimeSpan((long)Convert.ChangeType(value, typeof(long), Globalization.CultureInfo.InvariantCulture));

1962request.Timeout = (int)Math.Min(Int32.MaxValue, new TimeSpan(0, 0, this.timeout).TotalMilliseconds);

28public static readonly TimeSpan DefaultMaxClockSkew = new TimeSpan(0, 5, 0);

42public static readonly TimeSpan DefaultMaxClockSkew = new TimeSpan(0, 5, 0); // 5 minutes

391 timespan = new System.TimeSpan(days, hours, minutes, seconds, 0); 449 TimeSpan tsTemp = new TimeSpan(timespan.Days ,timespan.Hours,timespan.Minutes ,timespan.Seconds ,0);

120new CacheTable<string, string>("formatNameCache", 4, new TimeSpan(0, 0, 100)); // path -> formatname 123new CacheTable<QueueInfoKeyHolder, MQCacheableInfo>("queue info", 4, new TimeSpan(0, 0, 100)); // <formatname, accessMode> -> <readHandle. writeHandle, isTrans> 1583formatNameCache.ClearStale(new TimeSpan(0)); 1584queueInfoCache.ClearStale(new TimeSpan(0));

26private static readonly TimeSpan OneYear = new TimeSpan(365, 0, 0, 0);

48return new DateTimeOffset(value.UtcDateTime, new TimeSpan(0, value.OffsetMinutes, 0)); 56return deserialized.ToOffset(new TimeSpan(0, value.OffsetMinutes, 0));

412return new TimeSpan(GetInt64());

832TimeSpan ts = new TimeSpan(hourDelta, minuteDelta, 0);

402new TimeSpan(0, 0, 0), // default 693new TimeSpan(0, 0, 0),

117this.maintainerRetryInterval = new TimeSpan(PeerTransportConstants.MaintainerRetryInterval * 10000); 118this.maintainerTimeout = new TimeSpan(PeerTransportConstants.MaintainerTimeout * 10000); 119this.unregisterTimeout = new TimeSpan(PeerTransportConstants.UnregisterTimeout * 10000);

690static TimeSpan Timeout = new TimeSpan(0, 2, 0);

47static TimeSpan MaxTimeout = new TimeSpan(0, 10, 0); //PNRP validates the timeout to be no greater than 10 minutes 48static TimeSpan MaxResolveTimeout = new TimeSpan(0, 0, 45);

534TimeSpan elapsedTime = new TimeSpan(DateTime.UtcNow.Ticks - startTicks);

315DateTime effectiveExpirationTime = TimeoutHelper.Add(serviceToken.ValidFrom.ToUniversalTime(), new TimeSpan(effectiveTicksInterval));

25internal static readonly TimeSpan zeroOffset = new TimeSpan(0, 0, 0);

44return new TimeSpan(ticks);

312cache.SetMaxAge(new TimeSpan(0, 0, this.cacheProfile.Duration));

62static readonly TimeSpan FUTURE_FILETIME_BUFFER = new TimeSpan(0, 1, 0); // See VSWhidbey 400917

87static readonly TimeSpan OneYear = new TimeSpan(365, 0, 0, 0);

605internal static TimeSpan OneSec = new TimeSpan(0, 0, 1); 800DateTime waitLimit = DateTime.UtcNow.Add(new TimeSpan(0, 0, timeout)); 1020DateTime waitLimit = DateTime.UtcNow.Add(new TimeSpan(0, 0, timeout));

255controller.WaitForStatus(ServiceControllerStatus.Stopped, new TimeSpan(0, 5, 0));

39internal static TimeSpan DefaultPrivateBytesPollTime = new TimeSpan(0, 2, 0);

79internal static TimeSpan DefaultClientConnectedCheck = new TimeSpan(0, 0, 5);

446static TimeSpan s_oneYear = new TimeSpan(TimeSpan.TicksPerDay * 365);

3138Cache.SetExpires(_context.Timestamp + new TimeSpan(0, _expiresInMinutes, 0));

920_context.Timeout = new TimeSpan(0, 0, value);

21private readonly TimeSpan _timerPeriod = new TimeSpan(0, 0, 30); // 30 secs

2053static TimeSpan TS_ONE_SECOND = new TimeSpan(0, 0, 1); 2190static TimeSpan TS_ONE_SECOND = new TimeSpan(0, 0, 1);

42private readonly TimeSpan _timerPeriod = new TimeSpan(0, 0, 10); // 10 seconds

20private readonly TimeSpan _timerPeriod = new TimeSpan(0, 0, 15); // 15 second init precision

2642inActiveWindow = (diffTime <= new TimeSpan(0, PasswordAttemptWindow, 0)); 2772bool isLockedOutByBadPasswordAnswer = (diffTime <= new TimeSpan(0, PasswordAnswerAttemptLockoutDuration, 0)); 3776request.TimeLimit = new TimeSpan(0, ServerSearchTimeout, 0); 3833adLockoutDuration = new TimeSpan(-int64Value); 4144request.TimeLimit = new TimeSpan(0, ServerSearchTimeout, 0);

672public static TimeSpan Timeout { get { Initialize(); return new TimeSpan(0, _Timeout, 0); } }

350SlidingExpiration = new TimeSpan(0, state._timeout, 0), 389SlidingExpiration = new TimeSpan(0, timeout, 0),

177new ResourcePool(new TimeSpan(0, 0, 5), int.MaxValue), 484lockAge = new TimeSpan(0, 0, results.lockAge);

125static readonly TimeSpan LOCKED_ITEM_POLLING_DELTA = new TimeSpan(250 * TimeSpan.TicksPerMillisecond); 127static readonly TimeSpan DEFAULT_DBG_EXECUTION_TIMEOUT = new TimeSpan(0, 0, System.Web.Compilation.PageCodeDomTreeGenerator.DebugScriptTimeout);

240return new SqlPartitionInfo(new ResourcePool(new TimeSpan(0, 0, 5), int.MaxValue), 528lockAge = new TimeSpan(0, 0, (int) cmd.Parameters[3].Value); 538if (lockAge > new TimeSpan(0, 0, Sec.ONE_YEAR)) {

552timeout = new TimeSpan(0, timeoutMinutes, 0);

3704cache.SetMaxAge(new TimeSpan(0, 0, duration));

570value = (new TimeSpan(0, 0, timeoutInSeconds)).ToString();

697Duration = new TimeSpan(0 /*hours*/, 0 /*mins*/, duration /*seconds*/); 771Duration = new TimeSpan(0 /*hours*/, 0 /*mins*/, cacheAttrib.Duration /*seconds*/);

239value = new TimeSpan(reader.ReadInt64());

61return new TimeSpan(timeoutValue, 0, 0, 0); 63return new TimeSpan(timeoutValue, 0, 0); 65return new TimeSpan(0, 0, timeoutValue); 67return new TimeSpan(0, 0, 0, 0, timeoutValue); 69return new TimeSpan(0, timeoutValue, 0);

82TimeSpan ts = new TimeSpan(0, SystemWebProxy.Membership.UserIsOnlineTimeWindow, 0);

1285 TimeSpan span = new TimeSpan(0);

33private static readonly TimeSpan _cacheExpirationTime = new TimeSpan(0, 20, 0);

434chain.ChainPolicy.UrlRetrievalTimeout = new TimeSpan(0, 1, 0);

1285 TimeSpan span = new TimeSpan(0);

33public static readonly DependencyProperty TimeoutDurationProperty = DependencyProperty.Register("TimeoutDuration", typeof(TimeSpan), typeof(DelayActivity), new PropertyMetadata(new TimeSpan(0, 0, 0))); 259standardValuesCollection.Add(new TimeSpan(0, 0, 0)); 260standardValuesCollection.Add(new TimeSpan(0, 1, 0)); 261standardValuesCollection.Add(new TimeSpan(0, 30, 0)); 262standardValuesCollection.Add(new TimeSpan(1, 0, 0)); 263standardValuesCollection.Add(new TimeSpan(12, 0, 0)); 264standardValuesCollection.Add(new TimeSpan(1, 0, 0, 0));

25public static readonly DependencyProperty TimeoutDurationProperty = DependencyProperty.Register("TimeoutDuration", typeof(TimeSpan), typeof(WorkflowTransactionOptions), new PropertyMetadata(new TimeSpan(0, 0, 30), DependencyPropertyOptions.Metadata)); 122standardValuesCollection.Add(new TimeSpan(0, 0, 0)); 123standardValuesCollection.Add(new TimeSpan(0, 0, 15)); 124standardValuesCollection.Add(new TimeSpan(0, 1, 0));

23private static TimeSpan infinite = new TimeSpan(Timeout.Infinite); 25private static TimeSpan fiveMinutes = new TimeSpan(0, 5, 0);

56private static TimeSpan infinite = new TimeSpan(Timeout.Infinite); 58private static TimeSpan fiveMinutes = new TimeSpan(0, 5, 0);

690TimeSpan loadingInterval = new TimeSpan(0, 2, 0); 691private TimeSpan maxLoadingInterval = new TimeSpan(365, 0, 0, 0, 0); 694TimeSpan infinite = new TimeSpan(Timeout.Infinite); 764_ownershipDelta = new TimeSpan(0, 0, seconds); 776this.loadingInterval = new TimeSpan(0, 0, interval); 1195private TimeSpan minUpdate = new TimeSpan(0, 0, 5); 1196private TimeSpan infinite = new TimeSpan(Timeout.Infinite);

799return SQLBaseDate.Add( new TimeSpan( dateticks * TimeSpan.TicksPerDay + 882DateTimeOffset dto = new DateTimeOffset(dateTicks + timeTicks + zoneTicks, new TimeSpan(zoneTicks));

348return new DateTime(dt.Subtract(new TimeSpan(ZoneHour, ZoneMinute, 0)).Ticks, DateTimeKind.Utc); 351return new DateTime(dt.Add(new TimeSpan(ZoneHour, ZoneMinute, 0)).Ticks, DateTimeKind.Utc); 403ticks = result.Ticks - new TimeSpan(xdt.ZoneHour, xdt.ZoneMinute, 0).Ticks; 416ticks = result.Ticks + new TimeSpan(xdt.ZoneHour, xdt.ZoneMinute, 0).Ticks; 455result = new DateTimeOffset(dt, new TimeSpan(xdt.ZoneHour, xdt.ZoneMinute, 0)); 458result = new DateTimeOffset(dt, new TimeSpan(-xdt.ZoneHour, -xdt.ZoneMinute, 0)); 461result = new DateTimeOffset(dt, new TimeSpan( 0 ) ); 652return dt.Subtract(new TimeSpan(ZoneHour, ZoneMinute, 0)); 654return dt.Add(new TimeSpan(ZoneHour, ZoneMinute, 0));

333result = new TimeSpan(Int64.MinValue); 336result = new TimeSpan(-((long) ticks)); 340result = new TimeSpan((long) ticks);

277opts.Timeout = TimeSpan.FromMinutes(5);

55typeof(TimeSpan),

4786public TimeSpan MonitoringTotalProcessorTime

1766TimeSpan controlCWaitTime = new TimeSpan(0, 0, 30); // 30 seconds

97TimeSpan offset = new TimeSpan(m_ticksOffset); 200m_CachedDaylightChanges.Add(objYear, new DaylightTime(DateTime.MinValue, DateTime.MinValue, TimeSpan.Zero)); 204TimeSpan delta; 234public override TimeSpan GetUtcOffset(DateTime time) { 236return TimeSpan.Zero;

432public DateTime Add(TimeSpan value) { 622return (TimeSpan.TimeToTicks(hour, minute, second)); 820TimeSpan offset = TimeZoneInfo.GetLocalUtcOffset(this, TimeZoneInfoOptions.NoThrowOnInvalidTime); 1252public TimeSpan TimeOfDay { 1332public TimeSpan Subtract(DateTime value) { 1336public DateTime Subtract(TimeSpan value) { 1485public static DateTime operator +(DateTime d, TimeSpan t) { 1494public static DateTime operator -(DateTime d, TimeSpan t) { 1503public static TimeSpan operator -(DateTime d1, DateTime d2) {

42internal const Int64 MaxOffset = TimeSpan.TicksPerHour * 14; 45private const long UnixEpochTicks = TimeSpan.TicksPerDay * DateTime.DaysTo1970; // 621,355,968,000,000,000 46private const long UnixEpochSeconds = UnixEpochTicks / TimeSpan.TicksPerSecond; // 62,135,596,800 47private const long UnixEpochMilliseconds = UnixEpochTicks / TimeSpan.TicksPerMillisecond; // 62,135,596,800,000 50public static readonly DateTimeOffset MinValue = new DateTimeOffset(DateTime.MinTicks, TimeSpan.Zero); 51public static readonly DateTimeOffset MaxValue = new DateTimeOffset(DateTime.MaxTicks, TimeSpan.Zero); 60public DateTimeOffset(long ticks, TimeSpan offset) { 70TimeSpan offset; 85public DateTimeOffset(DateTime dateTime, TimeSpan offset) { 92if (offset != TimeSpan.Zero) { 102public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, TimeSpan offset) { 122public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, TimeSpan offset) { 144public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, TimeSpan offset) { 205public DateTimeOffset ToOffset(TimeSpan offset) { 310public TimeSpan Offset { 346public TimeSpan TimeOfDay { 365public DateTimeOffset Add(TimeSpan timeSpan) { 520const long MinSeconds = DateTime.MinTicks / TimeSpan.TicksPerSecond - UnixEpochSeconds; 521const long MaxSeconds = DateTime.MaxTicks / TimeSpan.TicksPerSecond - UnixEpochSeconds; 528long ticks = seconds * TimeSpan.TicksPerSecond + UnixEpochTicks; 529return new DateTimeOffset(ticks, TimeSpan.Zero); 533const long MinMilliseconds = DateTime.MinTicks / TimeSpan.TicksPerMillisecond - UnixEpochMilliseconds; 534const long MaxMilliseconds = DateTime.MaxTicks / TimeSpan.TicksPerMillisecond - UnixEpochMilliseconds; 541long ticks = milliseconds * TimeSpan.TicksPerMillisecond + UnixEpochTicks; 542return new DateTimeOffset(ticks, TimeSpan.Zero); 593TimeSpan offset; 611TimeSpan offset; 633TimeSpan offset; 644TimeSpan offset; 653public TimeSpan Subtract(DateTimeOffset value) { 657public DateTimeOffset Subtract(TimeSpan value) { 683long seconds = UtcDateTime.Ticks / TimeSpan.TicksPerSecond; 690long milliseconds = UtcDateTime.Ticks / TimeSpan.TicksPerMillisecond; 728TimeSpan offset; 741TimeSpan offset; 755TimeSpan offset; 770TimeSpan offset; 783private static Int16 ValidateOffset(TimeSpan offset) { 785if (ticks % TimeSpan.TicksPerMinute != 0) { 791return (Int16)(offset.Ticks / TimeSpan.TicksPerMinute); 795private static DateTime ValidateDate(DateTime dateTime, TimeSpan offset) { 837public static DateTimeOffset operator +(DateTimeOffset dateTimeOffset, TimeSpan timeSpan) { 842public static DateTimeOffset operator -(DateTimeOffset dateTimeOffset, TimeSpan timeSpan) { 846public static TimeSpan operator -(DateTimeOffset left, DateTimeOffset right) {

933: TraceLoggingTypeInfo<TimeSpan> 943public override void WriteData(TraceLoggingDataCollector collector, ref TimeSpan value)

781else if (dataType == typeof(TimeSpan))

844return TimeSpan.TimeToTicks(hour, minute, second) + millisecond * TicksPerMillisecond;

131internal static readonly TimeSpan NullOffset = TimeSpan.MinValue; 434private static String FormatCustomized(DateTime dateTime, String format, DateTimeFormatInfo dtfi, TimeSpan offset) { 717private static void FormatCustomizedTimeZone(DateTime dateTime, TimeSpan offset, String format, Int32 tokenLen, Boolean timeOnly, StringBuilder result) { 744if (offset >= TimeSpan.Zero) { 768private static void FormatCustomizedRoundripTimeZone(DateTime dateTime, TimeSpan offset, StringBuilder result) { 791if (offset >= TimeSpan.Zero) { 871private static String ExpandPredefinedFormat(String format, ref DateTime dateTime, ref DateTimeFormatInfo dtfi, ref TimeSpan offset) { 912internal static String Format(DateTime dateTime, String format, DateTimeFormatInfo dtfi, TimeSpan offset) 982internal static StringBuilder FastFormatRfc1123(DateTime dateTime, TimeSpan offset, DateTimeFormatInfo dtfi) 1013internal static StringBuilder FastFormatRoundtrip(DateTime dateTime, TimeSpan offset) 1031long fraction = dateTime.Ticks % TimeSpan.TicksPerSecond;

61internal static DateTime ParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, out TimeSpan offset) { 63offset = TimeSpan.Zero; 86internal static bool TryParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result, out TimeSpan offset) { 88offset = TimeSpan.Zero; 138DateTimeFormatInfo dtfi, DateTimeStyles style, out TimeSpan offset) { 140offset = TimeSpan.Zero; 153DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result, out TimeSpan offset) { 155offset = TimeSpan.Zero; 504private static bool ParseTimeZone(ref __DTString str, ref TimeSpan result) { 2286internal static DateTime Parse(String s, DateTimeFormatInfo dtfi, DateTimeStyles styles, out TimeSpan offset) { 2311internal static bool TryParse(String s, DateTimeFormatInfo dtfi, DateTimeStyles styles, out DateTime result, out TimeSpan offset) { 2313offset = TimeSpan.Zero; 2605result.timeZoneOffset = TimeSpan.Zero; 2634result.timeZoneOffset = TimeSpan.Zero; 2667result.timeZoneOffset = TimeSpan.Zero; 2674result.timeZoneOffset = TimeSpan.Zero; 2803result.timeZoneOffset = TimeSpan.Zero; 2986private static bool ParseTimeZoneOffset(ref __DTString str, int len, ref TimeSpan result) { 3724TimeSpan tempTimeZoneOffset = new TimeSpan(0); 3738if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && result.timeZoneOffset != TimeSpan.Zero) { 3761if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && result.timeZoneOffset != TimeSpan.Zero) { 3772TimeSpan tempTimeZoneOffset = new TimeSpan(0); 3839result.timeZoneOffset = TimeSpan.Zero; 3843result.timeZoneOffset = TimeSpan.Zero; 3921result.timeZoneOffset = TimeSpan.Zero; 5004internal TimeSpan timeZoneOffset;

16internal TimeSpan m_delta; 21public DaylightTime(DateTime start, DateTime end, TimeSpan delta) { 42public TimeSpan Delta { 53public DaylightTimeStruct(DateTime start, DateTime end, TimeSpan delta) 62public TimeSpan Delta { get; }

347return (TimeSpan.TimeToTicks(hour, minute, second) + millisecond * TicksPerMillisecond);;

35internal static String Format(TimeSpan value, String format, IFormatProvider formatProvider) { 71private static String FormatStandard(TimeSpan value, bool isInvariant, String format, Pattern pattern) { 73int day = (int)(value._ticks / TimeSpan.TicksPerDay); 74long time = value._ticks % TimeSpan.TicksPerDay; 80int hours = (int)(time / TimeSpan.TicksPerHour % 24); 81int minutes = (int)(time / TimeSpan.TicksPerMinute % 60); 82int seconds = (int)(time / TimeSpan.TicksPerSecond % 60); 83int fraction = (int)(time % TimeSpan.TicksPerSecond); 146internal static String FormatCustomized(TimeSpan value, String format, DateTimeFormatInfo dtfi) { 150int day = (int)(value._ticks / TimeSpan.TicksPerDay); 151long time = value._ticks % TimeSpan.TicksPerDay; 157int hours = (int)(time / TimeSpan.TicksPerHour % 24); 158int minutes = (int)(time / TimeSpan.TicksPerMinute % 60); 159int seconds = (int)(time / TimeSpan.TicksPerSecond % 60); 160int fraction = (int)(time % TimeSpan.TicksPerSecond);

455internal TimeSpan parsedTimeSpan; 464parsedTimeSpan = default(TimeSpan); 516if (ticks > TimeSpan.MaxMilliSeconds || ticks < TimeSpan.MinMilliSeconds) { 531long lowerLimit = TimeSpan.TicksPerTenthSecond; 540result = ((long)ticks * TimeSpan.TicksPerMillisecond) + f; 556internal static TimeSpan Parse(String input, IFormatProvider formatProvider) { 567internal static Boolean TryParse(String input, IFormatProvider formatProvider, out TimeSpan result) { 576result = default(TimeSpan); 580internal static TimeSpan ParseExact(String input, String format, IFormatProvider formatProvider, TimeSpanStyles styles) { 591internal static Boolean TryParseExact(String input, String format, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result) { 600result = default(TimeSpan); 604internal static TimeSpan ParseExactMultiple(String input, String[] formats, IFormatProvider formatProvider, TimeSpanStyles styles) { 615internal static Boolean TryParseExactMultiple(String input, String[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result) { 624result = default(TimeSpan); 1410if (!ParseInt((int)(0x7FFFFFFFFFFFFFFFL / TimeSpan.TicksPerDay), out days, ref result)) { 1413time = days * TimeSpan.TicksPerDay; 1478time = unit * TimeSpan.TicksPerHour; 1487time += unit * TimeSpan.TicksPerMinute; 1495time += unit * TimeSpan.TicksPerSecond; 1499int f = (int)TimeSpan.TicksPerSecond;

429TimeSpan ts;

107NullableHelper<TimeSpan>(); 120new List<TimeSpan>(); 144SZArrayHelper<TimeSpan>(null);

719return new DateTimeOffset(1601, 1, 1, 0, 0, 0, TimeSpan.Zero).ToLocalTime(); 760return new DateTimeOffset(1601, 1, 1, 0, 0, 0, TimeSpan.Zero).ToLocalTime(); 801return new DateTimeOffset(1601, 1, 1, 0, 0, 0, TimeSpan.Zero).ToLocalTime();

642else if (type == typeof(TimeSpan))

561else if (type == typeof(TimeSpan)) 669writer.Write(((TimeSpan) value).Ticks);

182public TimeSpan GetTimeSpan() 187return (TimeSpan)_data; 326public TimeSpan[] GetTimeSpanArray() 331return (TimeSpan[])_data;

329if (type == typeof(TimeSpan)) 330return new CLRIReferenceImpl<TimeSpan>(PropertyType.TimeSpan, (TimeSpan)obj); 406if (type == typeof(TimeSpan)) 407return new CLRIReferenceArrayImpl<TimeSpan>(PropertyType.TimeSpanArray, (TimeSpan[])obj);

76TimeSpan GetTimeSpan(); 133TimeSpan[] GetTimeSpanArray();

28private TimeSpan m_renewalTime = TimeSpan.FromMinutes(2); 34public ClientSponsor(TimeSpan renewalTime) 39public TimeSpan RenewalTime 77public TimeSpan Renewal(ILease lease)

26void Register(ISponsor obj, TimeSpan renewalTime); 35TimeSpan Renew(TimeSpan renewalTime); 37TimeSpan RenewOnCallTime 45TimeSpan SponsorshipTimeout 53TimeSpan InitialLeaseTime 61TimeSpan CurrentLeaseTime

26TimeSpan Renewal(ILease lease);

34internal TimeSpan initialLeaseTime; 37internal TimeSpan renewOnCallTime; 38internal TimeSpan sponsorshipTimeout; 54internal Lease(TimeSpan initialLeaseTime, 55TimeSpan renewOnCallTime, 56TimeSpan sponsorshipTimeout, 96public TimeSpan RenewOnCallTime 114public TimeSpan SponsorshipTimeout 132public TimeSpan InitialLeaseTime 144if (TimeSpan.Zero.CompareTo(value) >= 0) 153public TimeSpan CurrentLeaseTime 170Register(obj, TimeSpan.Zero); 175public void Register(ISponsor obj, TimeSpan renewalTime) 180if (state == LeaseState.Expired || sponsorshipTimeout == TimeSpan.Zero) 186if (renewalTime > TimeSpan.Zero) 251public TimeSpan Renew(TimeSpan renewalTime) 257internal TimeSpan RenewInternal(TimeSpan renewalTime) 263return TimeSpan.Zero; 342internal delegate TimeSpan AsyncRenewal(ILease lease); 417TimeSpan largestRenewalTime = TimeSpan.Zero; 428if ((sponsorStateInfo.sponsorState == SponsorState.Initial) && (largestRenewalTime == TimeSpan.Zero)) 491TimeSpan renewalTime = TimeSpan.Zero; 494renewalTime = (TimeSpan)ar.EndInvoke(iar); 528else if (sponsorStateInfo.renewalTime == TimeSpan.Zero) 550private void AddTime(TimeSpan renewalSpan) 579internal TimeSpan renewalTime; 582internal SponsorStateInfo(TimeSpan renewalTime, SponsorState sponsorState)

35private TimeSpan pollTime; 49internal static LeaseManager GetLeaseManager(TimeSpan pollTime) 78private LeaseManager(TimeSpan pollTime) 93internal void ChangePollTime(TimeSpan pollTime) 162internal void RegisterSponsorCall(Lease lease, Object sponsorId, TimeSpan sponsorshipTimeOut)

40private static long s_leaseTimeTicks = TimeSpan.FromMinutes(5).Ticks; 41private static long s_renewOnCallTimeTicks = TimeSpan.FromMinutes(2).Ticks; 42private static long s_sponsorshipTimeoutTicks = TimeSpan.FromMinutes(2).Ticks; 43private static long s_pollTimeTicks = TimeSpan.FromMilliseconds(10000).Ticks; 45private static TimeSpan GetTimeSpan(ref long ticks) 47return TimeSpan.FromTicks(Volatile.Read(ref ticks)); 50private static void SetTimeSpan(ref long ticks, TimeSpan value) 86public static TimeSpan LeaseTime 108public static TimeSpan RenewOnCallTime 130public static TimeSpan SponsorshipTimeout 151public static TimeSpan LeaseManagerPollTime 211internal static ILease CreateLease(TimeSpan leaseTime, 212TimeSpan renewOnCallTime, 213TimeSpan sponsorshipTimeout, 308if (ilease.InitialLeaseTime.CompareTo(TimeSpan.Zero) <= 0) 368if (lease.RenewOnCallTime > TimeSpan.Zero)

769else if (pt == typeof(TimeSpan))

138private TimeSpan _leaseTime; 139private TimeSpan _renewOnCallTime; 140private TimeSpan _sponsorshipTimeout; 141private TimeSpan _leaseManagerPollTime; 143internal TimeSpan LeaseTime { 156internal TimeSpan RenewOnCallTime { 169internal TimeSpan SponsorshipTimeout { 182internal TimeSpan LeaseManagerPollTime { 1796private static TimeSpan ParseTime(String time, RemotingXmlConfigFileData configData) 1815TimeSpan span = TimeSpan.FromSeconds(0); 1836case "d": span = TimeSpan.FromDays(value); break; 1837case "h": span = TimeSpan.FromHours(value); break; 1838case "m": span = TimeSpan.FromMinutes(value); break; 1839case "s": span = TimeSpan.FromSeconds(value); break; 1840case "ms": span = TimeSpan.FromMilliseconds(value); break;

257public static String ToString(TimeSpan timeSpan) 261if (TimeSpan.Compare(timeSpan, TimeSpan.Zero) < 1) 285long timea = Math.Abs(timeSpan.Ticks % TimeSpan.TicksPerDay); 286int t1 = (int)(timea % TimeSpan.TicksPerSecond); 298public static TimeSpan Parse(String value) 305return TimeSpan.Zero; 375(Int64.Parse(year, CultureInfo.InvariantCulture)*360+Int64.Parse(month, CultureInfo.InvariantCulture)*30+Int64.Parse(day, CultureInfo.InvariantCulture))*TimeSpan.TicksPerDay+ 376Int64.Parse(hour, CultureInfo.InvariantCulture)*TimeSpan.TicksPerHour+ 377Int64.Parse(minute, CultureInfo.InvariantCulture)*TimeSpan.TicksPerMinute+ 378Convert.ToInt64(Double.Parse(second+"."+fraction, CultureInfo.InvariantCulture)*(Double)TimeSpan.TicksPerSecond)

188protected abstract void WriteTimeSpan(TimeSpan val, String name);

313array = new TimeSpan[length]; 502internal static Type typeofTimeSpan = typeof(TimeSpan); 527internal static Type typeofTimeSpanArray = typeof(TimeSpan[]);

138internal void WriteTimeSpan(TimeSpan value) 762WriteTimeSpan((TimeSpan)value);

355internal TimeSpan ReadTimeSpan()

530DateTimeOffset managedUtcDTO = new DateTimeOffset(managedUtcTicks, TimeSpan.Zero);

286public CancellationTokenSource(TimeSpan delay) 425public void CancelAfter(TimeSpan delay)

482public bool Wait(TimeSpan timeout) 512public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)

453/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 454/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 464public bool Wait(TimeSpan timeout) 480/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 481/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 495public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)

132private static int MillisecondsTimeoutFromTimeSpan(TimeSpan timeout) 140public static bool TryEnter(Object obj, TimeSpan timeout) 155public static void TryEnter(Object obj, TimeSpan timeout, ref bool lockTaken) 206public static bool Wait(Object obj, TimeSpan timeout, bool exitContext) 216public static bool Wait(Object obj, TimeSpan timeout)

106public void AcquireReaderLock(TimeSpan timeout) 132public void AcquireWriterLock(TimeSpan timeout) 191public LockCookie UpgradeToWriterLock(TimeSpan timeout)

233/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 234/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 241public bool Wait(TimeSpan timeout) 260/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 261/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 271public bool Wait(TimeSpan timeout, CancellationToken cancellationToken) 530/// A <see cref="System.TimeSpan"/> that represents the number of milliseconds 531/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 547public Task<bool> WaitAsync(TimeSpan timeout) 557/// A <see cref="System.TimeSpan"/> that represents the number of milliseconds 558/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 568public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken cancellationToken)

209/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 210/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 224public void TryEnter(TimeSpan timeout, ref bool lockTaken)

216/// A <see cref="TimeSpan"/> that represents the number of milliseconds to wait, 223public static bool SpinUntil(Func<bool> condition, TimeSpan timeout)

3060/// A <see cref="System.TimeSpan"/> that represents the number of milliseconds to wait, or a <see 3061/// cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 3075public bool Wait(TimeSpan timeout) 4911/// A <see cref="System.TimeSpan"/> that represents the number of milliseconds to wait, or a <see 4912/// cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 4930public static bool WaitAll(Task[] tasks, TimeSpan timeout) 5336/// A <see cref="System.TimeSpan"/> that represents the number of milliseconds to wait, or a <see 5337/// cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 5355public static int WaitAny(Task[] tasks, TimeSpan timeout) 5797public static Task Delay(TimeSpan delay) 5819public static Task Delay(TimeSpan delay, CancellationToken cancellationToken)

698public bool Join(TimeSpan timeout) 729public static void Sleep(TimeSpan timeout)

1553TimeSpan timeout, 1572TimeSpan timeout,

21public static readonly TimeSpan InfiniteTimeSpan = new TimeSpan(0, 0, 0, 0, Timeout.Infinite);

866TimeSpan dueTime, 867TimeSpan period) 992public bool Change(TimeSpan dueTime, TimeSpan period)

202public virtual bool WaitOne (TimeSpan timeout, bool exitContext) 223public virtual bool WaitOne(TimeSpan timeout) 374TimeSpan timeout, 399public static bool WaitAll(WaitHandle[] waitHandles, TimeSpan timeout) 479TimeSpan timeout, 490public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout) 533TimeSpan timeout,

35, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable 66public static readonly TimeSpan Zero = new TimeSpan(0); 68public static readonly TimeSpan MaxValue = new TimeSpan(Int64.MaxValue); 69public static readonly TimeSpan MinValue = new TimeSpan(Int64.MinValue); 153public TimeSpan Add(TimeSpan ts) { 167public static int Compare(TimeSpan t1, TimeSpan t2) { 176if (!(value is TimeSpan)) 178long t = ((TimeSpan)value)._ticks; 185public int CompareTo(TimeSpan value) { 193public static TimeSpan FromDays(double value) { 197public TimeSpan Duration() { 198if (Ticks==TimeSpan.MinValue.Ticks) 205if (value is TimeSpan) { 206return _ticks == ((TimeSpan)value)._ticks; 211public bool Equals(TimeSpan obj) 216public static bool Equals(TimeSpan t1, TimeSpan t2) { 224public static TimeSpan FromHours(double value) { 228private static TimeSpan Interval(double value, int scale) { 239public static TimeSpan FromMilliseconds(double value) { 243public static TimeSpan FromMinutes(double value) { 247public TimeSpan Negate() { 248if (Ticks==TimeSpan.MinValue.Ticks) 254public static TimeSpan FromSeconds(double value) { 258public TimeSpan Subtract(TimeSpan ts) { 268public static TimeSpan FromTicks(long value) { 283public static TimeSpan Parse(String s) { 287public static TimeSpan Parse(String input, IFormatProvider formatProvider) { 290public static TimeSpan ParseExact(String input, String format, IFormatProvider formatProvider) { 293public static TimeSpan ParseExact(String input, String[] formats, IFormatProvider formatProvider) { 296public static TimeSpan ParseExact(String input, String format, IFormatProvider formatProvider, TimeSpanStyles styles) { 300public static TimeSpan ParseExact(String input, String[] formats, IFormatProvider formatProvider, TimeSpanStyles styles) { 304public static Boolean TryParse(String s, out TimeSpan result) { 307public static Boolean TryParse(String input, IFormatProvider formatProvider, out TimeSpan result) { 310public static Boolean TryParseExact(String input, String format, IFormatProvider formatProvider, out TimeSpan result) { 313public static Boolean TryParseExact(String input, String[] formats, IFormatProvider formatProvider, out TimeSpan result) { 316public static Boolean TryParseExact(String input, String format, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result) { 320public static Boolean TryParseExact(String input, String[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result) { 340public static TimeSpan operator -(TimeSpan t) { 341if (t._ticks==TimeSpan.MinValue._ticks) 346public static TimeSpan operator -(TimeSpan t1, TimeSpan t2) { 350public static TimeSpan operator +(TimeSpan t) { 354public static TimeSpan operator +(TimeSpan t1, TimeSpan t2) { 358public static bool operator ==(TimeSpan t1, TimeSpan t2) { 362public static bool operator !=(TimeSpan t1, TimeSpan t2) { 366public static bool operator <(TimeSpan t1, TimeSpan t2) { 370public static bool operator <=(TimeSpan t1, TimeSpan t2) { 374public static bool operator >(TimeSpan t1, TimeSpan t2) { 378public static bool operator >=(TimeSpan t1, TimeSpan t2) {

90public abstract TimeSpan GetUtcOffset(DateTime time); 133return CalculateUtcOffset(time, daylightTimes)!=TimeSpan.Zero; 196internal static TimeSpan CalculateUtcOffset(DateTime time, DaylightTime daylightTimes) { 198return TimeSpan.Zero; 202return TimeSpan.Zero; 248return TimeSpan.Zero;

65private TimeSpan m_baseUtcOffset; 165timeZone = CreateCustomTimeZone(c_utcId, TimeSpan.Zero, c_utcId, c_utcId); 237match = CreateCustomTimeZone(c_localId, TimeSpan.Zero, c_localId, c_localId); 264public TimeSpan offset; 266public OffsetAndRule(int year, TimeSpan offset, AdjustmentRule rule) { 303public TimeSpan BaseUtcOffset { 339public TimeSpan[] GetAmbiguousTimeOffsets(DateTimeOffset dateTimeOffset) { 359TimeSpan[] timeSpans = new TimeSpan[2]; 361TimeSpan actualUtcOffset = m_baseUtcOffset + rule.BaseUtcOffsetDelta; 364if (rule.DaylightDelta > TimeSpan.Zero) { 376public TimeSpan[] GetAmbiguousTimeOffsets(DateTime dateTime) { 407TimeSpan[] timeSpans = new TimeSpan[2]; 408TimeSpan actualUtcOffset = m_baseUtcOffset + rule.BaseUtcOffsetDelta; 411if (rule.DaylightDelta > TimeSpan.Zero) { 428public TimeSpan GetUtcOffset(DateTimeOffset dateTimeOffset) { 433public TimeSpan GetUtcOffset(DateTime dateTime) { 438internal static TimeSpan GetLocalUtcOffset(DateTime dateTime, TimeZoneInfoOptions flags) { 443internal TimeSpan GetUtcOffset(DateTime dateTime, TimeZoneInfoOptions flags) { 447private TimeSpan GetUtcOffset(DateTime dateTime, TimeZoneInfoOptions flags, CachedData cachedData) { 711TimeSpan destinationOffset = GetUtcOffsetFromUtc(utcDateTime, destinationTimeZone); 779TimeSpan sourceOffset = sourceTimeZone.BaseUtcOffset; 795sourceOffset += (sourceIsDaylightSavings ? sourceRule.DaylightDelta : TimeSpan.Zero /*FUTURE: sourceRule.StandardDelta*/); 1114TimeSpan baseUtcOffset, 1146TimeSpan baseUtcOffset, 1168TimeSpan baseUtcOffset, 1196TimeSpan baseUtcOffset, 1262m_baseUtcOffset = (TimeSpan)info.GetValue("BaseUtcOffset", typeof(TimeSpan)); 1343TimeSpan offset = GetUtcOffsetFromUtc(utcConverted, destinationTimeZone, out isAmbiguousLocalDst); 1379TimeSpan.Zero, // no daylight saving transition 1466TimeSpan delta = rule.DaylightDelta; 1510Boolean invalidAtStart = rule.DaylightDelta > TimeSpan.Zero; 1511startTime = rule.IsStartDateMarkerForBeginningOfYear() ? new DateTime(daylightTime.Start.Year, 1, 1, 0, 0, 0) : daylightTime.Start + (invalidAtStart ? rule.DaylightDelta : TimeSpan.Zero); /* FUTURE: - rule.StandardDelta; */ 1512endTime = rule.IsEndDateMarkerForEndOfYear() ? new DateTime(daylightTime.End.Year + 1, 1, 1, 0, 0, 0).AddTicks(-1) : daylightTime.End + (invalidAtStart ? -rule.DaylightDelta : TimeSpan.Zero); 1538static private Boolean GetIsDaylightSavingsFromUtc(DateTime time, Int32 Year, TimeSpan utc, AdjustmentRule rule, out Boolean isAmbiguousLocalDst, TimeZoneInfo zone) { 1546TimeSpan offset = utc + rule.BaseUtcOffsetDelta; /* FUTURE: + rule.StandardDelta; */ 1683if (rule == null || rule.DaylightDelta == TimeSpan.Zero) { 1691if (rule.DaylightDelta > TimeSpan.Zero) { 1747if (rule == null || rule.DaylightDelta == TimeSpan.Zero) { 1755if (rule.DaylightDelta < TimeSpan.Zero) { 1830return CreateCustomTimeZone(c_localId, TimeSpan.Zero, c_localId, c_localId); 1929return CreateCustomTimeZone(c_localId, TimeSpan.Zero, c_localId, c_localId); 1993static private TimeSpan GetUtcOffset(DateTime time, TimeZoneInfo zone, TimeZoneInfoOptions flags) { 1994TimeSpan baseOffset = zone.BaseUtcOffset; 2002baseOffset += (isDaylightSavings ? rule.DaylightDelta : TimeSpan.Zero /* FUTURE: rule.StandardDelta */); 2017static private TimeSpan GetUtcOffsetFromUtc(DateTime time, TimeZoneInfo zone) { 2022static private TimeSpan GetUtcOffsetFromUtc(DateTime time, TimeZoneInfo zone, out Boolean isDaylightSavings) { 2028static internal TimeSpan GetDateTimeNowUtcOffsetFromUtc(DateTime time, out Boolean isAmbiguousLocalDst) { 2032TimeSpan baseOffset; 2042baseOffset += (isDaylightSavings ? match.rule.DaylightDelta : TimeSpan.Zero /* FUTURE: rule.StandardDelta */); 2052static internal TimeSpan GetUtcOffsetFromUtc(DateTime time, TimeZoneInfo zone, out Boolean isDaylightSavings, out Boolean isAmbiguousLocalDst) { 2055TimeSpan baseOffset = zone.BaseUtcOffset; 2083baseOffset += (isDaylightSavings ? rule.DaylightDelta : TimeSpan.Zero /* FUTURE: rule.StandardDelta */); 2915static internal Boolean UtcOffsetOutOfRange(TimeSpan offset) { 2930TimeSpan baseUtcOffset, 2947if (baseUtcOffset.Ticks % TimeSpan.TicksPerMinute != 0) { 3010private TimeSpan m_daylightDelta; 3013private TimeSpan m_baseUtcOffsetDelta; // delta from the default Utc offset (utcOffset = defaultUtcOffset + m_baseUtcOffsetDelta) 3029public TimeSpan DaylightDelta { 3049internal TimeSpan BaseUtcOffsetDelta { 3057return this.DaylightDelta != TimeSpan.Zero || 3096TimeSpan daylightDelta, 3110rule.m_baseUtcOffsetDelta = TimeSpan.Zero; 3118TimeSpan daylightDelta, 3121TimeSpan baseUtcOffsetDelta) { 3158TimeSpan daylightDelta, 3186if (daylightDelta.Ticks % TimeSpan.TicksPerMinute != 0) { 3191if (dateStart.TimeOfDay != TimeSpan.Zero) { 3196if (dateEnd.TimeOfDay != TimeSpan.Zero) { 3243m_daylightDelta = (TimeSpan)info.GetValue("DaylightDelta", typeof(TimeSpan)); 3247object o = info.GetValueNoThrow("BaseUtcOffsetDelta", typeof(TimeSpan)); 3249m_baseUtcOffsetDelta = (TimeSpan) o; 3462if (timeOfDayYear != 1 || timeOfDayMonth != 1 || timeOfDayDay != 1 || (timeOfDay.Ticks % TimeSpan.TicksPerMillisecond != 0)) { 3601if (rule.BaseUtcOffsetDelta != TimeSpan.Zero) { // Serialize it only when BaseUtcOffsetDelta has a value to reduce the impact of adding rule.BaseUtcOffsetDelta 3623TimeSpan baseUtcOffset = s.GetNextTimeSpanValue(false); 3898private TimeSpan GetNextTimeSpanValue(Boolean canEndWithoutSeparator) { 3989TimeSpan daylightDelta = GetNextTimeSpanValue(false); 3992TimeSpan baseUtcOffsetDelta = TimeSpan.Zero;

108typeof(TimeSpan),

229else if (typeof(TimeSpan).IsAssignableFrom(type))

5503case KnownElements.TimeSpan: t = typeof(TimeSpan); break;

219TimeSpan.FromMinutes(3),

25private TimeSpan _timeSpan; 32public Duration(TimeSpan timeSpan) 34if (timeSpan < TimeSpan.Zero) 58public static implicit operator Duration(TimeSpan timeSpan) 60if (timeSpan < TimeSpan.Zero) 398public TimeSpan TimeSpan

84TimeSpan duration = TimeSpan.Zero; 89duration = (TimeSpan)_timeSpanConverter.ConvertFrom(td, cultureInfo, value); 123mi = typeof(Duration).GetConstructor(new Type[] { typeof(TimeSpan) });

203_inputTimer.Interval = TimeSpan.FromMilliseconds(125);

617private const Int64 ThrottleTimeout = TimeSpan.TicksPerSecond * 5; // 5 seconds (in 100ns units) of no activity will throttle down

279_inertiaTimer.Interval = TimeSpan.FromMilliseconds(15);

327_restoreDT.Interval = TimeSpan.FromMilliseconds(100); 1084TimeSpan delta = DateTime.Now - _lastWakeOrUnlockEvent;

298TimeSpan loopDuration = (DateTime.UtcNow - loopStartTime); 366TimeSpan loopDuration = (DateTime.UtcNow - loopStartTime);

136_nextTickNeededTime = TimeSpan.Zero; 279public TimeSpan? CurrentTime 500protected virtual TimeSpan GetCurrentTimeCore() 504return _currentTime.HasValue ? _currentTime.Value : TimeSpan.Zero; 535protected TimeSpan CurrentGlobalTime 541return TimeSpan.Zero; 622if (!_resolvedDuration.HasTimeSpan || _resolvedDuration.TimeSpan > TimeSpan.Zero) 698TimeSpan beginTime, TimeSpan? endTime, 707TimeSpan beginTime, TimeSpan endTime, Duration period, 720TimeSpan? lastCurrentTime = _currentTime; 774InternalSeek(TimeSpan.Zero); 869internal void InternalSeek(TimeSpan destination) 892internal void InternalSeekAlignedToLastTick(TimeSpan destination) 978TimeSpan? effectiveDuration; 1252TimeSpan? expirationTime; 1371internal TimeSpan? InternalNextTickNeededTime 1882TimeSpan previewParentTime = CurrentGlobalTime; 1939TimeSpan nextDesiredTick = InternalNextTickNeededTime == TimeSpan.Zero ? _rootData.CurrentAdjustedGlobalTime 1952private bool ComputeCurrentIteration(TimeSpan parentTime, double parentSpeed, 1953TimeSpan? expirationTime, 1954out TimeSpan localProgress) 1968TimeSpan beginTimeForOffsetComputation = _currentIterationBeginTime.HasValue ? _currentIterationBeginTime.Value 1970TimeSpan offsetFromBegin = MultiplyTimeSpan(parentTime - beginTimeForOffsetComputation, _appliedSpeedRatio); 1977if (_currentDuration.TimeSpan == TimeSpan.Zero) // We must be post-filling if we have gotten here 1982localProgress = TimeSpan.Zero; 1985_currentTime = TimeSpan.Zero; 2084TimeSpan optimizedOffsetFromBegin; 2107localProgress = TimeSpan.FromTicks(offsetFromBegin.Ticks % _currentDuration.TimeSpan.Ticks); 2112if ((localProgress == TimeSpan.Zero) 2136if (localProgress == TimeSpan.Zero) 2143InternalNextTickNeededTime = TimeSpan.Zero; 2159TimeSpan timeUntilNextBoundary; 2161if (localProgress == TimeSpan.Zero) // We are currently exactly at a boundary 2167TimeSpan decelBegin = MultiplyTimeSpan(_currentDuration.TimeSpan, 1.0 - _timeline.DecelerationRatio); 2172TimeSpan accelEnd = MultiplyTimeSpan(_currentDuration.TimeSpan, _timeline.AccelerationRatio); 2176TimeSpan proposedNextTickTime = CurrentGlobalTime + timeUntilNextBoundary; 2203private void ComputeCurrentIterationWithGrow(TimeSpan parentTime, TimeSpan? expirationTime, 2204out TimeSpan localProgress, out int newIteration) 2212TimeSpan offsetFromBegin = MultiplyTimeSpan(parentTime - _currentIterationBeginTime.Value, _appliedSpeedRatio); 2225localProgress = TimeSpan.FromTicks(offsetOnLaterIterations % _resolvedDuration.TimeSpan.Ticks); 2269private bool ComputeCurrentState(TimeSpan? expirationTime, ref TimeSpan parentTime, double parentSpeed, bool isInTick) 2313InternalNextTickNeededTime = TimeSpan.Zero; // We need ticks immediately 2351private bool ComputeCurrentTime(TimeSpan localProgress, out double localSpeed) 2361Debug.Assert(_currentDuration.TimeSpan > TimeSpan.Zero, "ComputeCurrentTime was entered with _currentDuration <= 0"); 2397InternalNextTickNeededTime = TimeSpan.Zero; 2421InternalNextTickNeededTime = TimeSpan.Zero; 2425_currentTime = TimeSpan.FromTicks((long)((t * durationInTicks) + 0.5)); 2486private TimeSpan? ComputeEffectiveDuration() 2496TimeSpan? effectiveDuration; 2499if (_currentDuration.HasTimeSpan && _currentDuration.TimeSpan == TimeSpan.Zero) 2502effectiveDuration = TimeSpan.Zero; 2508effectiveDuration = TimeSpan.Zero; 2532TimeSpan previousIterationDuration = TimeSpan.Zero; 2559effectiveDuration = TimeSpan.FromTicks((long)(presentAndFutureDuration / _appliedSpeedRatio + 0.5)) + previousIterationDuration; 2578private void ComputeEvents(TimeSpan? expirationTime, 2600postFillDuration = TimeSpan.Zero; // There is no reachable postfill zone because the active period is infinite 2636else if (postFillDuration != TimeSpan.Zero && // Our active period is finite and we have fill behavior 2660private bool ComputeExpirationTime(out TimeSpan? expirationTime) 2665TimeSpan? effectiveDuration; 2686expirationTime += TimeSpan.FromMilliseconds(50); // This compensation is roughly one frame of video 2816TimeSpan? endOfActivePeriod) 2824TimeSpan relativeBeginTime = _currentIterationBeginTime.HasValue ? _currentIterationBeginTime.Value : _beginTime.Value; 2847TimeSpan? endOfActivePeriod, 2851TimeSpan relativeBeginTime = _currentIterationBeginTime.HasValue ? _currentIterationBeginTime.Value : _beginTime.Value; 2898TimeSpan? parentTime; // Computed parent-local time 2899TimeSpan? expirationTime; // Computed expiration time with respect to repeat behavior and resolved duration; 2900TimeSpan localProgress; // Computed time inside simple duration 2902TimeSpan parentTimeValue; 3012private bool ComputeNextTickNeededTime(TimeSpan? expirationTime, 3013TimeSpan parentTime, double parentSpeed) 3023InternalNextTickNeededTime = IsInteractivelyPaused ? TimeSpan.Zero : (TimeSpan?)null; 3028TimeSpan? timeUntilNextBoundary = null; 3040TimeSpan timeUntilBegin = MultiplyTimeSpan(_beginTime.Value - parentTime, invertedParentSpeed); 3049if (timeUntilBegin >= TimeSpan.Zero) 3056TimeSpan timeUntilExpiration = MultiplyTimeSpan(expirationTime.Value - parentTime, invertedParentSpeed); 3058if (timeUntilExpiration >= TimeSpan.Zero && 3086private bool ComputeParentParameters(out TimeSpan? parentTime, out double? parentSpeed, 3104InternalNextTickNeededTime = TimeSpan.Zero; // When TimeManager wakes up, we will need an update 3174TimeSpan currentParentTimePT) 3199TimeSpan relativeBeginTimePT = _currentIterationBeginTime.HasValue ? _currentIterationBeginTime.Value : _beginTime.Value; 3200TimeSpan previewCurrentOffsetPT = currentParentTimePT - relativeBeginTimePT; // This is our time offset (not yet scaled by speed) 3201TimeSpan previewCurrentTimeLT = MultiplyTimeSpan(previewCurrentOffsetPT, _appliedSpeedRatio); // This is what our time would be 3211TimeSpan? expirationTimePT; 3217TimeSpan ourSyncTimeST = (_syncData.SyncClock == this) ? 3222TimeSpan? syncClockEffectiveDurationST = _syncData.SyncClockEffectiveDuration; 3231_syncData.PreviousSyncClockTime = TimeSpan.FromTicks(ourSyncTimeST.Ticks % syncClockDuration.TimeSpan.Ticks); 3237_syncData.PreviousRepeatTime = TimeSpan.Zero; 3254TimeSpan? previousSyncParentTimeSPT = (_syncData.SyncClock == this) ? 3267TimeSpan timeIntoSyncPeriodPT = previewCurrentOffsetPT; 3290_syncData.PreviousSyncClockTime = TimeSpan.Zero; 3291_syncData.PreviousRepeatTime = TimeSpan.Zero; 3308TimeSpan currentParentTimePT, double currentParentSpeed) 3328TimeSpan previousParentTimePT = parentIntervalCollection.IsEmptyOfRealPoints ? currentParentTimePT 3330TimeSpan parentElapsedTimePT = currentParentTimePT - previousParentTimePT; 3333TimeSpan ourProjectedElapsedTimeLT = MultiplyTimeSpan(parentElapsedTimePT, _appliedSpeedRatio); 3335TimeSpan syncTimeST = _syncData.SyncClock.GetCurrentTimeCore(); 3336TimeSpan syncElapsedTimeST = syncTimeST - _syncData.PreviousSyncClockTime; // Elapsed from last tick 3338if (syncElapsedTimeST > TimeSpan.Zero) // Only store the last value if it is greater than 3342TimeSpan? effectiveDurationST = _syncData.SyncClockEffectiveDuration; 3349_syncData.PreviousRepeatTime = TimeSpan.Zero; 3361_syncData.PreviousSyncClockTime = TimeSpan.Zero; 3371syncElapsedTimeST = TimeSpan.Zero; 3375TimeSpan syncElapsedTimeLT = (_syncData.SyncClock == this) 3380TimeSpan parentTimeSlipPT = parentElapsedTimePT - DivideTimeSpan(syncElapsedTimeLT, _appliedSpeedRatio); 3530private TimeSpan GetCurrentDesiredFrameTime(TimeSpan time) 3536private TimeSpan GetDesiredFrameTime(TimeSpan time, int frameOffset) 3545return TimeSpan.FromTicks(desiredFrameTick); 3549private TimeSpan GetNextDesiredFrameTime(TimeSpan time) 3680private TimeSpan DivideTimeSpan(TimeSpan timeSpan, double factor) 3683return TimeSpan.FromTicks((long)(((double)timeSpan.Ticks) / factor + 0.5)); 3699private static TimeSpan MultiplyTimeSpan(TimeSpan timeSpan, double factor) 3701return TimeSpan.FromTicks((long)(factor * (double)timeSpan.Ticks + 0.5)); 3711subtree.Current.InternalNextTickNeededTime = TimeSpan.Zero; 3715while (current != null && current.InternalNextTickNeededTime != TimeSpan.Zero) 3717current.InternalNextTickNeededTime = TimeSpan.Zero; 4059internal TimeSpan? SyncClockEffectiveDuration 4081internal TimeSpan PreviousSyncClockTime 4087internal TimeSpan PreviousRepeatTime 4093internal TimeSpan SyncClockBeginTime 4108private TimeSpan? _syncClockEffectiveDuration; // This reflects RepeatBehavior (local coordinates) 4110private TimeSpan? _syncClockBeginTime; 4111private TimeSpan _previousSyncClockTime; 4112private TimeSpan _previousRepeatTime; // How many complete iterations we already have done 4124internal TimeSpan CurrentAdjustedGlobalTime 4142internal TimeSpan LastAdjustedGlobalTime 4151internal TimeSpan? PendingSeekDestination 4166private TimeSpan _currentAdjustedGlobalTime; 4167private TimeSpan _lastAdjustedGlobalTime; 4168private TimeSpan? _pendingSeekDestination; 4435private TimeSpan? _currentTime; // Precalculated current global time 4450internal TimeSpan? _beginTime; 4456private TimeSpan? _currentIterationBeginTime; 4459internal TimeSpan? _nextTickNeededTime = null; 4507static Int64 s_TimeSpanTicksPerSecond = TimeSpan.FromSeconds(1).Ticks;

163public void Seek(TimeSpan offset, TimeSeekOrigin origin) 193if (offset < TimeSpan.Zero) 205public void SeekAlignedToLastTick(TimeSpan offset, TimeSeekOrigin origin) 235if (offset < TimeSpan.Zero)

146if ((!duration.HasTimeSpan || duration.TimeSpan > TimeSpan.Zero) 257TimeSpan? previousTickNeededTime = InternalNextTickNeededTime; 346Duration currentDuration = TimeSpan.Zero; 378childEndOfActivePeriod += TimeSpan.FromMilliseconds(50); // This compensation is roughly one frame of video 585TimeSpan beginTime, TimeSpan? endTime, 599TimeSpan beginTime, TimeSpan endTime, Duration period,

355TimeSpan currentTime = animationClock.CurrentTime.Value; 418TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 422TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 423TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 570private TimeSpan LargestTimeSpanKeyTime 575TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 603return TimeSpan.FromSeconds(1.0); 643TimeSpan calculationDuration = TimeSpan.Zero; 673_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 714_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 771TimeSpan blockBeginTime = TimeSpan.Zero; 789TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 792TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 854TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 896TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 907_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 418TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 422TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 423TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 570private TimeSpan LargestTimeSpanKeyTime 575TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 603return TimeSpan.FromSeconds(1.0); 643TimeSpan calculationDuration = TimeSpan.Zero; 673_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 714_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 771TimeSpan blockBeginTime = TimeSpan.Zero; 789TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 792TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 854TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 896TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 907_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 418TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 422TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 423TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 570private TimeSpan LargestTimeSpanKeyTime 575TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 603return TimeSpan.FromSeconds(1.0); 643TimeSpan calculationDuration = TimeSpan.Zero; 673_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 714_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 771TimeSpan blockBeginTime = TimeSpan.Zero; 789TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 792TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 854TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 896TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 907_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 418TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 422TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 423TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 570private TimeSpan LargestTimeSpanKeyTime 575TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 603return TimeSpan.FromSeconds(1.0); 643TimeSpan calculationDuration = TimeSpan.Zero; 673_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 714_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 771TimeSpan blockBeginTime = TimeSpan.Zero; 789TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 792TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 854TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 896TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 907_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 418TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 422TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 423TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 570private TimeSpan LargestTimeSpanKeyTime 575TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 603return TimeSpan.FromSeconds(1.0); 643TimeSpan calculationDuration = TimeSpan.Zero; 673_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 714_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 771TimeSpan blockBeginTime = TimeSpan.Zero; 789TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 792TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 854TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 896TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 907_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

56TimeSpan CurrentTime

53public static KeyTime FromTimeSpan(TimeSpan timeSpan) 55if (timeSpan < TimeSpan.Zero) 125if ((TimeSpan)keyTime1._value != (TimeSpan)keyTime2._value) 223public static implicit operator KeyTime(TimeSpan timeSpan) 238public TimeSpan TimeSpan 244return (TimeSpan)_value;

117TimeSpan timeSpanValue = (TimeSpan)TypeDescriptor.GetConverter( 118typeof(TimeSpan)).ConvertFrom( 166mi = typeof(KeyTime).GetMethod("FromTimeSpan", new Type[] { typeof(TimeSpan) }); 209typeof(TimeSpan)).ConvertTo(

41public ParallelTimeline(TimeSpan? beginTime) 55public ParallelTimeline(TimeSpan? beginTime, Duration duration) 72public ParallelTimeline(TimeSpan? beginTime, Duration duration, RepeatBehavior repeatBehavior) 92Duration simpleDuration = TimeSpan.Zero;

40private TimeSpan _repeatDuration; 68public RepeatBehavior(TimeSpan duration) 149public TimeSpan Duration

98TimeSpan timeSpanValue = (TimeSpan)TypeDescriptor.GetConverter(typeof(TimeSpan)).ConvertFrom(td, cultureInfo, stringValue); 146mi = typeof(RepeatBehavior).GetConstructor(new Type[] { typeof(TimeSpan) });

13internal TimeSpan _resolvedKeyTime;

128private TimeIntervalCollection(TimeSpan point) 137private void InitializePoint(TimeSpan point) 154private TimeIntervalCollection(TimeSpan point, bool includePoint) 179private TimeIntervalCollection(TimeSpan from, bool includeFrom, TimeSpan to, bool includeTo) 253internal TimeSpan FirstNodeTime 271internal TimeIntervalCollection SlipBeginningOfConnectedInterval(TimeSpan slipTime) 273if (slipTime == TimeSpan.Zero) // The no-op case 300internal TimeIntervalCollection SetBeginningOfConnectedInterval(TimeSpan beginTime) 323static internal TimeIntervalCollection CreatePoint(TimeSpan time) 331static internal TimeIntervalCollection CreateClosedOpenInterval(TimeSpan from, TimeSpan to) 339static internal TimeIntervalCollection CreateOpenClosedInterval(TimeSpan from, TimeSpan to) 347static internal TimeIntervalCollection CreateInfiniteClosedInterval(TimeSpan from) 404internal bool Contains(TimeSpan time) 534internal bool Intersects(TimeSpan from, TimeSpan to) 542TimeSpan temp = from; 859internal bool IntersectsPeriodicCollection(TimeSpan beginTime, Duration period, double appliedSpeedRatio, 866|| (period == TimeSpan.Zero) // The PTIC has no nonzero period, we define such intersections nonexistent 988internal bool IntersectsMultiplePeriods(TimeSpan beginTime, Duration period, double appliedSpeedRatio) 993|| (period == TimeSpan.Zero) // The PTIC has no nonzero period, we define such intersections nonexistent 1011TimeSpan lastNodeTime = _nodeTime[_count - 1]; 1034TimeSpan beginTime, TimeSpan endTime, Duration period, 1043Debug.Assert(!period.HasTimeSpan || period.TimeSpan > TimeSpan.Zero || beginTime == endTime); // Check the consistency of degenerate case where simple duration is zero; expiration time should equal beginTime 1108projection.InitializePoint(TimeSpan.FromTicks(outputInTicks)); 1156TimeSpan beginTime, Nullable<TimeSpan> endTime, 1168Debug.Assert(endTime.HasValue || fillDuration == TimeSpan.Zero); // Either endTime is finite, or it's infinite hence we cannot have any fill zone 1169Debug.Assert(!period.HasTimeSpan || period.TimeSpan > TimeSpan.Zero || (endTime.HasValue && beginTime == endTime)); // Check the consistency of degenerate case where simple duration is zero; expiration time should equal beginTime 1182&& _nodeIsPoint[_count - 1] && (endTime > beginTime || fillDuration.TimeSpan > TimeSpan.Zero)))); // ...we may have a point intersection with the stopped zone 1188projection.InitializePoint(TimeSpan.Zero); 1192bool includeFillPeriod = !fillDuration.HasTimeSpan || fillDuration.TimeSpan > TimeSpan.Zero; // This variable represents whether we have a non-zero fill zone 1201Nullable<TimeSpan> activeDuration; 1242TimeSpan beginTime, Nullable<TimeSpan> endTime, bool includeFillPeriod, double speedRatio) 1263projection.CurrentNodeTime = TimeSpan.Zero; 1276projection.CurrentNodeTime = TimeSpan.FromTicks((long)(speedRatio * timeOffset)); 1294projection.CurrentNodeTime = TimeSpan.FromTicks((long)(speedRatio * timeOffset)); 1311private void ProjectionFold(ref TimeIntervalCollection projection, Nullable<TimeSpan> activeDuration, 1319Debug.Assert(CurrentNodeTime >= TimeSpan.Zero); // Verify that we are already clipped 1354private void ProjectionFoldPoint(ref TimeIntervalCollection projection, Nullable<TimeSpan> activeDuration, 1383projection.MergePoint(TimeSpan.FromTicks(currentProjection)); 1397private bool ProjectionFoldInterval(ref TimeIntervalCollection projection, Nullable<TimeSpan> activeDuration, 1448projection.MergeInterval(TimeSpan.Zero, true, 1449TimeSpan.FromTicks(currentProjection), includeTime); 1454projection.MergeInterval(TimeSpan.FromTicks(currentProjection), includeTime, 1455TimeSpan.FromTicks(periodInTicks), true); 1465projection.MergeInterval(TimeSpan.Zero, true, 1466TimeSpan.FromTicks(clippedTime), NextNodeIsPoint); 1473projection.MergeInterval(TimeSpan.FromTicks(clippedTime), NextNodeIsPoint, 1474TimeSpan.FromTicks(periodInTicks), true); 1485projection.MergeInterval(TimeSpan.FromTicks(currentProjection - intervalLength), NextNodeIsPoint, 1486TimeSpan.FromTicks(currentProjection), CurrentNodeIsPoint); 1490projection.MergeInterval(TimeSpan.FromTicks(currentProjection), CurrentNodeIsPoint, 1491TimeSpan.FromTicks(currentProjection + intervalLength), NextNodeIsPoint); 1507projection._nodeTime[0] = TimeSpan.Zero; 1511projection._nodeTime[1] = TimeSpan.FromTicks(periodInTicks); 1521projection.MergeInterval(TimeSpan.FromTicks(currentProjection), CurrentNodeIsPoint, 1522TimeSpan.FromTicks(periodInTicks), false); 1525projection.MergeInterval(TimeSpan.Zero, true, 1526TimeSpan.FromTicks(intervalLength - timeBeforeNextPeriod), NextNodeIsPoint); 1532projection.MergePoint(TimeSpan.FromTicks(periodInTicks)); 1536projection.MergePoint(TimeSpan.Zero); 1544projection.MergeInterval(TimeSpan.FromTicks(currentProjection), CurrentNodeIsPoint, 1545TimeSpan.FromTicks(currentProjection + intervalLength), NextNodeIsPoint); 1558private void MergePoint(TimeSpan point) 1613private void MergeInterval(TimeSpan from, bool includeFrom, 1614TimeSpan to, bool includeTo) 1784_nodeTime = new TimeSpan[requiredCapacity]; 1795TimeSpan[] newNodeTime = new TimeSpan[newCapacity]; 1829TimeSpan accelEnd = TimeSpan.FromTicks((long)(dpPeriod * accelRatio)); 1830TimeSpan decelStart = TimeSpan.FromTicks(periodInTicks - (long)(dpPeriod * decelRatio)); 1840_nodeTime[_current] = TimeSpan.FromTicks((long)(halfMaxRate * inversePeriod * t * t / accelRatio)); 1848_nodeTime[_current] = TimeSpan.FromTicks((long)(halfMaxRate * (2 * t - (accelRatio * dpPeriod)))); 1856_nodeTime[_current] = TimeSpan.FromTicks(periodInTicks - (long)(halfMaxRate * inversePeriod * t * t / decelRatio)); 2129private int Locate(TimeSpan time) 2204private TimeSpan CurrentNodeTime 2246private TimeSpan NextNodeTime 2291private TimeSpan[] _nodeTime; // An interval's begin time

67protected Timeline(Nullable<TimeSpan> beginTime) 82protected Timeline(Nullable<TimeSpan> beginTime, Duration duration) 101protected Timeline(Nullable<TimeSpan> beginTime, Duration duration, RepeatBehavior repeatBehavior) 285typeof(TimeSpan?), 288(TimeSpan?)TimeSpan.Zero, 302public TimeSpan? BeginTime 306return (TimeSpan?)GetValue(BeginTimeProperty);

41protected TimelineGroup(Nullable<TimeSpan> beginTime) 55protected TimelineGroup(Nullable<TimeSpan> beginTime, Duration duration) 72protected TimelineGroup(Nullable<TimeSpan> beginTime, Duration duration, RepeatBehavior repeatBehavior)

129public Nullable<TimeSpan> CurrentTime 233if (GetNextTickNeeded() >= TimeSpan.Zero) 284TimeSpan offsetTime = TimeSpan.FromMilliseconds((double)offset); 314_lastTickTime = TimeSpan.Zero; 318_globalTime = TimeSpan.Zero; 388EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnimation | EventTrace.Keyword.KeywordPerf, EventTrace.Event.WClientTimeManagerTickBegin, (_startTime + _globalTime).Ticks / TimeSpan.TicksPerMillisecond); 462TimeSpan IClock.CurrentTime 466return TimeSpan.FromTicks(DateTime.Now.Ticks); 488public TimeSpan CurrentTime 503private TimeSpan _currentTime; 563internal TimeSpan GetCurrentGlobalTime() 571return TimeSpan.Zero; 596return TimeSpan.Zero; 728internal TimeSpan InternalCurrentGlobalTime 773internal TimeSpan GetNextTickNeeded() 781TimeSpan? nextTickNeededTime = _timeManagerClock.InternalNextTickNeededTime; 786TimeSpan timeManagerCurrentTime = _systemClock.CurrentTime - _startTime; 789TimeSpan nextTickNeededTimeFromCurrentTime = nextTickNeededTime.Value - timeManagerCurrentTime; 791if (nextTickNeededTimeFromCurrentTime <= TimeSpan.Zero) 795return TimeSpan.Zero; 805return TimeSpan.FromTicks(-1); 811return TimeSpan.FromTicks(-1); 818internal TimeSpan LastTickDelta 829internal TimeSpan LastTickTime 910private TimeSpan _globalTime; 911private TimeSpan _startTime; 912private TimeSpan _lastTickTime; 913private TimeSpan _pauseTime;

295TimeSpan.FromMilliseconds(1000),

277TimeSpan timeoutSpan; 284timeoutSpan = TimeSpan.FromMilliseconds(-1); 702AcquireBackBuffer(TimeSpan.Zero, false); 1141private bool AcquireBackBuffer(TimeSpan timeout, bool waitForCopy)

90protected override TimeSpan GetCurrentTimeCore() 112_mediaPlayer.SetPosition(TimeSpan.FromTicks(0)); 142TimeSpan? currentTimeProperty = this.CurrentTime; 143TimeSpan currentTimeValue = currentTimeProperty.HasValue ? currentTimeProperty.Value : TimeSpan.Zero;

94return (long)(TimeSpan.TicksPerSecond * (counts / _perfCounterFreq) + (TimeSpan.TicksPerSecond * (counts % _perfCounterFreq)) / _perfCounterFreq); 105return (long)(_perfCounterFreq * (ticks / TimeSpan.TicksPerSecond) + (_perfCounterFreq * (ticks % TimeSpan.TicksPerSecond)) / TimeSpan.TicksPerSecond); 219_estimatedNextPresentationTime = TimeSpan.FromTicks(CountsToTicks(_lastPresentationTime)); 576private void ScheduleNextRenderOp(TimeSpan minimumDelay) 592TimeSpan nextTickNeeded = TimeSpan.Zero; 608if (nextTickNeeded >= TimeSpan.Zero) 610nextTickNeeded = TimeSpan.FromTicks(Math.Max(nextTickNeeded.Ticks, minimumDelay.Ticks)); 619if (nextTickNeeded > TimeSpan.FromSeconds(1)) 630else if (nextTickNeeded > TimeSpan.Zero) 641_promoteRenderOpToRender.Interval = TimeSpan.FromSeconds(1); 645else if (nextTickNeeded == TimeSpan.Zero) 704long earliestWakeupTicks = currentTicks + TicksUntilNextVsync(currentTicks) + TimeSpan.TicksPerMillisecond; 705_estimatedNextVSyncTimer.Interval = TimeSpan.FromTicks(earliestWakeupTicks - currentTicks); 712_estimatedNextVSyncTimer.Interval = TimeSpan.FromMilliseconds(17); 758TimeSpan presentationDelay = TimeSpan.Zero; 953return TimeSpan.TicksPerSecond / _animationRenderRate; 1118TimeSpan IClock.CurrentTime 1210if ((nextPresentationTicks - _estimatedNextPresentationTime.Ticks) * _animationRenderRate > TimeSpan.FromMilliseconds(500).Ticks) 1213_estimatedNextPresentationTime = TimeSpan.FromTicks(nextPresentationTicks); 1218_estimatedNextPresentationTime = TimeSpan.FromTicks(countsTicks); 1223_estimatedNextPresentationTime = TimeSpan.FromTicks(countsTicks); 1963ScheduleNextRenderOp(TimeSpan.Zero); 2645timer.Interval = TimeSpan.FromTicks(earliestWakeupTicks - currentTicks); 2657ScheduleNextRenderOp(TimeSpan.Zero); 2840private TimeSpan _timeDelay = TimeSpan.FromMilliseconds(10); 2986private TimeSpan _estimatedNextPresentationTime; 3014private const long MaxTicksWithoutInput = TimeSpan.TicksPerSecond / 2;

280public TimeSpan Position 914TimeSpan value

504return new Duration(TimeSpan.FromTicks(mediaLength)); 512internal TimeSpan Position 773SetPosition(TimeSpan.Zero); 812Position = TimeSpan.FromTicks(0); 1139internal void SetPosition(TimeSpan value) 1154private TimeSpan GetPosition() 1160return TimeSpan.FromTicks(position);

74public MediaTimeline(Nullable<TimeSpan> beginTime) : this() 84public MediaTimeline(Nullable<TimeSpan> beginTime, Duration duration) 97public MediaTimeline(Nullable<TimeSpan> beginTime, Duration duration, RepeatBehavior repeatBehavior)

16internal RenderingEventArgs(TimeSpan renderingTime) 25public TimeSpan RenderingTime 33private TimeSpan _renderingTime;

833long timeSpan = (dtStop.Ticks - dtStart.Ticks) / TimeSpan.TicksPerMillisecond;

27private TimeSpan _timespan; 31internal SponsorHelper(ILease lease, TimeSpan timespan) 40TimeSpan ISponsor.Renewal(ILease lease)

69_position = new SettableState<TimeSpan>(new TimeSpan(0)); 186internal TimeSpan Position 212TimeSpan position 873SettableState<TimeSpan> _position;

3277internal static TimeSpan AutoScrollTimeout 3285return TimeSpan.FromMilliseconds(MS.Win32.SafeNativeMethods.GetDoubleClickTime() * 0.8);

536public TimeSpan Position

2649timer.Interval = TimeSpan.FromMilliseconds(SystemParameters.MenuShowDelay);

331ToolTipTimer.Interval = TimeSpan.FromMilliseconds(ToolTipService.GetInitialShowDelay(o)); 525ToolTipTimer.Interval = TimeSpan.FromMilliseconds(ToolTipService.GetShowDuration(o)); 595ToolTipTimer.Interval = TimeSpan.FromMilliseconds(ToolTipService.GetBetweenShowDelay(o));

1684_asyncDestroy.Interval = animating ? AnimationDelayTime : TimeSpan.Zero; 2924internal static TimeSpan AnimationDelayTime = new TimeSpan(0, 0, 0, 0, AnimationDelay);

127_timer.Interval = TimeSpan.FromMilliseconds(Delay); 150TimeSpan interval = TimeSpan.FromMilliseconds(Interval);

237TimeSpan translateTime = TimeSpan.FromSeconds(((int)(endPos - startPos) / 200.0)); // travel at 200px /second 238TimeSpan pauseTime = TimeSpan.FromSeconds(1.0); // pause 1 second between animations 239TimeSpan startTime; 246startTime = TimeSpan.FromSeconds(-1*(_glow.Margin.Left-startPos)/200.0); 251startTime = TimeSpan.Zero; 261animation.KeyFrames.Add(new LinearThicknessKeyFrame(new Thickness(startPos,0,0,0), TimeSpan.FromSeconds(0)));

719private TimeSpan TimeOut 730return TimeSpan.FromMilliseconds(SafeNativeMethods.GetDoubleClickTime() * 2);

8722_cleanupDelay.Interval = TimeSpan.FromMilliseconds(500.0);

2743timer.Interval = TimeSpan.FromMilliseconds(delay);

912Duration blinkDuration = new Duration(TimeSpan.FromMilliseconds(blinkInterval * 2));

539_mouseSelectionState.Timer.Interval = TimeSpan.FromMilliseconds(Math.Max(SystemParameters.MenuShowDelay, 200));

125lease.InitialLeaseTime = TimeSpan.Zero; // infinite -- never expire

755case 663: t = () => typeof(TimeSpan); break;

10259typeof(System.TimeSpan),

6207case KnownElements.TimeSpan: t = typeof(System.TimeSpan); break;

355TimeSpan currentTime = animationClock.CurrentTime.Value; 429TimeSpan previousResolvedKeyTime = _sortedResolvedKeyFrames[previousResolvedKeyFrameIndex]._resolvedKeyTime; 433TimeSpan segmentCurrentTime = currentTime - previousResolvedKeyTime; 434TimeSpan segmentDuration = _sortedResolvedKeyFrames[currentResolvedKeyFrameIndex]._resolvedKeyTime - previousResolvedKeyTime; 662private TimeSpan LargestTimeSpanKeyTime 667TimeSpan largestTimeSpanKeyTime = TimeSpan.Zero; 695return TimeSpan.FromSeconds(1.0); 735TimeSpan calculationDuration = TimeSpan.Zero; 765_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.FromMilliseconds( 806_sortedResolvedKeyFrames[index]._resolvedKeyTime = TimeSpan.Zero; 863TimeSpan blockBeginTime = TimeSpan.Zero; 881TimeSpan uniformTimeStep = TimeSpan.FromTicks((_sortedResolvedKeyFrames[block.EndIndex]._resolvedKeyTime - blockBeginTime).Ticks / segmentCount); 884TimeSpan resolvedTime = blockBeginTime + uniformTimeStep; 946TimeSpan prePacedBlockKeyTime = _sortedResolvedKeyFrames[index - 1]._resolvedKeyTime; 988TimeSpan pacedBlockDuration = _sortedResolvedKeyFrames[index]._resolvedKeyTime - prePacedBlockKeyTime; 999_sortedResolvedKeyFrames[currentKeyFrameIndex]._resolvedKeyTime = prePacedBlockKeyTime + TimeSpan.FromMilliseconds(

27public TimeSpan Offset 52return !(TimeSpan.Zero.Equals(_offset)); 104TimeSpan _offset = TimeSpan.Zero;

1477public Nullable<TimeSpan> GetCurrentTime( FrameworkElement containingObject ) 1487public Nullable<TimeSpan> GetCurrentTime( FrameworkContentElement containingObject ) 1496public TimeSpan GetCurrentTime() 1498Nullable<TimeSpan> currentTime = GetCurrentTimeImpl(this); 1506return default(TimeSpan); 1510private Nullable<TimeSpan> GetCurrentTimeImpl( DependencyObject containingObject ) 1708public void Seek( FrameworkElement containingObject, TimeSpan offset, TimeSeekOrigin origin ) 1718public void Seek( FrameworkContentElement containingObject, TimeSpan offset, TimeSeekOrigin origin ) 1728public void Seek( TimeSpan offset, TimeSeekOrigin origin ) 1738public void Seek( TimeSpan offset ) 1743private void SeekImpl( DependencyObject containingObject, TimeSpan offset, TimeSeekOrigin origin ) 1759public void SeekAlignedToLastTick( FrameworkElement containingObject, TimeSpan offset, TimeSeekOrigin origin ) 1769public void SeekAlignedToLastTick( FrameworkContentElement containingObject, TimeSpan offset, TimeSeekOrigin origin ) 1779public void SeekAlignedToLastTick( TimeSpan offset, TimeSeekOrigin origin ) 1789public void SeekAlignedToLastTick( TimeSpan offset ) 1794private void SeekAlignedToLastTickImpl( DependencyObject containingObject, TimeSpan offset, TimeSeekOrigin origin )

815public static TimeSpan MouseHoverTime 819return TimeSpan.FromMilliseconds(MouseHoverTimeMilliseconds);

424dynamic.Duration = new Duration(TimeSpan.Zero); 843private static readonly Duration DurationZero = new Duration(TimeSpan.Zero);

133Duration duration = new Duration(TimeSpan.FromSeconds(0.2)); 184Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 277Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 353Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 446Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 507Duration duration = new Duration(TimeSpan.FromSeconds(0.3));

129Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 141daukf.KeyFrames.Add(new LinearDoubleKeyFrame(1.0, TimeSpan.FromSeconds(0.5))); 142daukf.KeyFrames.Add(new DiscreteDoubleKeyFrame(1.0, TimeSpan.FromSeconds(0.75))); 143daukf.KeyFrames.Add(new LinearDoubleKeyFrame(0.0, TimeSpan.FromSeconds(2.0))); 160Duration duration = new Duration(TimeSpan.FromSeconds(0.2)); 220Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 246daukf.KeyFrames.Add(new LinearDoubleKeyFrame(1.0, TimeSpan.FromSeconds(to1))); 247daukf.KeyFrames.Add(new DiscreteDoubleKeyFrame(1.0, TimeSpan.FromSeconds(to1 + 0.25))); 248daukf.KeyFrames.Add(new LinearDoubleKeyFrame(0.0, TimeSpan.FromSeconds(to1 + 1.5))); 249daukf.KeyFrames.Add(new LinearDoubleKeyFrame(currentOpacity, TimeSpan.FromSeconds(2))); 257Duration duration = new Duration(TimeSpan.FromSeconds(0.2)); 309Duration duration = new Duration(TimeSpan.FromSeconds(0.1)); 342Duration duration = new Duration(TimeSpan.FromSeconds(0.1));

150Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 162Duration duration = new Duration(TimeSpan.FromSeconds(0.2));

92TimeSpan translateTime = TimeSpan.FromSeconds(twiceWidth / 200.0); // travel at 200px /second 93TimeSpan pauseTime = TimeSpan.FromSeconds(1.0); // pause 1 second between animations 96animation.BeginTime = TimeSpan.Zero;

119Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 156Duration duration = new Duration(TimeSpan.FromSeconds(0.2)); 231Duration duration = new Duration(TimeSpan.FromSeconds(0.2)); 254Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 331Duration duration = new Duration(TimeSpan.FromSeconds(0.3));

125animation.Duration = new Duration(TimeSpan.FromMilliseconds(milliseconds)); // Repeat every 3 seconds

125animation.Duration = new Duration(TimeSpan.FromMilliseconds(milliseconds)); // Repeat every 3 seconds

125animation.Duration = new Duration(TimeSpan.FromMilliseconds(milliseconds)); // Repeat every 3 seconds

17static TimeSpan FailureThrottlingTimeout = TimeSpan.FromSeconds(15);

38TimeSpan GetRemainingTimeout() 153public void StartReading(byte[] accruedData, TimeSpan timeout)

29TimeSpan channelInitializationTimeout; 34TimeSpan channelInitializationTimeout,

47public TimeSpan GetRemainingTimeout() 189public void StartReading(TimeSpan timeout, Action connectionDequeuedCallback)

299static readonly TimeSpan RetryMonitorInterval = TimeSpan.FromMinutes(5); 564static readonly TimeSpan InfiniteTimeout = TimeSpan.FromMilliseconds(UInt32.MaxValue);

17TimeSpan receiveTimeout; 53public TimeSpan ReceiveTimeout

18TimeSpan receiveTimeout; 65public TimeSpan ReceiveTimeout

49customBinding.ReceiveTimeout = TimeSpan.MaxValue;

191((IContextChannel)this.connectionDuplicator).OperationTimeout = TimeSpan.MaxValue;

155typeof(int), typeof(int), typeof(int), typeof(TimeSpan) });

138temp[typeof(TimeSpan)] = typeof(TimeSpanConverter);

22/// <para>Provides a type converter to convert <see cref='System.TimeSpan'/> 32/// convert an object in the given source type to a <see cref='System.TimeSpan'/> object using the 54/// <para>Converts the given object to a <see cref='System.TimeSpan'/> 61return TimeSpan.Parse(text, culture); 83if (destinationType == typeof(InstanceDescriptor) && value is TimeSpan) { 84MethodInfo method = typeof(TimeSpan).GetMethod("Parse", new Type[] {typeof(string)});

63TimeSpan lifetime,

851TimeSpan.FromMilliseconds(ServicePoint.MaxIdleTime) <

97TimeSpan lifetime,

25private TimeSpan m_Lifetime; // the timespan the connection is to live for 54internal PooledStream(ConnectionPool connectionPool, TimeSpan lifetime, bool checkLifetime) : base () { // pooled constructor 240TimeSpan timeSpan = utcNow.Subtract(m_CreateTime); 244m_ConnectionIsDoomed = (0 < TimeSpan.Compare(m_Lifetime, timeSpan)); 253TimeSpan connectionLifetime; 256connectionLifetime = TimeSpan.MaxValue;

851private TimeSpan m_MaxStale; 864TimeSpan maxStale,

97if (ctx.Policy.MinFresh > TimeSpan.Zero) { 100if (ctx.Policy.MaxAge != TimeSpan.MaxValue) { 103if (ctx.Policy.MaxStale > TimeSpan.Zero) { 270if (ctx.Policy.Level == HttpRequestCacheLevel.Default && ctx.ResponseAge != TimeSpan.MinValue) { 275(ctx.Policy.MinFresh > TimeSpan.Zero && (ctx.ResponseExpires - DateTime.UtcNow) < ctx.Policy.MinFresh) || 276(ctx.Policy.MaxStale > TimeSpan.Zero && (DateTime.UtcNow - ctx.ResponseExpires) > ctx.Policy.MaxStale))) 372ctx.CacheEntry.MaxStale = TimeSpan.MinValue; 509TimeSpan age = TimeSpan.MaxValue; 521if (ctx.CacheAge != TimeSpan.MinValue) { 525if (ctx.CacheAge != TimeSpan.MinValue) 535if (ctx.CacheAge != TimeSpan.MinValue) { 537if (ctx.CacheAge > age || age == TimeSpan.MaxValue) { 546ctx.CacheAge = (age < TimeSpan.Zero? TimeSpan.Zero: age); 556if (ctx.CacheAge != TimeSpan.MinValue) { 566ctx.CacheMaxAge = TimeSpan.FromSeconds(ctx.CacheCacheControl.SMaxAge); 580ctx.CacheMaxAge = TimeSpan.FromSeconds(ctx.CacheCacheControl.MaxAge); 603if (expiresDate != DateTime.MinValue && date != DateTime.MinValue && ctx.CacheAge != TimeSpan.MinValue) { 646TimeSpan span = (nowDate - lastModifiedDate); 648ctx.CacheMaxAge = TimeSpan.FromSeconds(maxAgeSeconds); 883if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_age, (ctx.CacheAge != TimeSpan.MinValue ? ((int)ctx.CacheAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo) : SR.GetString(SR.net_log_unknown)), (ctx.CacheMaxAge != TimeSpan.MinValue? ((int)ctx.CacheMaxAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo): SR.GetString(SR.net_log_unknown)))); 885if (ctx.Policy.MinFresh > TimeSpan.Zero) 891if (ctx.Policy.MaxAge != TimeSpan.MaxValue) 905TimeSpan adjustedMaxAge = ctx.CacheMaxAge; 906if (ctx.Policy.MaxStale > TimeSpan.Zero) 909if (adjustedMaxAge < TimeSpan.MaxValue - ctx.Policy.MaxStale) 915adjustedMaxAge = TimeSpan.MaxValue; 1202if (ctx.ResponseAge != TimeSpan.MinValue) {

138internal override Stream Store(string key, long contentLength, DateTime expiresUtc, DateTime lastModifiedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata) 165internal override void Update(string key, DateTime expiresUtc, DateTime lastModifiedUtc, DateTime lastSynchronizedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata) 204internal override bool TryStore(string key, long contentLength, DateTime expiresUtc, DateTime lastModifiedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata, out Stream writeStream) 263internal override bool TryUpdate(string key, DateTime expiresUtc, DateTime lastModifiedUtc, DateTime lastSynchronizedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata)

52internal FtpRequestCacheValidator(bool strictCacheErrors, TimeSpan unspecifiedMaxAge): base(strictCacheErrors, unspecifiedMaxAge) 151TimeSpan age = TimeSpan.MaxValue; 164TimeSpan span = (nowDate - CacheEntry.LastModifiedUtc); 479if (CacheEntry.LastSynchronizedUtc + TimeSpan.FromMinutes(1) >= nowUtc)

69internal TimeSpan Age; 70internal TimeSpan MaxAge; 80Age = TimeSpan.MinValue; 81MaxAge = TimeSpan.MinValue; 123internal TimeSpan CacheAge {get{return m_CacheVars.Age;} set{m_CacheVars.Age = value;}} 124internal TimeSpan CacheMaxAge {get{return m_CacheVars.MaxAge;} set{m_CacheVars.MaxAge = value;}} 135internal TimeSpan ResponseAge {get{return m_ResponseVars.Age;} set{m_ResponseVars.Age = value;}} 175internal HttpRequestCacheValidator(bool strictCacheErrors, TimeSpan unspecifiedMaxAge): base(strictCacheErrors, unspecifiedMaxAge) 382CacheAge = TimeSpan.Zero; 827TimeSpan span = TimeSpan.MinValue; 838span = TimeSpan.FromSeconds(sec);

35internal readonly static TimeSpan s_MaxTimeSpanForInt32 = TimeSpan.FromSeconds((double)int.MaxValue); 97internal override Stream Store(string key, long contentLength, DateTime expiresUtc, DateTime lastModifiedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata) 102internal override bool TryStore(string key, long contentLength, DateTime expiresUtc, DateTime lastModifiedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata, out Stream writeStream) 195internal override void Update(string key, DateTime expiresUtc, DateTime lastModifiedUtc, DateTime lastSynchronizedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata) 201internal override bool TryUpdate(string key, DateTime expiresUtc, DateTime lastModifiedUtc, DateTime lastSynchronizedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata) 383private Stream GetWriteStream(string key, long contentLength, DateTime expiresUtc, DateTime lastModifiedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata, bool isThrow) 419if (maxStale > TimeSpan.Zero) { 435Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_max_stale, (maxStale > TimeSpan.Zero? ((int)maxStale.TotalSeconds).ToString():"n/a"))); 502private bool UpdateInfo(string key, DateTime expiresUtc, DateTime lastModifiedUtc, DateTime lastSynchronizedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata, bool isThrow) 542if (maxStale != TimeSpan.MinValue) { 545if (maxStale >= TimeSpan.Zero) {

64TimeSpan maxStale, 82TimeSpan maxStale, 97TimeSpan maxStale, 111TimeSpan maxStale,

37private TimeSpan m_MaxStale; 61m_MaxStale = TimeSpan.FromSeconds(entry.Info.U.ExemptDelta); 64m_MaxStale = TimeSpan.MaxValue; 77internal TimeSpan MaxStale {get{return m_MaxStale;} set{m_MaxStale = value;}} 94sb.Append("\r\nMaxStale(sec) = ").Append(MaxStale == TimeSpan.MinValue? "": ((int)MaxStale.TotalSeconds).ToString(NumberFormatInfo.CurrentInfo));

150private TimeSpan m_MaxAge = TimeSpan.MaxValue; 151private TimeSpan m_MinFresh = TimeSpan.MinValue; 152private TimeSpan m_MaxStale = TimeSpan.MinValue; 168public HttpRequestCachePolicy(HttpCacheAgeControl cacheAgeControl, TimeSpan ageOrFreshOrStale):this(HttpRequestCacheLevel.Default) 188public HttpRequestCachePolicy(HttpCacheAgeControl cacheAgeControl, TimeSpan maxAge, TimeSpan freshOrStale):this(HttpRequestCacheLevel.Default) 223public HttpRequestCachePolicy(HttpCacheAgeControl cacheAgeControl, TimeSpan maxAge, TimeSpan freshOrStale, DateTime cacheSyncDate) 254public TimeSpan MaxAge { 260public TimeSpan MinFresh { 266public TimeSpan MaxStale { 275(m_MaxAge == TimeSpan.MaxValue? string.Empty: " MaxAge:" + m_MaxAge.ToString()) + 276(m_MinFresh == TimeSpan.MinValue? string.Empty: " MinFresh:" + m_MinFresh.ToString()) + 277(m_MaxStale == TimeSpan.MinValue? string.Empty: " MaxStale:" + m_MaxStale.ToString()) +

87private TimeSpan _UnspecifiedMaxAge; 100protected RequestCacheValidator(bool strictCacheErrors, TimeSpan unspecifiedMaxAge) 117internal TimeSpan UnspecifiedMaxAge

34public TimeSpan MaximumAge 36get { return (TimeSpan)this[this.maximumAge]; } 41public TimeSpan MaximumStale 43get { return (TimeSpan)this[this.maximumStale]; } 48public TimeSpan MinimumFresh 50get { return (TimeSpan)this[this.minimumFresh]; } 87new ConfigurationProperty(ConfigurationStrings.MaximumAge, typeof(TimeSpan), TimeSpan.MaxValue, 91new ConfigurationProperty(ConfigurationStrings.MaximumStale, typeof(TimeSpan), TimeSpan.MinValue, 95new ConfigurationProperty(ConfigurationStrings.MinimumFresh, typeof(TimeSpan), TimeSpan.MinValue,

38return new ConfigurationProperty(name, typeof(TimeSpan), TimeSpan.Zero, null, new TimeSpanValidator(), 43public TimeSpan EntityBody 45get { return (TimeSpan)this[entityBody]; } 49public TimeSpan DrainEntityBody 51get { return (TimeSpan)this[drainEntityBody]; } 55public TimeSpan RequestQueue 57get { return (TimeSpan)this[requestQueue]; } 61public TimeSpan IdleConnection 63get { return (TimeSpan)this[idleConnection]; } 67public TimeSpan HeaderWait 69get { return (TimeSpan)this[headerWait]; } 99return type == typeof(TimeSpan); 104TimeSpan timeout = (TimeSpan)value;

65public TimeSpan UnspecifiedMaximumAge 67get { return (TimeSpan)this[this.unspecifiedMaximumAge]; } 149typeof(TimeSpan), 150TimeSpan.FromDays(1), 190(httpPolicy.MinimumFresh != TimeSpan.MinValue ? HttpCacheAgeControl.MaxAgeAndMinFresh : HttpCacheAgeControl.MaxAgeAndMaxStale); 192this.defaultHttpCachePolicy = new HttpRequestCachePolicy(cacheAgeControl, httpPolicy.MaximumAge, (httpPolicy.MinimumFresh != TimeSpan.MinValue ? httpPolicy.MinimumFresh : httpPolicy.MaximumStale)); 261internal TimeSpan UnspecifiedMaximumAge 316TimeSpan unspecifiedMaximumAge;

158TimeSpan ts; 180this.downloadTimeout = (ts == TimeSpan.MaxValue || ts == TimeSpan.Zero) ? Timeout.Infinite : (int) ts.TotalMilliseconds;

55public TimeSpan DownloadTimeout 57get { return (TimeSpan) this[this.downloadTimeout]; } 90typeof(TimeSpan), 91TimeSpan.FromMinutes(1), 93new TimeSpanValidator(new TimeSpan(0, 0, 0), TimeSpan.MaxValue, false),

1669return (PooledStream) new FtpControlStream(pool, TimeSpan.MaxValue, false);

160public Task<HttpListenerWebSocketContext> AcceptWebSocketAsync(string subProtocol, TimeSpan keepAliveInterval) 169TimeSpan keepAliveInterval) 183TimeSpan keepAliveInterval,

65private TimeSpan GetTimeout(UnsafeNclNativeMethods.HttpApi.HTTP_TIMEOUT_TYPE type) 73private void SetTimespanTimeout(UnsafeNclNativeMethods.HttpApi.HTTP_TIMEOUT_TYPE type, TimeSpan value) 110public TimeSpan EntityBody 131public TimeSpan DrainEntityBody 147public TimeSpan RequestQueue 164public TimeSpan IdleConnection 182public TimeSpan HeaderWait

21return (PooledStream)new SmtpPooledStream(pool, TimeSpan.MaxValue, false);

76internal static readonly IDictionary<string, TimeSpan> timeZoneOffsetLookup = SmtpDateTime.InitializeShortHandLookups(); 80internal readonly static long timeSpanMaxTicks = TimeSpan.TicksPerHour * 99 + TimeSpan.TicksPerMinute * 59; 89internal static IDictionary<string, TimeSpan> InitializeShortHandLookups() 91Dictionary<string, TimeSpan> tempTimeZoneOffsetLookup = new Dictionary<string, TimeSpan>(); 94tempTimeZoneOffsetLookup.Add("UT", TimeSpan.Zero); // +0000 95tempTimeZoneOffsetLookup.Add("GMT", TimeSpan.Zero); // +0000 113private readonly TimeSpan timeZone; 131TimeSpan localTimeZone = TimeZoneInfo.Local.GetUtcOffset(value); 140this.timeZone = TimeSpan.Zero; 358internal bool TryParseTimeZoneString(string timeZoneString, out TimeSpan timeZone) 362timeZone = TimeSpan.Zero; 412internal TimeSpan ValidateAndGetSanitizedTimeSpan(TimeSpan span) 415TimeSpan sanitizedTimeSpan = new TimeSpan(span.Days, span.Hours, span.Minutes, 0, 0); 427internal string TimeSpanToOffset(TimeSpan span)

29internal SmtpPooledStream(ConnectionPool connectionPool, TimeSpan lifetime, bool checkLifetime) : base (connectionPool,lifetime,checkLifetime) {

402private TimeSpan keepAliveInterval; 583public TimeSpan KeepAliveInterval

26TimeSpan keepAliveInterval, bool useZeroMaskingKey, ArraySegment<byte> internalBuffer)

28TimeSpan keepAliveInterval,

25private static TimeSpan? defaultKeepAliveInterval; 27public static TimeSpan DefaultKeepAliveInterval 67TimeSpan keepAliveInterval, 93TimeSpan keepAliveInterval,

72TimeSpan keepAliveInterval, 2195public static KeepAliveTracker Create(TimeSpan keepAliveInterval) 2236private readonly TimeSpan m_KeepAliveInterval; 2241public DefaultKeepAliveTracker(TimeSpan keepAliveInterval) 2296TimeSpan idleTime = GetIdleTime(); 2316private TimeSpan GetIdleTime() 2318TimeSpan sinceLastSendActivity = GetTimeElapsed(m_LastSendActivity); 2319TimeSpan sinceLastReceiveActivity = GetTimeElapsed(m_LastReceiveActivity); 2329private TimeSpan GetTimeElapsed(Stopwatch watch)

57TimeSpan keepAliveInterval, 70TimeSpan keepAliveInterval, 453TimeSpan keepAliveInterval)

738internal static TimeSpan WebSocketGetDefaultKeepAliveInterval() 748return TimeSpan.FromMilliseconds(result);

63private static readonly TimeSpan MaximumMatchTimeout = TimeSpan.FromMilliseconds(Int32.MaxValue - 1); 77public static readonly TimeSpan InfiniteMatchTimeout = Timeout.InfiniteTimeSpan; 93TimeSpan internalMatchTimeout; // timeout for the execution of this regex 111internal static readonly TimeSpan FallbackDefaultMatchTimeout = InfiniteMatchTimeout; 120internal static readonly TimeSpan DefaultMatchTimeout = InitDefaultMatchTimeout(); 232Regex(String pattern, RegexOptions options, TimeSpan matchTimeout) 236private Regex(String pattern, RegexOptions options, TimeSpan matchTimeout, bool useCache) { 326TimeSpan timeout = new TimeSpan(timeoutTicks); 361static void ValidateMatchTimeout(TimeSpan matchTimeout) { 367if (TimeSpan.Zero < matchTimeout && matchTimeout <= MaximumMatchTimeout) 387private static TimeSpan InitDefaultMatchTimeout() { 398if (!(defTmOut is TimeSpan)) { 411TimeSpan defaultTimeout = (TimeSpan) defTmOut; 525TimeSpan MatchTimeout { 748static bool IsMatch(String input, String pattern, RegexOptions options, TimeSpan matchTimeout) { 822static Match Match(String input, String pattern, RegexOptions options, TimeSpan matchTimeout) { 908static MatchCollection Matches(String input, String pattern, RegexOptions options, TimeSpan matchTimeout) { 982static String Replace(String input, String pattern, String replacement, RegexOptions options, TimeSpan matchTimeout) { 1082static String Replace(String input, String pattern, MatchEvaluator evaluator, RegexOptions options, TimeSpan matchTimeout) { 1170static String[] Split(String input, String pattern, RegexOptions options, TimeSpan matchTimeout) {

29private TimeSpan matchTimeout; 45public RegexCompilationInfo(String pattern, RegexOptions options, String name, String fullnamespace, bool ispublic, TimeSpan matchTimeout) { 122public TimeSpan MatchTimeout {

230TimeSpan mTimeout = regexes[i].MatchTimeout; 3186internal void GenerateRegexType(String pattern, RegexOptions opts, String name, bool ispublic, RegexCode code, RegexTree tree, Type factory, TimeSpan matchTimeout) { 3223Call(typeof(TimeSpan).GetMethod("FromTicks", BindingFlags.Static | BindingFlags.Public)); 3280tmoutCtorBuilder = _typebuilder.DefineConstructor(ma, CallingConventions.Standard, new Type[] { typeof(TimeSpan) });

38private TimeSpan matchTimeout = TimeSpan.FromTicks(-1); 48public RegexMatchTimeoutException(string regexInput, string regexPattern, TimeSpan matchTimeout) : 102TimeSpan timeout = TimeSpan.FromTicks(info.GetInt64("timeoutTicks")); 116Init("", "", TimeSpan.FromTicks(-1)); 119private void Init(string input, string pattern, TimeSpan timeout) { 154public TimeSpan MatchTimeout {

119Match Scan(Regex regex, String text, int textbeg, int textend, int textstart, int prevlen, bool quick, TimeSpan timeout) { 267throw new RegexMatchTimeoutException(runtext, runregex.pattern, TimeSpan.FromMilliseconds(timeout));

350TimeSpan timeout,

50private TimeSpan m_timeout; 112public TimeSpan UrlRetrievalTimeout {

549TimeSpan timeout,

842public TimeSpan PrivilegedProcessorTime { 1070public TimeSpan TotalProcessorTime { 1082public TimeSpan UserProcessorTime { 2814public TimeSpan PrivilegedProcessorTime { 2820public TimeSpan UserProcessorTime { 2826public TimeSpan TotalProcessorTime {

215public TimeSpan PrivilegedProcessorTime { 262public TimeSpan TotalProcessorTime { 274public TimeSpan UserProcessorTime {

120public TimeSpan Elapsed {

327/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 328/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 341public bool TryAdd(T item, TimeSpan timeout) 605/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 606/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 618public bool TryTake(out T item, TimeSpan timeout) 891/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 892/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 909public static int TryAddToAny(BlockingCollection<T>[] collections, T item, TimeSpan timeout) 1255/// <param name="timeout">A <see cref="System.TimeSpan"/> that represents the number of milliseconds 1256/// to wait, or a <see cref="System.TimeSpan"/> that represents -1 milliseconds to wait indefinitely. 1275public static int TryTakeFromAny(BlockingCollection<T>[] collections, out T item, TimeSpan timeout) 1778private static void ValidateTimeout(TimeSpan timeout)

556public Boolean SignalAndWait(TimeSpan timeout) 583public Boolean SignalAndWait(TimeSpan timeout, CancellationToken cancellationToken)

13public static TimeSpan AcquireLockTimeout = TimeSpan.FromSeconds(30); 14public static TimeSpan AsyncOperationContextCompleteTimeout = TimeSpan.FromSeconds(30); 15public static TimeSpan CloseTimeout = TimeSpan.FromSeconds(30); 16public static TimeSpan DeleteTimeout = TimeSpan.FromSeconds(30); 17public static TimeSpan InvokeTimeout = TimeSpan.MaxValue; 18public static TimeSpan LoadTimeout = TimeSpan.FromSeconds(30); 19public static TimeSpan OpenTimeout = TimeSpan.FromSeconds(30); 20public static TimeSpan ResumeBookmarkTimeout = TimeSpan.FromSeconds(30); 21public static TimeSpan SaveTimeout = TimeSpan.FromSeconds(30); 22public static TimeSpan InternalSaveTimeout = TimeSpan.MaxValue; 23public static TimeSpan TrackingTimeout = TimeSpan.FromSeconds(30); 24public static TimeSpan TransactionCompletionTimeout = TimeSpan.FromSeconds(30);

112completeData, TimeSpan.MaxValue, onResumeAsyncCodeActivityBookmark, this.executor);

24protected virtual IAsyncResult BeginOnSave(IDictionary<XName, object> readWriteValues, IDictionary<XName, object> writeOnlyValues, TimeSpan timeout, AsyncCallback callback, object state) 37protected virtual IAsyncResult BeginOnLoad(IDictionary<XName, object> readWriteValues, TimeSpan timeout, AsyncCallback callback, object state) 50internal override IAsyncResult InternalBeginOnSave(IDictionary<XName, object> readWriteValues, IDictionary<XName, object> writeOnlyValues, TimeSpan timeout, AsyncCallback callback, object state) 60internal override IAsyncResult InternalBeginOnLoad(IDictionary<XName, object> readWriteValues, TimeSpan timeout, AsyncCallback callback, object state)

88IAsyncResult IPersistencePipelineModule.BeginOnSave(IDictionary<XName, object> readWriteValues, IDictionary<XName, object> writeOnlyValues, TimeSpan timeout, AsyncCallback callback, object state) 98IAsyncResult IPersistencePipelineModule.BeginOnLoad(IDictionary<XName, object> readWriteValues, TimeSpan timeout, AsyncCallback callback, object state) 113internal virtual IAsyncResult InternalBeginOnSave(IDictionary<XName, object> readWriteValues, IDictionary<XName, object> writeOnlyValues, TimeSpan timeout, AsyncCallback callback, object state) 123internal virtual IAsyncResult InternalBeginOnLoad(IDictionary<XName, object> readWriteValues, TimeSpan timeout, AsyncCallback callback, object state)

470protected internal abstract IAsyncResult OnBeginResumeBookmark(Bookmark bookmark, object value, TimeSpan timeout, AsyncCallback callback, object state); 491protected void FlushTrackingRecords(TimeSpan timeout) 499protected IAsyncResult BeginFlushTrackingRecords(TimeSpan timeout, AsyncCallback callback, object state) 1113public void FlushTrackingRecords(TimeSpan timeout) 1118public IAsyncResult BeginFlushTrackingRecords(TimeSpan timeout, AsyncCallback callback, object state)

37return BeginResumeBookmark(bookmark, value, TimeSpan.MaxValue, callback, state); 40public IAsyncResult BeginResumeBookmark(Bookmark bookmark, object value, TimeSpan timeout, AsyncCallback callback, object state)

2640internal IAsyncResult BeginResumeBookmark(Bookmark bookmark, object value, TimeSpan timeout, AsyncCallback callback, object state)

28public InArgument<TimeSpan> Duration 44RuntimeArgument durationArgument = new RuntimeArgument("Duration", typeof(TimeSpan), ArgumentDirection.In, true); 58TimeSpan duration = this.Duration.Get(context); 59if (duration < TimeSpan.Zero) 64if (duration == TimeSpan.Zero)

85protected override void OnRegisterTimer(TimeSpan timeout, Bookmark bookmark) 88if (timeout < TimeSpan.MaxValue) 161result = targetInstance.BeginResumeBookmark(timerBookmark, null, TimeSpan.MaxValue, 293protected override IAsyncResult BeginOnSave(IDictionary<XName, object> readWriteValues, IDictionary<XName, object> writeOnlyValues, TimeSpan timeout, AsyncCallback callback, object state)

15public void RegisterTimer(TimeSpan timeout, Bookmark bookmark) 25protected abstract void OnRegisterTimer(TimeSpan timeout, Bookmark bookmark);

46public void AddTimer(TimeSpan timeout, Bookmark bookmark) 112this.AddTimer(TimeSpan.FromSeconds(retryDuration), bookmark);

23InArgument<TimeSpan> timeout; 30Variable<TimeSpan> nestedScopeTimeout; 40this.timeout = new InArgument<TimeSpan>(TimeSpan.FromMinutes(1)); 43this.nestedScopeTimeout = new Variable<TimeSpan>(); 78public InArgument<TimeSpan> Timeout 100Duration = new InArgument<TimeSpan>(this.nestedScopeTimeout) 130RuntimeArgument timeoutArgument = new RuntimeArgument("Timeout", typeof(TimeSpan), ArgumentDirection.In, false); 343TimeSpan timeout = this.Timeout.Get(context); 359TimeSpan transactionTimeout = this.Timeout.Get(context);

79protected internal override IAsyncResult BeginTrack(TrackingRecord record, TimeSpan timeout, AsyncCallback callback, object state) 90protected internal override void Track(TrackingRecord record, TimeSpan timeout)

23protected internal virtual IAsyncResult BeginTrack(TrackingRecord record, TimeSpan timeout, AsyncCallback callback, object state) 36protected internal abstract void Track(TrackingRecord record, TimeSpan timeout); 43TimeSpan timeout; 45public TrackAsyncResult(TrackingParticipant participant, TrackingRecord record, TimeSpan timeout, AsyncCallback callback, object state)

149public void FlushPendingRecords(TimeSpan timeout) 201public IAsyncResult BeginFlushPendingRecords(TimeSpan timeout, AsyncCallback callback, object state) 309public FlushPendingRecordsAsyncResult(TrackingProvider provider, TimeSpan timeout, AsyncCallback callback, object state)

501bool WaitForTurn(InstanceOperation operation, TimeSpan timeout) 507bool WaitForTurnNoEnqueue(InstanceOperation operation, TimeSpan timeout) 519bool WaitForTurnAsync(InstanceOperation operation, TimeSpan timeout, Action<object, TimeoutException> callback, object state) 524bool WaitForTurnAsync(InstanceOperation operation, bool push, TimeSpan timeout, Action<object, TimeoutException> callback, object state) 531bool WaitForTurnNoEnqueueAsync(InstanceOperation operation, TimeSpan timeout, Action<object, TimeoutException> callback, object state) 1017public void Terminate(string reason, TimeSpan timeout) 1027public void Terminate(Exception reason, TimeSpan timeout) 1074public IAsyncResult BeginTerminate(string reason, TimeSpan timeout, AsyncCallback callback, object state) 1084public IAsyncResult BeginTerminate(Exception reason, TimeSpan timeout, AsyncCallback callback, object state) 1126public void Cancel(TimeSpan timeout) 1159public IAsyncResult BeginCancel(TimeSpan timeout, AsyncCallback callback, object state) 1249internal static IDictionary<string, object> Invoke(Activity activity, IDictionary<string, object> inputs, WorkflowInstanceExtensionManager extensions, TimeSpan timeout) 1291internal static IAsyncResult BeginInvoke(Activity activity, IDictionary<string, object> inputs, WorkflowInstanceExtensionManager extensions, TimeSpan timeout, SynchronizationContext syncContext, AsyncInvokeContext invokeContext, AsyncCallback callback, object state) 1308public void Run(TimeSpan timeout) 1313void InternalRun(TimeSpan timeout, bool isUserRun) 1363public IAsyncResult BeginRun(TimeSpan timeout, AsyncCallback callback, object state) 1368IAsyncResult BeginInternalRun(TimeSpan timeout, bool isUserRun, AsyncCallback callback, object state) 1439public static void CreateDefaultInstanceOwner(InstanceStore instanceStore, WorkflowIdentity definitionIdentity, WorkflowIdentityFilter identityFilter, TimeSpan timeout) 1462WorkflowIdentityFilter identityFilter, TimeSpan timeout, AsyncCallback callback, object state) 1490public static void DeleteDefaultInstanceOwner(InstanceStore instanceStore, TimeSpan timeout) 1511public static IAsyncResult BeginDeleteDefaultInstanceOwner(InstanceStore instanceStore, TimeSpan timeout, AsyncCallback callback, object state) 1541static InstanceView ExecuteInstanceCommandWithTemporaryHandle(InstanceStore instanceStore, InstancePersistenceCommand command, TimeSpan timeout) 1586public static WorkflowApplicationInstance GetRunnableInstance(InstanceStore instanceStore, TimeSpan timeout) 1607public static IAsyncResult BeginGetRunnableInstance(InstanceStore instanceStore, TimeSpan timeout, AsyncCallback callback, object state) 1633public static WorkflowApplicationInstance GetInstance(Guid instanceId, InstanceStore instanceStore, TimeSpan timeout) 1654public static IAsyncResult BeginGetInstance(Guid instanceId, InstanceStore instanceStore, TimeSpan timeout, AsyncCallback callback, object state) 1680public void Load(WorkflowApplicationInstance instance, TimeSpan timeout) 1690public void Load(WorkflowApplicationInstance instance, DynamicUpdateMap updateMap, TimeSpan timeout) 1749public void LoadRunnableInstance(TimeSpan timeout) 1802public void Load(Guid instanceId, TimeSpan timeout) 1962static WorkflowApplicationInstance LoadCore(TimeSpan timeout, bool loadAny, PersistenceManager persistenceManager) 2038internal static void DiscardInstance(PersistenceManagerBase persistanceManager, TimeSpan timeout) 2045internal static IAsyncResult BeginDiscardInstance(PersistenceManagerBase persistanceManager, TimeSpan timeout, AsyncCallback callback, object state) 2089public IAsyncResult BeginLoadRunnableInstance(TimeSpan timeout, AsyncCallback callback, object state) 2126public IAsyncResult BeginLoad(Guid instanceId, TimeSpan timeout, AsyncCallback callback, object state) 2160public IAsyncResult BeginLoad(WorkflowApplicationInstance instance, TimeSpan timeout, 2172public IAsyncResult BeginLoad(WorkflowApplicationInstance instance, DynamicUpdateMap updateMap, TimeSpan timeout, 2255IAsyncResult BeginInternalPersist(PersistenceOperation operation, TimeSpan timeout, bool isInternalPersist, AsyncCallback callback, object state) 2414public void Persist(TimeSpan timeout) 2445public IAsyncResult BeginPersist(TimeSpan timeout, AsyncCallback callback, object state) 2471public ReadOnlyCollection<BookmarkInfo> GetBookmarks(TimeSpan timeout) 2553public BookmarkResumptionResult ResumeBookmark(string bookmarkName, object value, TimeSpan timeout) 2564public BookmarkResumptionResult ResumeBookmark(Bookmark bookmark, object value, TimeSpan timeout) 2651public IAsyncResult BeginResumeBookmark(string bookmarkName, object value, TimeSpan timeout, AsyncCallback callback, object state) 2668public IAsyncResult BeginResumeBookmark(Bookmark bookmark, object value, TimeSpan timeout, AsyncCallback callback, object state) 2682protected internal override IAsyncResult OnBeginResumeBookmark(Bookmark bookmark, object value, TimeSpan timeout, AsyncCallback callback, object state) 2807public void Unload(TimeSpan timeout) 2851public IAsyncResult BeginUnload(TimeSpan timeout, AsyncCallback callback, object state) 3072public InvokeAsyncResult(Activity activity, IDictionary<string, object> inputs, WorkflowInstanceExtensionManager extensions, TimeSpan timeout, SynchronizationContext syncContext, AsyncInvokeContext invokeContext, AsyncCallback callback, object state) 3191public ResumeBookmarkAsyncResult(WorkflowApplication instance, Bookmark bookmark, object value, TimeSpan timeout, AsyncCallback callback, object state) 3196public ResumeBookmarkAsyncResult(WorkflowApplication instance, Bookmark bookmark, object value, bool isFromExtension, TimeSpan timeout, AsyncCallback callback, object state) 3446public UnloadOrPersistAsyncResult(WorkflowApplication instance, TimeSpan timeout, PersistenceOperation operation, 3657TimeSpan flushTrackingRecordsTimeout; 3952protected void Run(TimeSpan timeout) 4097public static TerminateAsyncResult Create(WorkflowApplication instance, Exception reason, TimeSpan timeout, AsyncCallback callback, object state) 4127public static CancelAsyncResult Create(WorkflowApplication instance, TimeSpan timeout, AsyncCallback callback, object state) 4160public static RunAsyncResult Create(WorkflowApplication instance, bool isUserRun, TimeSpan timeout, AsyncCallback callback, object state) 4302IDictionary<XName, InstanceValue> values, DynamicUpdateMap updateMap, TimeSpan timeout, 4316bool loadAny, TimeSpan timeout, AsyncCallback callback, object state) 4744public PumpBasedSynchronizationContext(TimeSpan timeout) 4833bool WaitOne(AutoResetEvent waiter, TimeSpan timeout) 5318TimeSpan timeout, AsyncCallback callback, object state) 5421public bool WaitForTurn(TimeSpan timeout) 5431public bool WaitForTurnAsync(TimeSpan timeout, Action<object, TimeoutException> callback, object state) 5659public void Initialize(WorkflowIdentity definitionIdentity, TimeSpan timeout) 5708public IAsyncResult BeginInitialize(WorkflowIdentity definitionIdentity, TimeSpan timeout, AsyncCallback callback, object state) 5753public void DeleteOwner(TimeSpan timeout) 5770public IAsyncResult BeginDeleteOwner(TimeSpan timeout, AsyncCallback callback, object state) 5808public void EnsureReadyness(TimeSpan timeout) 5821public IAsyncResult BeginEnsureReadyness(TimeSpan timeout, AsyncCallback callback, object state) 5958public void Save(IDictionary<XName, InstanceValue> instance, PersistenceOperation operation, TimeSpan timeout) 5964public IDictionary<XName, InstanceValue> Load(TimeSpan timeout) 5977public bool TryLoad(TimeSpan timeout, out IDictionary<XName, InstanceValue> data) 5983public IAsyncResult BeginSave(IDictionary<XName, InstanceValue> instance, PersistenceOperation operation, TimeSpan timeout, AsyncCallback callback, object state) 5994public IAsyncResult BeginLoad(TimeSpan timeout, AsyncCallback callback, object state) 6012public IAsyncResult BeginTryLoad(TimeSpan timeout, AsyncCallback callback, object state) 6039public void Unlock(TimeSpan timeout) 6049public IAsyncResult BeginUnlock(TimeSpan timeout, AsyncCallback callback, object state)

81public void Abandon(TimeSpan timeout) 94public IAsyncResult BeginAbandon(TimeSpan timeout, AsyncCallback callback, object state)

93public static IDictionary<string, object> Invoke(Activity workflow, TimeSpan timeout) 105public static IDictionary<string, object> Invoke(Activity workflow, IDictionary<string, object> inputs, TimeSpan timeout) 129public static TResult Invoke<TResult>(Activity<TResult> workflow, IDictionary<string, object> inputs, TimeSpan timeout) 140public static TResult Invoke<TResult>(Activity<TResult> workflow, IDictionary<string, object> inputs, out IDictionary<string, object> additionalOutputs, TimeSpan timeout) 170public IAsyncResult BeginInvoke(TimeSpan timeout, AsyncCallback callback, object state) 184public IAsyncResult BeginInvoke(IDictionary<string, object> inputs, TimeSpan timeout, AsyncCallback callback, object state) 208IAsyncResult result = context.WorkflowApplication.BeginCancel(TimeSpan.MaxValue, cancelCallback, context); 229public IDictionary<string, object> Invoke(TimeSpan timeout) 243public IDictionary<string, object> Invoke(IDictionary<string, object> inputs, TimeSpan timeout) 255public void InvokeAsync(TimeSpan timeout) 265public void InvokeAsync(TimeSpan timeout, object userState) 277public void InvokeAsync(IDictionary<string, object> inputs, TimeSpan timeout) 287public void InvokeAsync(IDictionary<string, object> inputs, TimeSpan timeout, object userState) 299static IDictionary<string, object> Invoke(Activity workflow, TimeSpan timeout, WorkflowInstanceExtensionManager extensions) 321static IDictionary<string, object> Invoke(Activity workflow, IDictionary<string, object> inputs, TimeSpan timeout, WorkflowInstanceExtensionManager extensions) 360IAsyncResult BeginInvoke(Activity workflow, IDictionary<string, object> inputs, TimeSpan timeout, WorkflowInstanceExtensionManager extensions, AsyncCallback callback, object state) 373IAsyncResult BeginInvoke(Activity workflow, TimeSpan timeout, WorkflowInstanceExtensionManager extensions, AsyncCallback callback, object state) 391void InternalInvokeAsync(IDictionary<string, object> inputs, TimeSpan timeout, object userState)

16public WorkflowPersistenceContext(bool transactionRequired, TimeSpan transactionTimeout) 21public WorkflowPersistenceContext(bool transactionRequired, Transaction transactionToUse, TimeSpan transactionTimeout)

59typeof(TimeSpan),

35TimeSpan timeout,

25TimeSpan timeout,

26TimeSpan timeout,

12public DetectActivatableWorkflowsTask(SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, TimeSpan taskInterval) 17public override void ResetTimer(bool fireImmediately, TimeSpan? taskIntervalOverride)

26TimeSpan timeout, 69TimeSpan? timeTillNextPoll = null;

12public DetectRunnableInstancesTask(SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, TimeSpan taskInterval) 17public override void ResetTimer(bool fireImmediately, TimeSpan? taskIntervalOverride)

25TimeSpan timeout,

11TimeSpan RetryDelay(int retryAttempt);

24InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) 42public TimeSpan RetryTimeout 92TimeSpan retryDelay = tryCommandAsyncResult.InstanceStore.GetNextRetryDelay(++tryCommandAsyncResult.retryCount);

11static readonly TimeSpan defaultRetryDelay = TimeSpan.FromSeconds(5); 13public TimeSpan RetryDelay(int retryAttempt)

11readonly TimeSpan DefaultBackoffLimit = TimeSpan.FromSeconds(10); 12readonly TimeSpan DefaultBackoffMultiplier = TimeSpan.FromMilliseconds(100); 14readonly TimeSpan multiplier; 15readonly TimeSpan maxDelay; 25public TimeSpan RetryDelay(int retryAttempt) 29return TimeSpan.FromMilliseconds

70TimeSpan waitTime = TimeSpan.Zero; 112if (waitTime != TimeSpan.Zero)

33TimeSpan timeout,

21TimeSpan timeout,

11public LockRecoveryTask(SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, TimeSpan taskInterval, TimeSpan taskTimeout)

11public LockRenewalTask(SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, TimeSpan taskInterval, TimeSpan taskTimeout)

16TimeSpan taskInterval; 20TimeSpan taskTimeout; 22public PersistenceTask(SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, InstancePersistenceCommand instancePersistenceCommand, TimeSpan taskInterval, TimeSpan taskTimeout, bool automaticallyResetTimer) 80public virtual void ResetTimer(bool fireImmediately, TimeSpan? taskIntervalOverride) 82TimeSpan timeTillNextPoll = this.taskInterval; 99this.taskTimer.Set(fireImmediately ? TimeSpan.Zero : timeTillNextPoll);

27TimeSpan timeout,

25TimeSpan timeout,

53TimeSpan timeout, 250TimeSpan datetimeOffset = pendingTimerExpiration - DateTime.UtcNow;

18static readonly TimeSpan MaximumOpenTimeout = TimeSpan.FromMinutes(2); 61TimeSpan timeout, int retryCount, int maximumRetries, AsyncCallback callback, object state) 69this.timeoutHelper = new TimeoutHelper(TimeSpan.FromTicks(openTimeout)); 255return (this.timeoutHelper.RemainingTime() <= TimeSpan.Zero);

21static readonly TimeSpan defaultConnectionOpenTime = TimeSpan.FromSeconds(15); 22static readonly TimeSpan defaultInstancePersistenceEventDetectionPeriod = TimeSpan.FromSeconds(5); 23static readonly TimeSpan defaultLockRenewalPeriod = TimeSpan.FromSeconds(30); 24static readonly TimeSpan minimumTimeSpanAllowed = TimeSpan.FromSeconds(1); 27TimeSpan bufferedHostLockRenewalPeriod; 33TimeSpan hostLockRenewalPeriod; 38TimeSpan instancePersistenceEventDetectionPeriod; 64this.bufferedHostLockRenewalPeriod = TimeSpan.Zero; 97public TimeSpan HostLockRenewalPeriod 153public TimeSpan RunnableInstancesDetectionPeriod 176internal TimeSpan BufferedHostLockRenewalPeriod 181if (this.bufferedHostLockRenewalPeriod == TimeSpan.Zero) 183double lockBuffer = Math.Min(SqlWorkflowInstanceStoreConstants.LockOwnerTimeoutBuffer.TotalSeconds, (TimeSpan.MaxValue.Subtract(this.HostLockRenewalPeriod)).TotalSeconds); 184this.bufferedHostLockRenewalPeriod = TimeSpan.FromSeconds(Math.Min(Int32.MaxValue, lockBuffer + this.HostLockRenewalPeriod.TotalSeconds)); 330protected internal override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) 355internal IAsyncResult BeginTryCommandSkipRetry(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) 391internal IAsyncResult BeginTryCommandInternalWithVersionCheck(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state, Version targetVersion) 398internal IAsyncResult BeginTryCommandInternal(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) 403internal IAsyncResult BeginTryCommandInternal(InstancePersistenceContext context, InstancePersistenceCommand command, Transaction transaction, TimeSpan timeout, AsyncCallback callback, object state) 501this.BeginTryCommandInternal(null, command, TimeSpan.MaxValue, this.unlockInstanceCallback, command); 505internal TimeSpan GetNextRetryDelay(int retryAttempt) 630this.BeginTryCommandInternal(null, command, TimeSpan.MaxValue, unlockInstanceCallback, command); 682BackoffTimeoutHelper = new BackoffTimeoutHelper(TimeSpan.MaxValue)

29TimeSpan timeout, 45TimeSpan timeout,

12public static readonly TimeSpan MaxHostLockRenewalPulseInterval = TimeSpan.FromSeconds(30); 13public static readonly TimeSpan DefaultTaskTimeout = TimeSpan.FromSeconds(30); 14public static readonly TimeSpan LockOwnerTimeoutBuffer = TimeSpan.FromSeconds(30);

16TimeSpan hostLockRenewalPulseInterval = TimeSpan.Zero; 85TimeSpan HostLockRenewalPulseInterval 89if (this.hostLockRenewalPulseInterval == TimeSpan.Zero) 116TimeSpan runnableInstancesDetectionPeriod = this.sqlWorkflowInstanceStore.RunnableInstancesDetectionPeriod;

31TimeSpan timeout,

25TimeSpan timeout,

24TimeSpan timeout,

25TimeSpan timeout,

131else if (value is TimeSpan) 280else if (value is TimeSpan) 282return XmlConvert.ToString((TimeSpan)value);

208this.tryHideTimer.Interval = TimeSpan.FromMilliseconds(200);

143return type.IsPrimitive || type == typeof(string) || type == typeof(TimeSpan) || type == typeof(DateTime);

1532var dt = new DispatcherTimer(TimeSpan.FromSeconds(6), DispatcherPriority.ApplicationIdle, (sender, e) => { tip.IsOpen = false; }, r.Dispatcher);

60private TimeSpan _startupTimeout = new TimeSpan(0, 0, 10); 62public TimeSpan StartupTimeout

246public TimeSpan Renewal(ILease lease) 254return m_lifetimeTokens.Count > 0 ? lease.InitialLeaseTime : TimeSpan.Zero;

59TimeSpan matchTimeout = TimeSpan.FromSeconds(2);

74TimeSpan matchTimeout = TimeSpan.FromSeconds(2);

111: Regex = new Regex(Pattern, default(RegexOptions), TimeSpan.FromMilliseconds((double)MatchTimeoutInMilliseconds));

52TimeSpan matchTimeout = TimeSpan.FromSeconds(2);

22static readonly TypeConverter s_TimeSpanConverter = TypeDescriptor.GetConverter(typeof(TimeSpan)); 25ValidateType(value, typeof(TimeSpan)); 27if ((TimeSpan)value == TimeSpan.MaxValue) { 39return TimeSpan.MaxValue;

15return (type == typeof(TimeSpan)); 22if (((TimeSpan)value) <= TimeSpan.Zero) {

24ValidateType(value, typeof(TimeSpan)); 26long data = (long)(((TimeSpan)value).TotalMinutes); 36return TimeSpan.FromMinutes((double)min);

24ValidateType(value, typeof(TimeSpan)); 26if ((TimeSpan)value == TimeSpan.MaxValue) { 39return TimeSpan.MaxValue;

24ValidateType(value, typeof(TimeSpan)); 26long data = (long)(((TimeSpan)value).TotalSeconds); 40return TimeSpan.FromSeconds((double)min);

24ValidateType(value, typeof(TimeSpan)); 26if ((TimeSpan)value == TimeSpan.MaxValue) { 38return TimeSpan.MaxValue;

30private TimeSpan _minValue = TimeSpan.MinValue; 31private TimeSpan _maxValue = TimeSpan.MaxValue; 34public TimeSpanValidator(TimeSpan minValue, TimeSpan maxValue) 38public TimeSpanValidator(TimeSpan minValue, TimeSpan maxValue, bool rangeIsExclusive) 42public TimeSpanValidator(TimeSpan minValue, TimeSpan maxValue, bool rangeIsExclusive, long resolutionInSeconds) { 59return (type == typeof(TimeSpan)); 63ValidatorUtils.HelperParamValidation(value, typeof(TimeSpan)); 65ValidatorUtils.ValidateScalar((TimeSpan)value,

26private TimeSpan _min = TimeSpan.MinValue; 27private TimeSpan _max = TimeSpan.MaxValue; 42public TimeSpan MinValue { 48public TimeSpan MaxValue { 59TimeSpan timeValue = TimeSpan.Parse(value, CultureInfo.InvariantCulture); 74TimeSpan timeValue = TimeSpan.Parse(value, CultureInfo.InvariantCulture);

98public static void ValidateScalar(TimeSpan value, TimeSpan min, TimeSpan max, long resolutionInSeconds, bool exclusiveRange) { 103ValidateResolution(TimeSpan.FromSeconds( resolutionInSeconds ).ToString(), value.Ticks, resolutionInSeconds * TimeSpan.TicksPerSecond);

140private bool GetNextBatch(TimeSpan ts) { 143if (ts == TimeSpan.MaxValue) 166return ReadEvent(TimeSpan.MaxValue); 172public EventRecord ReadEvent(TimeSpan timeout) {

142TimeSpan timeDifference = timeNow.Subtract(kvp.Value.TheTime);

244public TimeoutTracker(TimeSpan timeout) 292public bool TryEnterReadLock(TimeSpan timeout) 454public bool TryEnterWriteLock(TimeSpan timeout) 677public bool TryEnterUpgradeableReadLock(TimeSpan timeout)

208this.tryHideTimer.Interval = TimeSpan.FromMilliseconds(200);

143return type.IsPrimitive || type == typeof(string) || type == typeof(TimeSpan) || type == typeof(DateTime);

1532var dt = new DispatcherTimer(TimeSpan.FromSeconds(6), DispatcherPriority.ApplicationIdle, (sender, e) => { tip.IsOpen = false; }, r.Dispatcher);

115public override TimeSpan GetTimeSpan(SmiEventSink sink, int ordinal) { 212public override void SetTimeSpan(SmiEventSink sink, int ordinal, TimeSpan value) {

133ht.Add( typeof( System.TimeSpan ), ExtendedClrTypeCode.TimeSpan ); 355if (value.GetType() == typeof(TimeSpan) && smiVersion >= SmiContextFactory.KatmaiVersion)

201public virtual TimeSpan GetTimeSpan(SmiEventSink sink, int ordinal) { 401public virtual void SetTimeSpan(SmiEventSink sink, int ordinal, TimeSpan value) {

219public virtual TimeSpan GetTimeSpan(int ordinal) { 473public virtual void SetTimeSpan(int ordinal, TimeSpan value) {

51[FieldOffset(0)] internal TimeSpan _timeSpan; 270internal TimeSpan TimeSpan {

774internal static TimeSpan GetTimeSpan(SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData, bool gettersSupportKatmaiDateTime) { 783return (TimeSpan) obj; 787internal static TimeSpan GetTimeSpan(SmiEventSink_Default sink, SmiTypedGetterSetter getters, int ordinal, SmiMetaData metaData) { 792return (TimeSpan)GetValue200(sink, getters, ordinal, metaData, null); 1557internal static void SetTimeSpan(SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData, TimeSpan value, bool settersSupportKatmaiDateTime) { 1708SetTimeSpan_Checked(sink, setters, ordinal, metaData, (TimeSpan)value); 1999TimeSpan ts; 2003ts = (TimeSpan)reader.GetValue(i); 2279TimeSpan ts; 2286ts = (TimeSpan)record.GetValue(i); 2426private static readonly TimeSpan x_timeMin = TimeSpan.Zero; 2427private static readonly TimeSpan x_timeMax = new TimeSpan(TimeSpan.TicksPerDay - 1); 2428private static void VerifyTimeRange(SqlDbType dbType, TimeSpan value) { 2439private static void SetTimeSpan_Checked(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, TimeSpan value) { 3200private static TimeSpan GetTimeSpan_Unchecked(SmiEventSink_Default sink, SmiTypedGetterSetter getters, int ordinal) { 3203TimeSpan result = getters.GetTimeSpan(sink, ordinal); 3337private static void SetTimeSpan_Unchecked(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, TimeSpan value) {

863}else if(col.DataType == typeof(DateTime) || col.DataType == typeof(TimeSpan)) {

40typeof(TimeSpan),

1934long result = checked((long)seconds * TimeSpan.TicksPerSecond); 1939long result = checked(milliseconds * TimeSpan.TicksPerMillisecond); 1965long result = timerValue / TimeSpan.TicksPerMillisecond; 1970long result = timerValue / TimeSpan.TicksPerSecond;

88typeof(TimeSpan),

187if (typeof(TimeSpan) == dataType) {

525return XmlConvert.ToString((TimeSpan) value); 559return (TimeSpan) value; 704return (TimeSpan) value; 771return XmlConvert.ToString((TimeSpan) value);

18private static readonly TimeSpan defaultValue = TimeSpan.Zero; 20private TimeSpan[] values; 23: base(column, typeof(TimeSpan), defaultValue, StorageType.TimeSpan) { 31TimeSpan min = TimeSpan.MaxValue; 36min=(TimeSpan.Compare(values[record],min) < 0) ? values[record] : min; 45TimeSpan max = TimeSpan.MinValue; 50max=(TimeSpan.Compare(values[record],max) >= 0) ? values[record] : max; 76return TimeSpan.FromTicks((long)Math.Round(sum)); 91return TimeSpan.FromTicks((long)Math.Round(meanSum / meanCount)); 120return TimeSpan.FromTicks((long)stDev); 127throw ExprException.Overflow(typeof(TimeSpan)); 133TimeSpan valueNo1 = values[recordNo1]; 134TimeSpan valueNo2 = values[recordNo2]; 141return TimeSpan.Compare(valueNo1, valueNo2); 155TimeSpan valueNo1 = values[recordNo]; 159return valueNo1.CompareTo((TimeSpan)value); 162private static TimeSpan ConvertToTimeSpan(object value) { 167return TimeSpan.Parse((string)value); 176return (TimeSpan) value; 199TimeSpan value = values[record]; 219TimeSpan[] newValues = new TimeSpan[capacity]; 232return XmlConvert.ToString((TimeSpan)value); 236return new TimeSpan[recordCount]; 240TimeSpan[] typedStore = (TimeSpan[]) store; 246values = (TimeSpan[]) store;

337if (vLeft is TimeSpan && vRight is DateTime) { 338value = (DateTime)vRight + (TimeSpan)vLeft; 340else if (vLeft is DateTime && vRight is TimeSpan) { 341value = (DateTime)vLeft + (TimeSpan)vRight; 348value = (TimeSpan)vLeft + (TimeSpan)vRight; 378if (vLeft is TimeSpan && vRight is SqlDateTime) { 380value = (SqlDateTime)SqlConvert.ConvertToSqlDateTime((DateTime)rValue.Value + (TimeSpan)vLeft); 382else if (vLeft is SqlDateTime && vRight is TimeSpan) { 384value = (SqlDateTime)SqlConvert.ConvertToSqlDateTime((DateTime)lValue.Value + (TimeSpan)vRight); 456value = (DateTime)vLeft - (TimeSpan)vRight; 463value = (TimeSpan)vLeft - (TimeSpan)vRight; 466if (vLeft is TimeSpan && vRight is SqlDateTime) { 468value = (SqlDateTime)SqlConvert.ConvertToSqlDateTime((DateTime)rValue.Value - (TimeSpan)vLeft); 470else if (vLeft is SqlDateTime && vRight is TimeSpan) { 472value = (SqlDateTime)SqlConvert.ConvertToSqlDateTime((DateTime)lValue.Value - (TimeSpan)vRight);

782static private readonly TypeMap _Time = new TypeMap(OdbcType.Time, DbType.Time, typeof(TimeSpan), ODBC32.SQL_TYPE.TYPE_TIME, ODBC32.SQL_C.TYPE_TIME, ODBC32.SQL_C.TYPE_TIME, 6, 12, false); 903else if (dataType == typeof(System.TimeSpan)) {

891public TimeSpan GetTime(int i) { 892return (TimeSpan)internalGetTime(i);

299WriteTime(offset, (TimeSpan)value);

514Value_DBTIME((TimeSpan) value); 751private TimeSpan Value_DBTIME() { 756private void Value_DBTIME(TimeSpan value) {

165static private readonly NativeDBType D_DBTime = new NativeDBType(0xff, 6, true, false, OleDbType.DBTime, NativeDBType.DBTIME, S_DBTIME, typeof(System.TimeSpan), NativeDBType.DBTIME, DbType.Time ); // 7 - (tagDBTime) 323else if (value is System.TimeSpan) {

977public TimeSpan GetTimeSpan(int ordinal) { 978return (TimeSpan) GetValue(ordinal);

603internal TimeSpan ReadTime(int offset) { 611internal void WriteTime(int offset, TimeSpan value) {

531internal TimeSpan LoadBalanceTimeout {

19private readonly TimeSpan _loadBalanceTimeout; 49public TimeSpan LoadBalanceTimeout {

69timeout._originalTimerTicks = milliseconds * TimeSpan.TicksPerMillisecond;

1028public TimeSpan Adjust(TimeSpan value) { 1108else if (dataType == typeof(TimeSpan)) 1109value = this.Adjust((TimeSpan)value); 1296else if (dataType == typeof(TimeSpan)) 1297smd = new SqlMetaData(name, SqlDbType.Time, 0, InferScaleFromTimeTicks(((TimeSpan)value).Ticks)); 1477private static readonly TimeSpan x_timeMin = TimeSpan.Zero; 1478private static readonly TimeSpan x_timeMax = new TimeSpan(TimeSpan.TicksPerDay - 1); 1479private void VerifyTimeRange(TimeSpan value) {

397internal TimeSpan Time { 405return (TimeSpan)this.Value; // anything else we haven't thought of goes through boxing. 414TimeSpan offset = new TimeSpan(0, _value._dateTimeOffsetInfo.offset, 0); 424return (dateTime2Info.date * TimeSpan.TicksPerDay + dateTime2Info.timeInfo.ticks); 879internal void SetToTime(TimeSpan timeSpan, byte scale) {

130static private TimeSpan _ColumnEncryptionKeyCacheTtl = TimeSpan.FromHours(2); 137static public TimeSpan ColumnEncryptionKeyCacheTtl

2529virtual public TimeSpan GetTimeSpan(int i) { 2532TimeSpan t = _data[i].Time; 2542t = (TimeSpan) temp;

809public override TimeSpan GetTimeSpan(int ordinal) {

339} else if (dataType == typeof(TimeSpan)) { 407else if (sqlType == typeof(TimeSpan)) return DBNull.Value; 525else if (comVal is TimeSpan || comVal is DateTimeOffset) 826(255, 7, -1, false, false, false, TdsEnums.SQLTIME, TdsEnums.SQLTIME, MetaTypeName.TIME, typeof(System.TimeSpan), typeof(System.TimeSpan), SqlDbType.Time, DbType.Time, 1);

171private static readonly TimeSpan _dbAuthenticationContextLockedRefreshTimeSpan = new TimeSpan(hours: 0, minutes: 45, seconds: 00); 175private static readonly TimeSpan _dbAuthenticationContextUnLockedRefreshTimeSpan = new TimeSpan(hours: 0, minutes: 10, seconds: 00); 2233TimeSpan contextValidity = dbConnectionPoolAuthenticationContext.ExpirationTime.Subtract(DateTime.UtcNow);

950value = TimeSpan.Parse((string)value);

101if (SqlConnection.ColumnEncryptionKeyCacheTtl != TimeSpan.Zero) {

5951WriteTime((TimeSpan)value, mt.Scale, length, stateObj); 6114WriteTime((TimeSpan)value, metatype.Scale, 5, stateObj); 6259private byte[] SerializeTime(TimeSpan value, byte scale, int length) { 6260if (0 > value.Ticks || value.Ticks >= TimeSpan.TicksPerDay) { 6273private void WriteTime(TimeSpan value, byte scale, int length, TdsParserStateObject stateObj) { 6274if (0 > value.Ticks || value.Ticks >= TimeSpan.TicksPerDay) { 10685WriteTime((TimeSpan)value, scale, actualLength, stateObj); 10893return SerializeTime((TimeSpan)value, scale, actualLength);

179public override void SetTimeSpan(SmiEventSink sink, int ordinal, TimeSpan value) {

546internal void SetTimeSpan(TimeSpan value) {

65private const long TicksPerSecond = TimeSpan.TicksPerMillisecond * 1000; 88private static readonly TimeSpan MinTimeSpan = MinDateTime.Subtract(SQLBaseDate); 89private static readonly TimeSpan MaxTimeSpan = MaxDateTime.Subtract(SQLBaseDate); 218private static TimeSpan ToTimeSpan(SqlDateTime value) { 220return new TimeSpan(value.m_day * TimeSpan.TicksPerDay + 221millisecond * TimeSpan.TicksPerMillisecond); 233long dayticks = daypart * TimeSpan.TicksPerDay; 234long timeticks = ((long)(timepart / SQLTicksPerMillisecond + 0.5)) * TimeSpan.TicksPerMillisecond; // 241private static SqlDateTime FromTimeSpan(TimeSpan value) { 247long ticks = value.Ticks - day * TimeSpan.TicksPerDay; 251ticks += TimeSpan.TicksPerDay; 254int time = (int)((double)ticks / TimeSpan.TicksPerMillisecond * SQLTicksPerMillisecond + 0.5); 369public static SqlDateTime operator +(SqlDateTime x, TimeSpan t) { 374public static SqlDateTime operator -(SqlDateTime x, TimeSpan t) { 383public static SqlDateTime Add(SqlDateTime x, TimeSpan t) { 388public static SqlDateTime Subtract(SqlDateTime x, TimeSpan t) {

210if (type == typeof(TimeSpan))

1576new NameType("duration" , typeof(TimeSpan)), /* XSD Apr */

554TimeSpan offsetTimeSpan = new TimeSpan(offsetHours, offsetMinutes, 0); 577private static TimeSpan ConvertTimeLiteralValue(ErrorContext errCtx, string datetimeLiteralValue) 593TimeSpan ts = new TimeSpan(hour, minute, second);

2193else if (typeof(TimeSpan) == type ||

549return new DateTimeOffset(((DateTime)value).Ticks, TimeSpan.Zero);

60typeDefaultMap[PrimitiveTypeKind.Time] = default(TimeSpan);

59m_breakdownTimes = new TimeSpan[numEnums]; 69private readonly TimeSpan[] m_breakdownTimes; 97internal TimeSpan[] BreakdownTimes 161TimeSpan timeElapsed = m_singleWatch.Elapsed; 174TimeSpan timeElapsed = m_watch.Elapsed;

160return typeof(TimeSpan);

148else if (typeof(TimeSpan) == clrType) 210primitiveTypes[(int)PrimitiveTypeKind.Time] = CreatePrimitiveType(typeof(TimeSpan), PrimitiveTypeKind.Time);

170InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Time], PrimitiveTypeKind.Time, EdmConstants.Time, typeof(TimeSpan));

719else if (clrType == typeof(System.TimeSpan))

618protected internal static TimeSpan SetValidValue(TimeSpan value, string propertyName) 634protected internal static TimeSpan SetValidValue(TimeSpan value) 652protected internal static Nullable<TimeSpan> SetValidValue(Nullable<TimeSpan> value, string propertyName) 668protected internal static Nullable<TimeSpan> SetValidValue(Nullable<TimeSpan> value)

577yield return GetProperty(typeof(TimeSpan), "Hours", BindingFlags.Public | BindingFlags.Instance, ExpressionConverter.Hour); 578yield return GetProperty(typeof(TimeSpan), "Minutes", BindingFlags.Public | BindingFlags.Instance, ExpressionConverter.Minute); 579yield return GetProperty(typeof(TimeSpan), "Seconds", BindingFlags.Public | BindingFlags.Instance, ExpressionConverter.Second); 580yield return GetProperty(typeof(TimeSpan), "Milliseconds", BindingFlags.Public | BindingFlags.Instance, ExpressionConverter.Millisecond);

558public static System.TimeSpan? CreateTime(System.Int32? hour, System.Int32? minute, System.Double? second) 639public static System.TimeSpan? AddHours(System.TimeSpan? timeValue, System.Int32? addValue) 666public static System.TimeSpan? AddMinutes(System.TimeSpan? timeValue, System.Int32? addValue) 693public static System.TimeSpan? AddSeconds(System.TimeSpan? timeValue, System.Int32? addValue) 720public static System.TimeSpan? AddMilliseconds(System.TimeSpan? timeValue, System.Int32? addValue) 747public static System.TimeSpan? AddMicroseconds(System.TimeSpan? timeValue, System.Int32? addValue) 774public static System.TimeSpan? AddNanoseconds(System.TimeSpan? timeValue, System.Int32? addValue) 855public static System.Int32? DiffHours(System.TimeSpan? timeValue1, System.TimeSpan? timeValue2) 882public static System.Int32? DiffMinutes(System.TimeSpan? timeValue1, System.TimeSpan? timeValue2) 909public static System.Int32? DiffSeconds(System.TimeSpan? timeValue1, System.TimeSpan? timeValue2) 936public static System.Int32? DiffMilliseconds(System.TimeSpan? timeValue1, System.TimeSpan? timeValue2) 963public static System.Int32? DiffMicroseconds(System.TimeSpan? timeValue1, System.TimeSpan? timeValue2) 990public static System.Int32? DiffNanoseconds(System.TimeSpan? timeValue1, System.TimeSpan? timeValue2)

662public static System.TimeSpan? DateAdd(System.String datePartArg, System.Double? number, System.TimeSpan? time) 707public static System.Int32? DateDiff(System.String datePartArg, System.TimeSpan? startDate, System.TimeSpan? endDate) 734public static System.Int32? DateDiff(System.String datePartArg, System.String startDate, System.TimeSpan? endDate) 743public static System.Int32? DateDiff(System.String datePartArg, System.TimeSpan? startDate, System.String endDate) 779public static System.Int32? DateDiff(System.String datePartArg, System.TimeSpan? startDate, System.DateTime? endDate) 788public static System.Int32? DateDiff(System.String datePartArg, System.TimeSpan? startDate, System.DateTimeOffset? endDate) 797public static System.Int32? DateDiff(System.String datePartArg, System.DateTime? startDate, System.TimeSpan? endDate) 806public static System.Int32? DateDiff(System.String datePartArg, System.DateTimeOffset? startDate, System.TimeSpan? endDate) 851public static System.String DateName(System.String datePartArg, System.TimeSpan? date) 896public static System.Int32? DatePart(System.String datePartArg, System.TimeSpan? date) 959public static System.Int32? DataLength(System.TimeSpan? arg) 1049public static System.Int32? Checksum(System.TimeSpan? arg1) 1130public static System.Int32? Checksum(System.TimeSpan? arg1, System.TimeSpan? arg2) 1220public static System.Int32? Checksum(System.TimeSpan? arg1, System.TimeSpan? arg2, System.TimeSpan? arg3)

784TimeSpan timeSpan = (TimeSpan)value;

384_timeSpan = ForType(typeof(System.TimeSpan));

113else if (toType == typeof(TimeSpan)) { 115return TimeSpan.Parse(value.ToString(), Globalization.CultureInfo.InvariantCulture); 127else if (fromType == typeof(TimeSpan)) { 129return ((TimeSpan)value).ToString("", Globalization.CultureInfo.InvariantCulture); 133return dt.Add((TimeSpan)value); 137return dto.Add((TimeSpan)value); 140return Convert.ChangeType(((TimeSpan)value).Ticks, toType, Globalization.CultureInfo.InvariantCulture);

536type == typeof(TimeSpan) || type == typeof(Binary))

45bool isClrTimeSpanType = clrType == typeof(TimeSpan);

220return (typeof(TimeSpan) == type) || (typeof(DateTimeOffset) == type);

210if (exp.Type == typeof(TimeSpan))

164if (node.Type == typeof(TimeSpan))

56else if (snew.ClrType == typeof(TimeSpan)) { 257if (mc.Arguments.Count == 1 && mc.Arguments[0].ClrType == typeof(TimeSpan)) { 281if (mc.Arguments.Count == 1 && mc.Arguments[0].ClrType == typeof(TimeSpan)) { 293if (!mc.Method.IsStatic && mc.Method.DeclaringType == typeof(TimeSpan)) { 590if (m.Expression.ClrType == typeof(TimeSpan)) { 705else if (sox.ClrType == typeof(TimeSpan)) { 793if (sox.Args.Count == 2 && sox.Args[0].ClrType == typeof(DateTime) && sox.Args[1].ClrType == typeof(TimeSpan)) { 798sql.ConvertToInt(sql.ConvertToBigint(sql.Divide(sql.ConvertTimeToDouble(sox.Args[1]), TimeSpan.TicksPerMinute))) 830if (sox.Args.Count == 7 && sox.Args[6].ClrType == typeof(TimeSpan)) { 835else if (sox.Args.Count == 8 && sox.Args[6].ClrType == typeof(int) && sox.Args[7].ClrType == typeof(TimeSpan)) { 852sql.ConvertToInt(sql.ConvertToBigint(sql.Divide(sql.ConvertTimeToDouble(sox.Args[timeSpanIndex]), TimeSpan.TicksPerMinute))) 862return sql.ConvertTo(typeof(TimeSpan), sox.Args[0]); 869SqlExpression TicksFromHours = sql.Multiply(hours, TimeSpan.TicksPerHour); 870SqlExpression TicksFromMinutes = sql.Multiply(minutes, TimeSpan.TicksPerMinute); 871SqlExpression TicksFromSeconds = sql.Multiply(seconds, TimeSpan.TicksPerSecond); 872return sql.ConvertTo(typeof(TimeSpan), sql.Add(TicksFromHours, TicksFromMinutes, TicksFromSeconds)); 879SqlExpression TicksFromDays = sql.Multiply(days, TimeSpan.TicksPerDay); 880SqlExpression TicksFromHours = sql.Multiply(hours, TimeSpan.TicksPerHour); 881SqlExpression TicksFromMinutes = sql.Multiply(minutes, TimeSpan.TicksPerMinute); 882SqlExpression TicksFromSeconds = sql.Multiply(seconds, TimeSpan.TicksPerSecond); 886return sql.ConvertTo(typeof(TimeSpan), totalTicks); 891SqlExpression ticksFromMs = sql.Multiply(milliseconds, TimeSpan.TicksPerMillisecond); 892return sql.ConvertTo(typeof(TimeSpan), sql.Add(totalTicks, ticksFromMs)); 966else if (declType == typeof(TimeSpan)) { 1059else if ((mc.Method.Name == "Add" && mc.Arguments.Count == 1 && mc.Arguments[0].ClrType == typeof(TimeSpan)) 1121else if ((mc.Method.Name == "Add" && mc.Arguments.Count == 1 && mc.Arguments[0].ClrType == typeof(TimeSpan)) 1190returnValue = sql.FunctionCall(typeof(TimeSpan), "ABS", new SqlExpression[] { mc.Object }, source); 1342else if (rightType == typeof(TimeSpan)) { 1377if (rightType == typeof(TimeSpan)) { 2219SqlExpression ticksFromHour = sql.Multiply(sql.ConvertToBigint(hours), TimeSpan.TicksPerHour); 2220SqlExpression ticksFromMinutes = sql.Multiply(sql.ConvertToBigint(minutes), TimeSpan.TicksPerMinute); 2221SqlExpression ticksFromSeconds = sql.Multiply(sql.ConvertToBigint(seconds), TimeSpan.TicksPerSecond); 2222SqlExpression ticksFromMs = sql.Multiply(sql.ConvertToBigint(milliseconds), TimeSpan.TicksPerMillisecond); 2223return sql.ConvertTo(typeof(TimeSpan), sql.Add(ticksFromHour, ticksFromMinutes, ticksFromSeconds, ticksFromMs)); 2239else if (baseClrTypeOfExpr == typeof(System.TimeSpan)) { 2264return sql.Divide(sql.ConvertToDouble(exp), TimeSpan.TicksPerMillisecond); 2274return sql.Divide(sql.ConvertToDouble(exp), TimeSpan.TicksPerSecond); 2284return sql.Divide(sql.ConvertToDouble(exp), TimeSpan.TicksPerMinute); 2294return sql.Divide(sql.ConvertToDouble(exp), TimeSpan.TicksPerHour); 2306return sql.Divide(sql.ConvertToDouble(exp), TimeSpan.TicksPerDay); 2311return sql.ConvertToInt(sql.Mod(sql.ConvertToBigint(sql.Divide(exp, TimeSpan.TicksPerMillisecond)), 1000)); 2316return sql.ConvertToInt(sql.Mod(sql.ConvertToBigint(sql.Divide(exp, TimeSpan.TicksPerSecond)), 60)); 2321return sql.ConvertToInt(sql.Mod(sql.ConvertToBigint(sql.Divide(exp, TimeSpan.TicksPerMinute)), 60)); 2326return sql.ConvertToInt(sql.Mod(sql.ConvertToBigint(sql.Divide(exp, TimeSpan.TicksPerHour)), 24)); 2331return sql.ConvertToInt(sql.Divide(exp, TimeSpan.TicksPerDay)); 2345SqlExpression daysAdded = sql.DATEADD("day", sql.Divide(sqlTicks, TimeSpan.TicksPerDay), sqlDate, source, asNullable); 2346return sql.DATEADD("ms", sql.Mod(sql.Divide(sqlTicks, TimeSpan.TicksPerMillisecond), 86400000), daysAdded, source, asNullable); 2366SqlExpression daysAdded = sql.DATETIMEOFFSETADD("day", sql.Divide(sqlTicks, TimeSpan.TicksPerDay), sqlDate, source, asNullable); 2367return sql.DATETIMEOFFSETADD("ms", sql.Mod(sql.Divide(sqlTicks, TimeSpan.TicksPerMillisecond), 86400000), daysAdded, source, asNullable);