Add polyfills for TimeProvider and ITimer

PolyShim/Net80/ITimer.cs

@@ -0,0 +1,21 @@
+#if !FEATURE_TIMEPROVIDER
+#nullable enable
+// ReSharper disable RedundantUsingDirective
+// ReSharper disable CheckNamespace
+// ReSharper disable InconsistentNaming
+// ReSharper disable PartialTypeWithSinglePart
+
+using System;
+using System.Threading.Tasks;
+
+namespace System.Threading;
+
+// https://learn.microsoft.com/dotnet/api/system.threading.itimer
+internal interface ITimer : IDisposable
+#if FEATURE_ASYNCINTERFACES
+        , IAsyncDisposable
+#endif
+{
+    bool Change(TimeSpan dueTime, TimeSpan period);
+}
+#endif

PolyShim/Net80/TimeProvider.cs

@@ -0,0 +1,159 @@
+#if !FEATURE_TIMEPROVIDER
+#nullable enable
+// ReSharper disable RedundantUsingDirective
+// ReSharper disable CheckNamespace
+// ReSharper disable InconsistentNaming
+// ReSharper disable PartialTypeWithSinglePart
+
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using SystemThreading = System.Threading;
+
+namespace System;
+
+// https://learn.microsoft.com/dotnet/api/system.timeprovider
+[ExcludeFromCodeCoverage]
+internal abstract class TimeProvider
+{
+    public static TimeProvider System { get; } = new SystemTimeProvider();
+
+    protected TimeProvider() { }
+
+    public virtual DateTimeOffset GetUtcNow() => DateTimeOffset.UtcNow;
+
+    public DateTimeOffset GetLocalNow()
+    {
+        var utcDateTime = GetUtcNow();
+        var offset = LocalTimeZone.GetUtcOffset(utcDateTime);
+        return new DateTimeOffset(utcDateTime.DateTime + offset, offset);
+    }
+
+    public abstract TimeZoneInfo LocalTimeZone { get; }
+
+    public virtual long GetTimestamp() => Stopwatch.GetTimestamp();
+
+    public TimeSpan GetElapsedTime(long startingTimestamp) =>
+        GetElapsedTime(startingTimestamp, GetTimestamp());
+
+    public virtual TimeSpan GetElapsedTime(long startingTimestamp, long endingTimestamp)
+    {
+        // Stopwatch.GetElapsedTime was added in .NET 7, so we need to calculate it manually
+        var tickFrequency = Stopwatch.Frequency;
+        var ticks = endingTimestamp - startingTimestamp;
+
+        if (tickFrequency == TimeSpan.TicksPerSecond)
+        {
+            return new TimeSpan(ticks);
+        }
+        else if (tickFrequency > TimeSpan.TicksPerSecond)
+        {
+            var ticksPerStopwatchTick = (double)tickFrequency / TimeSpan.TicksPerSecond;
+            return new TimeSpan((long)(ticks / ticksPerStopwatchTick));
+        }
+        else
+        {
+            var ticksPerStopwatchTick = (double)TimeSpan.TicksPerSecond / tickFrequency;
+            return new TimeSpan((long)(ticks * ticksPerStopwatchTick));
+        }
+    }
+
+    // Timer and TimerCallback are not available on .NET Standard 1.0 and 1.1
+#if !(NETSTANDARD && !NETSTANDARD1_2_OR_GREATER)
+    public SystemThreading.ITimer CreateTimer(
+        SystemThreading.TimerCallback callback,
+        object? state,
+        TimeSpan dueTime,
+        TimeSpan period
+    ) => new SystemTimeProviderTimer(dueTime, period, callback, state);
+#endif
+
+    // Task.Delay, Timeout.InfiniteTimeSpan, and CancellationTokenSource(TimeSpan) require .NET 4.5+
+#if FEATURE_TASK && (NETSTANDARD1_3_OR_GREATER || NETCOREAPP || NET45_OR_GREATER)
+    public virtual Task Delay(
+        TimeSpan delay,
+        SystemThreading.CancellationToken cancellationToken = default
+    )
+    {
+        if (delay < TimeSpan.Zero && delay != SystemThreading.Timeout.InfiniteTimeSpan)
+            throw new ArgumentOutOfRangeException(nameof(delay));
+
+        if (cancellationToken.IsCancellationRequested)
+        {
+            var tcs = new TaskCompletionSource<bool>();
+            tcs.SetCanceled();
+            return tcs.Task;
+        }
+
+        if (delay == TimeSpan.Zero)
+            return Task.CompletedTask;
+
+        return Task.Delay(delay, cancellationToken);
+    }
+
+    public SystemThreading.CancellationTokenSource CreateCancellationTokenSource(TimeSpan delay)
+    {
+        if (delay < TimeSpan.Zero && delay != SystemThreading.Timeout.InfiniteTimeSpan)
+            throw new ArgumentOutOfRangeException(nameof(delay));
+
+        if (delay == SystemThreading.Timeout.InfiniteTimeSpan)
+            return new SystemThreading.CancellationTokenSource();
+
+        return new SystemThreading.CancellationTokenSource(delay);
+    }
+#endif
+
+    private sealed class SystemTimeProvider : TimeProvider
+    {
+        public override TimeZoneInfo LocalTimeZone => TimeZoneInfo.Local;
+    }
+
+    // Timer and TimerCallback are not available on .NET Standard 1.0 and 1.1
+#if !(NETSTANDARD && !NETSTANDARD1_2_OR_GREATER)
+    private sealed class SystemTimeProviderTimer : SystemThreading.ITimer
+    {
+        private readonly SystemThreading.Timer _timer;
+
+        public SystemTimeProviderTimer(
+            TimeSpan dueTime,
+            TimeSpan period,
+            SystemThreading.TimerCallback callback,
+            object? state
+        )
+        {
+            _timer = new SystemThreading.Timer(callback, state, dueTime, period);
+        }
+
+        public bool Change(TimeSpan dueTime, TimeSpan period)
+        {
+            try
+            {
+                return _timer.Change(dueTime, period);
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public void Dispose()
+        {
+            _timer.Dispose();
+        }
+
+#if FEATURE_ASYNCINTERFACES
+        public ValueTask DisposeAsync()
+        {
+#if NETCOREAPP3_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
+            return _timer.DisposeAsync();
+#else
+            _timer.Dispose();
+            return default;
+#endif
+        }
+#endif
+    }
+#endif
+}
+#endif

PolyShim/PolyShim.csproj

@@ -50,19 +50,19 @@
   <ItemGroup>
     <PackageReference
       Include="Microsoft.Bcl.AsyncInterfaces"
-      Version="7.0.0"
+      Version="8.0.0"
       PrivateAssets="all"
       Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard' AND $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '2.0'))"
     />
     <PackageReference
       Include="Microsoft.Bcl.AsyncInterfaces"
-      Version="7.0.0"
+      Version="8.0.0"
       PrivateAssets="all"
       Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' AND $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '2.0')) AND $([MSBuild]::VersionLessThan($(TargetFrameworkVersion), '3.0'))"
     />
     <PackageReference
       Include="Microsoft.Bcl.AsyncInterfaces"
-      Version="7.0.0"
+      Version="8.0.0"
       PrivateAssets="all"
       Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework' AND $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '4.6.1'))"
     />
@@ -144,6 +144,24 @@
       PrivateAssets="all"
       Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework' AND $([MSBuild]::VersionEquals($(TargetFrameworkVersion), '4.0'))"
     />
+    <PackageReference
+      Include="Microsoft.Bcl.TimeProvider"
+      Version="8.0.1"
+      PrivateAssets="all"
+      Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard' AND $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '2.0'))"
+    />
+    <PackageReference
+      Include="Microsoft.Bcl.TimeProvider"
+      Version="8.0.1"
+      PrivateAssets="all"
+      Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' AND $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '2.0')) AND $([MSBuild]::VersionLessThan($(TargetFrameworkVersion), '8.0'))"
+    />
+    <PackageReference
+      Include="Microsoft.Bcl.TimeProvider"
+      Version="8.0.1"
+      PrivateAssets="all"
+      Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework' AND $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '4.6.2'))"
+    />
   </ItemGroup>
 
   <!-- Import common .NET Framework libraries for metadata references -->

PolyShim/PolyShim.targets

@@ -302,6 +302,23 @@
       <DefineConstants Condition="$(FeatureValueTuple)"
         >$(DefineConstants);FEATURE_VALUETUPLE</DefineConstants
       >
+
+      <FeatureTimeProvider>false</FeatureTimeProvider>
+      <FeatureTimeProvider
+        Condition="@(Reference-&gt;AnyHaveMetadataValue('Identity', 'Microsoft.Bcl.TimeProvider'))"
+        >true</FeatureTimeProvider
+      >
+      <FeatureTimeProvider
+        Condition="@(PackageDependencies-&gt;AnyHaveMetadataValue('Identity', 'Microsoft.Bcl.TimeProvider'))"
+        >true</FeatureTimeProvider
+      >
+      <FeatureTimeProvider
+        Condition="$(IsNetCoreApp) AND $([MSBuild]::VersionGreaterThanOrEquals($(TargetFrameworkVersion), '8.0'))"
+        >true</FeatureTimeProvider
+      >
+      <DefineConstants Condition="$(FeatureTimeProvider)"
+        >$(DefineConstants);FEATURE_TIMEPROVIDER</DefineConstants
+      >
     </PropertyGroup>
   </Target>
 </Project>

PolyShim/Signatures.md

@@ -1,7 +1,7 @@
 # Signatures
 
-- **Total:** 355
-- **Types:** 76
+- **Total:** 357
+- **Types:** 78
 - **Members:** 279
 
 ___
@@ -187,6 +187,8 @@ ___
   - [`TValue? GetValueOrDefault(TKey)`](https://learn.microsoft.com/dotnet/api/system.collections.generic.collectionextensions.getvalueordefault#system-collections-generic-collectionextensions-getvalueordefault-2(system-collections-generic-ireadonlydictionary((-0-1))-0)) <sup><sub>.NET Core 2.0</sub></sup>
 - `IsExternalInit`
   - [**[class]**](https://learn.microsoft.com/dotnet/api/system.runtime.compilerservices.isexternalinit) <sup><sub>.NET 5.0</sub></sup>
+- `ITimer`
+  - [**[interface]**](https://learn.microsoft.com/dotnet/api/system.threading.itimer) <sup><sub>.NET 8.0</sub></sup>
 - `KeyValuePair<TKey, TValue>`
   - [`void Deconstruct(out TKey, out TValue)`](https://learn.microsoft.com/dotnet/api/system.collections.generic.keyvaluepair-2.deconstruct) <sup><sub>.NET Core 2.0</sub></sup>
 - `LibraryImportAttribute`
@@ -441,6 +443,8 @@ ___
   - [`void Write(ReadOnlySpan<char>)`](https://learn.microsoft.com/dotnet/api/system.io.textwriter.write#system-io-textwriter-write(system-readonlyspan((system-char)))) <sup><sub>.NET Core 2.1</sub></sup>
 - `ThreadAbortException`
   - [**[class]**](https://learn.microsoft.com/dotnet/api/system.threading.threadabortexception) <sup><sub>.NET Core 2.0</sub></sup>
+- `TimeProvider`
+  - [**[class]**](https://learn.microsoft.com/dotnet/api/system.timeprovider) <sup><sub>.NET 8.0</sub></sup>
 - `TimeSpan`
   - [`TimeSpan FromMilliseconds(long, long)`](https://learn.microsoft.com/dotnet/api/system.timespan.frommilliseconds#system-timespan-frommilliseconds(system-int64-system-int64)) <sup><sub>.NET 9.0</sub></sup>
   - [`TimeSpan FromMilliseconds(long)`](https://learn.microsoft.com/dotnet/api/system.timespan.frommilliseconds#system-timespan-frommilliseconds(system-int64)) <sup><sub>.NET 10.0</sub></sup>

Readme.md

@@ -193,6 +193,7 @@ Currently, **PolyShim** recognizes the following packages:
 - [`Microsoft.Bcl.AsyncInterfaces`](https://nuget.org/packages/Microsoft.Bcl.AsyncInterfaces) — `IAsyncEnumerable<T>`, `IAsyncDisposable`, etc.
 - [`Microsoft.Bcl.HashCode`](https://nuget.org/packages/Microsoft.Bcl.HashCode) — `HashCode`, etc.
 - [`Microsoft.Bcl.Memory`](https://nuget.org/packages/Microsoft.Bcl.Memory) — `Index`, `Range`, etc.
+- [`Microsoft.Bcl.TimeProvider`](https://nuget.org/packages/Microsoft.Bcl.TimeProvider) — `TimeProvider`, `ITimer`, etc.
 - [`Microsoft.Net.Http`](https://nuget.org/packages/Microsoft.Net.Http) — `HttpClient`, `HttpContent`, etc. (wider support than the `System.*` variant).
 
 For example, adding a reference to the `Microsoft.Bcl.AsyncInterfaces` package will enable **PolyShim**'s polyfills that work with `IAsyncEnumerable<T>`, such as `Task.WhenEach(...)`: