feat: target .netstandard 2.0

Author: egil

.editorconfig

@@ -235,3 +235,4 @@ dotnet_naming_style.begins_with_i.capitalization = pascal_case
 
 [*.{cs,vb}]
 dotnet_diagnostic.CA1014.severity = none
+dotnet_diagnostic.CA1510.severity = none # disabled because we are multi targeting frameworks that does not have ANE.ThrowIfNull

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0]
+
+- Add support for libraries that target netstandard 2.0.
+
 ## [0.6.0]
 
 - Changed `TestTimeProvider` to `ManualTimeProvider`.

README.md

@@ -1,6 +1,6 @@
 # Time Scheduler - a TimeProvider shim
 
-This is a shim for the upcoming `System.TimeProvider` API coming in .NET 8. It includes a test version of the `TimeProvider`, named `ManualTimeProvider`, that allows you to control the progress of time during testing deterministically.
+This is a shim for the upcoming `System.TimeProvider` API coming in .NET 8. It includes a test version of the `TimeProvider` type, named `ManualTimeProvider`, that allows you to control the progress of time during testing deterministically.
 
 *NOTE: Originally, this library provided its own abstraction, `ITimeScheduler` and related types, `DefaultScheduler` and `TestScheduler`. These are now considered obsolete.*
 
@@ -10,11 +10,11 @@ Currently, the following .NET time-based APIs are supported:
 |----------------------|----------------------|
 | `GetUtcNow()` method | `DateTimeOffset.UtcNow` property |
 | `CreateTimer()` method | `System.Threading.Timer` type |
-| `CreatePeriodicTimer(TimeSpan)` method | `System.Threading.PeriodicTimer` type |
+| `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 |
-| `Task.WaitAsync(TimeSpan, TimeProvider)` method | `Task.WaitAsync(TimeSpan)` method |
-| `Task.WaitAsync(TimeSpan, TimeProvider, CancellationToken)` method | `Task.WaitAsync(TimeSpan, CancellationToken)` 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 |
 
 The implementations of `TimeProvider` is abstract. An instance of `TimeProvider` for production use is availalbe on the `TimeProvider.System` property,
 and `ManualTimeProvider` can be used during testing.

TimeScheduler.sln

@@ -11,7 +11,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
 		CHANGELOG.md = CHANGELOG.md
-		global.json = global.json
 		README.md = README.md
 	EndProjectSection
 EndProject

src/TimeScheduler/DefaultScheduler.cs

@@ -29,7 +29,11 @@ public partial class DefaultScheduler : TimeProvider, ITimeScheduler
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void CancelAfter(CancellationTokenSource cancellationTokenSource, TimeSpan delay)
     {
-        ArgumentNullException.ThrowIfNull(cancellationTokenSource);
+        if (cancellationTokenSource is null)
+        {
+            throw new ArgumentNullException(nameof(cancellationTokenSource));
+        }
+
         cancellationTokenSource.CancelAfter(delay);
     }
 
@@ -43,6 +47,7 @@ public Task Delay(TimeSpan delay)
     public Task Delay(TimeSpan delay, CancellationToken cancellationToken)
         => Task.Delay(delay, cancellationToken);
 
+#if NET6_0_OR_GREATER
     /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public PeriodicTimer PeriodicTimer(TimeSpan period)
@@ -52,31 +57,48 @@ public PeriodicTimer PeriodicTimer(TimeSpan period)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Task WaitAsync(Task task, TimeSpan timeout)
     {
-        ArgumentNullException.ThrowIfNull(task);
+        if (task is null)
+        {
+            throw new ArgumentNullException(nameof(task));
+        }
+
         return task.WaitAsync(timeout);
     }
 
     /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Task WaitAsync(Task task, TimeSpan timeout, CancellationToken cancellationToken)
     {
-        ArgumentNullException.ThrowIfNull(task);
+        if (task is null)
+        {
+            throw new ArgumentNullException(nameof(task));
+        }
+
         return task.WaitAsync(timeout, cancellationToken);
     }
 
     /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Task<TResult> WaitAsync<TResult>(Task<TResult> task, TimeSpan timeout)
     {
-        ArgumentNullException.ThrowIfNull(task);
+        if (task is null)
+        {
+            throw new ArgumentNullException(nameof(task));
+        }
+
         return task.WaitAsync(timeout);
     }
 
     /// <inheritdoc/>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Task<TResult> WaitAsync<TResult>(Task<TResult> task, TimeSpan timeout, CancellationToken cancellationToken)
     {
-        ArgumentNullException.ThrowIfNull(task);
+        if (task is null)
+        {
+            throw new ArgumentNullException(nameof(task));
+        }
+
         return task.WaitAsync(timeout, cancellationToken);
     }
+#endif
 }

src/TimeScheduler/ITimeScheduler.cs

@@ -23,7 +23,7 @@ public interface ITimeScheduler
     /// <remarks>
     /// The default implementation returns <see cref="DateTimeOffset.UtcNow"/>.
     /// </remarks>
-    public virtual DateTimeOffset GetUtcNow() => DateTimeOffset.UtcNow;
+    DateTimeOffset GetUtcNow();
 
     /// <summary>
     /// Creates a Task that will complete after a time delay.
@@ -60,6 +60,7 @@ public interface ITimeScheduler
     /// </remarks>
     Task Delay(TimeSpan delay, CancellationToken cancellationToken);
 
+#if NET6_0_OR_GREATER
     /// <summary>
     /// Factory method that creates a periodic timer that enables waiting asynchronously for timer ticks.
     /// Use this factory method as a replacement for instantiating a <see cref="System.Threading.PeriodicTimer"/>.
@@ -115,6 +116,7 @@ public interface ITimeScheduler
     /// <exception cref="ArgumentNullException">The <paramref name="task"/> is null.</exception>
     /// <returns>The <see cref="Task{TResult}"/> representing the asynchronous wait. It may or may not be the same instance as the current instance.</returns>
     Task<TResult> WaitAsync<TResult>(Task<TResult> task, TimeSpan timeout, CancellationToken cancellationToken);
+#endif
 
     /// <summary>
     /// Schedules a Cancel operation on the <paramref name="cancellationTokenSource"/>.

src/TimeScheduler/PeriodicTimerWrapper.cs

@@ -1,3 +1,4 @@
+#if NET6_0_OR_GREATER
 namespace TimeScheduler;
 
 internal sealed class PeriodicTimerWrapper : PeriodicTimer
@@ -18,3 +19,4 @@ protected override void Dispose(bool disposing)
         base.Dispose(disposing);
     }
 }
+#endif

src/TimeScheduler/System.Runtime.CompilerServices/CallerArgumentExpressionAttribute.cs

@@ -0,0 +1,14 @@
+#if !NET6_0_OR_GREATER
+namespace System.Runtime.CompilerServices;
+
+[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
+internal sealed class CallerArgumentExpressionAttribute : Attribute
+{
+    public CallerArgumentExpressionAttribute(string parameterName)
+    {
+        ParameterName = parameterName;
+    }
+
+    public string ParameterName { get; }
+}
+#endif

src/TimeScheduler/System/Testing/TestPeriodicTimer.cs

@@ -1,3 +1,4 @@
+#if NET6_0_OR_GREATER
 namespace System.Testing;
 
 internal sealed class TestPeriodicTimer : TimeScheduler.PeriodicTimer
@@ -62,3 +63,4 @@ protected override void Dispose(bool disposing)
         base.Dispose(disposing);
     }
 }
+#endif

src/TimeScheduler/System/Threading/ITimer.cs

@@ -1,11 +1,22 @@
 namespace System.Threading;
 
+#if NET6_0_OR_GREATER
 /// <summary>Represents a timer that can have its due time and period changed.</summary>
 /// <remarks>
 /// Implementations of <see cref="Change"/>, <see cref="IDisposable.Dispose"/>, and <see cref="IAsyncDisposable.DisposeAsync"/>
 /// must all be thread-safe such that the timer instance may be accessed concurrently from multiple threads.
 /// </remarks>
-public interface ITimer : IDisposable, IAsyncDisposable
+#else
+/// <summary>Represents a timer that can have its due time and period changed.</summary>
+/// <remarks>
+/// Implementations of <see cref="Change"/> and <see cref="IDisposable.Dispose"/>
+/// must all be thread-safe such that the timer instance may be accessed concurrently from multiple threads.
+/// </remarks>
+#endif
+public interface ITimer : IDisposable
+#if NET6_0_OR_GREATER
+    , IAsyncDisposable
+#endif
 {
     /// <summary>Changes the start time and the interval between method invocations for a timer, using <see cref="TimeSpan"/> values to measure time intervals.</summary>
     /// <param name="dueTime">