Add Timer class polyfill for .NET Standard 1.0–1.1 via Task.Delay

PolyShim/Net80/TimeProvider.cs

@@ -40,21 +40,18 @@ public virtual TimeSpan GetElapsedTime(long startingTimestamp, long endingTimest
     public TimeSpan GetElapsedTime(long startingTimestamp) =>
         GetElapsedTime(startingTimestamp, GetTimestamp());
 
-#if !(NETSTANDARD && !NETSTANDARD1_2_OR_GREATER)
     public virtual ITimer CreateTimer(
         TimerCallback callback,
         object? state,
         TimeSpan dueTime,
         TimeSpan period
     ) => new SystemTimeProviderTimer(dueTime, period, callback, state);
-#endif
 
     private sealed class SystemTimeProvider : TimeProvider
     {
         public override TimeZoneInfo LocalTimeZone => TimeZoneInfo.Local;
     }
 
-#if !(NETSTANDARD && !NETSTANDARD1_2_OR_GREATER)
     private sealed class SystemTimeProviderTimer : ITimer
     {
         private readonly Timer _timer;
@@ -90,6 +87,5 @@ public void Dispose()
         public ValueTask DisposeAsync() => _timer.DisposeAsync();
 #endif
     }
-#endif
 }
 #endif

PolyShim/NetCore10/Timer.cs

@@ -0,0 +1,119 @@
+#if NETSTANDARD && !NETSTANDARD1_2_OR_GREATER
+#nullable enable
+// ReSharper disable RedundantUsingDirective
+// ReSharper disable CheckNamespace
+// ReSharper disable InconsistentNaming
+// ReSharper disable PartialTypeWithSinglePart
+
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+
+namespace System.Threading;
+
+// https://learn.microsoft.com/dotnet/api/system.threading.timer
+[ExcludeFromCodeCoverage]
+internal sealed class Timer : IDisposable
+{
+    private readonly TimerCallback _callback;
+    private readonly object? _state;
+    private CancellationTokenSource _cts = new CancellationTokenSource();
+    private volatile bool _disposed;
+
+    public Timer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
+    {
+        _callback = callback;
+        _state = state;
+        Schedule(dueTime, period);
+    }
+
+    public Timer(TimerCallback callback, object? state, int dueTime, int period)
+        : this(
+            callback,
+            state,
+            TimeSpan.FromMilliseconds(dueTime),
+            TimeSpan.FromMilliseconds(period)
+        ) { }
+
+    public Timer(TimerCallback callback, object? state, long dueTime, long period)
+        : this(
+            callback,
+            state,
+            TimeSpan.FromMilliseconds(dueTime),
+            TimeSpan.FromMilliseconds(period)
+        ) { }
+
+    public Timer(TimerCallback callback)
+        : this(callback, null, Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan) { }
+
+    private void Schedule(TimeSpan dueTime, TimeSpan period)
+    {
+        if (_disposed)
+            throw new ObjectDisposedException(nameof(Timer));
+
+        var cts = new CancellationTokenSource();
+        var oldCts = Interlocked.Exchange(ref _cts, cts);
+        oldCts.Cancel();
+        oldCts.Dispose();
+
+        if (dueTime == Timeout.InfiniteTimeSpan)
+            return;
+
+        _ = Task.Run(async () =>
+        {
+            try
+            {
+                if (dueTime > TimeSpan.Zero)
+                    await Task.Delay(dueTime, cts.Token);
+
+                if (cts.IsCancellationRequested)
+                    return;
+
+                _callback(_state);
+
+                if (period == Timeout.InfiniteTimeSpan || period <= TimeSpan.Zero)
+                    return;
+
+                while (!cts.IsCancellationRequested)
+                {
+                    await Task.Delay(period, cts.Token);
+
+                    if (cts.IsCancellationRequested)
+                        return;
+
+                    _callback(_state);
+                }
+            }
+            catch (OperationCanceledException) { }
+        });
+    }
+
+    public bool Change(TimeSpan dueTime, TimeSpan period)
+    {
+        try
+        {
+            Schedule(dueTime, period);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public bool Change(int dueTime, int period) =>
+        Change(TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period));
+
+    public bool Change(long dueTime, long period) =>
+        Change(TimeSpan.FromMilliseconds(dueTime), TimeSpan.FromMilliseconds(period));
+
+    public void Dispose()
+    {
+        if (_disposed)
+            return;
+        _disposed = true;
+        var cts = Interlocked.Exchange(ref _cts, new CancellationTokenSource());
+        cts.Cancel();
+        cts.Dispose();
+    }
+}
+#endif

PolyShim/NetCore30/Timer.cs

@@ -1,6 +1,4 @@
 #if (NETCOREAPP && !NETCOREAPP3_0_OR_GREATER) || (NETFRAMEWORK) || (NETSTANDARD && !NETSTANDARD2_1_OR_GREATER)
-// Timer is not available on .NET Standard 1.0 and 1.1
-#if !(NETSTANDARD && !NETSTANDARD1_2_OR_GREATER)
 #nullable enable
 // ReSharper disable RedundantUsingDirective
 // ReSharper disable CheckNamespace
@@ -27,4 +25,3 @@ public ValueTask DisposeAsync()
     }
 }
 #endif
-#endif

PolyShim/Signatures.md

@@ -1,7 +1,7 @@
 # Signatures
 
-- **Total:** 372
-- **Types:** 78
+- **Total:** 373
+- **Types:** 79
 - **Members:** 294
 
 ___
@@ -462,6 +462,7 @@ ___
 - `TimeProvider`
   - [**[class]**](https://learn.microsoft.com/dotnet/api/system.timeprovider) <sup><sub>.NET 8.0</sub></sup>
 - `Timer`
+  - [**[class]**](https://learn.microsoft.com/dotnet/api/system.threading.timer) <sup><sub>.NET Core 1.0</sub></sup>
   - [`ValueTask DisposeAsync()`](https://learn.microsoft.com/dotnet/api/system.threading.timer.disposeasync) <sup><sub>.NET Core 3.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>