feat: Added TimeProvider.CreateCancellationTokenSource(TimeSpan delay)

Author: egil

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.8.0]
 
 - Added `TimeProvider.GetElapsedTime(long startingTimestamp)`
+- Added `TimeProvider.CreateCancellationTokenSource(TimeSpan delay)`
 
 ## [0.7.0]
 

README.md

@@ -10,9 +10,9 @@ Currently, the following .NET time-based APIs are supported:
 |----------------------|----------------------|
 | `GetUtcNow()` method | `DateTimeOffset.UtcNow` property |
 | `CreateTimer()` method | `System.Threading.Timer` type |
-| `CreatePeriodicTimer(TimeSpan)` method (only .NET 6) | `System.Threading.PeriodicTimer` type |
+| `TimeProvider.CreatePeriodicTimer(TimeSpan)` method (only .NET 6) | `System.Threading.PeriodicTimer` type |
 | `Delay(TimeSpan, CancellationToken)` method | `Task.Delay(TimeSpan, CancellationToken)` method |
-| `CancellationTokenSource.CancelAfter(TimeSpan, TimeProvider)` method | `CancellationTokenSource.CancelAfter(TimeSpan)` method |
+| `CancellationTokenSource.CancelAfter(TimeSpan, TimeProvider)` and `TimeProvider.CreateCancellationTokenSource(TimeSpan delay)` methods | `CancellationTokenSource.CancelAfter(TimeSpan)` method |
 | `Task.WaitAsync(TimeSpan, TimeProvider)` method (only .NET 6)| `Task.WaitAsync(TimeSpan)` method |
 | `Task.WaitAsync(TimeSpan, TimeProvider, CancellationToken)` method (only .NET 6)| `Task.WaitAsync(TimeSpan, CancellationToken)` method |
 

src/TimeScheduler/System/Threading/TimeProviderCancellationTokenSourceExtensions.cs

@@ -11,17 +11,69 @@ public static class TimeProviderCancellationTokenSourceExtensions
     private const uint UnsignedInfinite = unchecked((uint)-1);
     private static readonly ConditionalWeakTable<CancellationTokenSource, ITimer> CancellationTokenSourceTimerMap = new();
 
+    /// <summary>Initializes a new instance of the <see cref="CancellationTokenSource"/> class that will be canceled after the specified <see cref="TimeSpan"/>. </summary>
+    /// <param name="timeProvider">The <see cref="TimeProvider"/> with which to interpret the <paramref name="delay"/>. </param>
+    /// <param name="delay">The time interval to wait before canceling this <see cref="CancellationTokenSource"/>. </param>
+    /// <exception cref="ArgumentOutOfRangeException"> The <paramref name="delay"/> is negative and not equal to <see cref="Timeout.InfiniteTimeSpan" /> or greater than maximum allowed timer duration.</exception>
+    /// <returns><see cref="CancellationTokenSource"/> that will be canceled after the specified <paramref name="delay"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// The countdown for the delay starts during the call to the constructor. When the delay expires,
+    /// the constructed <see cref="CancellationTokenSource"/> is canceled if it has
+    /// not been canceled already.
+    /// </para>
+    /// <para>
+    /// If running on .NET versions earlier than .NET 8.0, there is a constraint when invoking <see cref="CancellationTokenSource.CancelAfter(TimeSpan)"/> on the resultant object.
+    /// This action will not terminate the initial timer indicated by <paramref name="delay"/>. However, this restriction does not apply on .NET 8.0 and later versions.
+    /// </para>
+    /// </remarks>
+    public static CancellationTokenSource CreateCancellationTokenSource(this TimeProvider timeProvider, TimeSpan delay)
+    {
+#if NET8_0_OR_GREATER
+            return new CancellationTokenSource(delay, timeProvider);
+#else
+        if (timeProvider is null)
+        {
+            throw new ArgumentNullException(nameof(timeProvider));
+        }
+
+        if (delay != Timeout.InfiniteTimeSpan && delay < TimeSpan.Zero)
+        {
+            throw new ArgumentOutOfRangeException(nameof(delay));
+        }
+
+        if (timeProvider == TimeProvider.System)
+        {
+            return new CancellationTokenSource(delay);
+        }
+
+        var cts = new CancellationTokenSource();
+
+        ITimer timer = timeProvider.CreateTimer(s =>
+        {
+            try
+            {
+                ((CancellationTokenSource)s!).Cancel();
+            }
+            catch (ObjectDisposedException) { }
+        }, cts, delay, Timeout.InfiniteTimeSpan);
+
+        cts.Token.Register(t => ((ITimer)t!).Dispose(), timer);
+        return cts;
+#endif // NET8_0_OR_GREATER
+    }
+
     /// <summary>
     /// Schedules a Cancel operation on the <paramref name="cancellationTokenSource"/>.
     /// </summary>
-    /// <param name="timeProvider">
-    /// The <see cref="TimeProvider"/> to use for scheduling the cancellation.
-    /// </param>
     /// <param name="cancellationTokenSource">
     /// The <see cref="CancellationTokenSource"/> to cancel after the specified delay.
     /// </param>
     /// <param name="delay">The time span to wait before canceling the <paramref name="cancellationTokenSource"/>.
     /// </param>
+    /// <param name="timeProvider">
+    /// The <see cref="TimeProvider"/> to use for scheduling the cancellation.
+    /// </param>
     /// <exception cref="ObjectDisposedException">The exception thrown when the <paramref name="cancellationTokenSource"/>
     /// has been disposed.
     /// </exception>
@@ -32,7 +84,7 @@ public static class TimeProviderCancellationTokenSourceExtensions
     /// <remarks>
     /// <para>
     /// The countdown for the delay starts during this call. When the delay expires,
-    /// the <paramref name="cancellationTokenSource"/> is canceled, if it has
+    /// the <paramref name="cancellationTokenSource"/> is cancel    ed, if it has
     /// not been canceled already.
     /// </para>
     /// <para>

test/TimeScheduler.Tests/System/TimeProviderTests.cs

@@ -260,6 +260,16 @@ public async Task CancelAfter_cancels()
         await throwsAfterCancel.Should().ThrowAsync<TaskCanceledException>();
     }
 
+    [Fact]
+    public async Task CreateCancellationTokenSource_cancels()
+    {
+        var delay = TimeSpan.FromMilliseconds(30);
+        using var cts = TimeProvider.System.CreateCancellationTokenSource(delay);
+
+        var throwsAfterCancel = () => Task.Delay(TimeSpan.FromHours(1), cts.Token);
+        await throwsAfterCancel.Should().ThrowAsync<TaskCanceledException>();
+    }
+
     [Fact]
     public async Task CancelAfter_reschedule_cancel()
     {