🧵 adapt Lock for .NET >= 9

gimlichael · gimlichael · commit c8dcc2c7e4e3 · 2025-08-16T10:24:28.000+02:00
diff --git a/src/Cuemon.Core/Disposable.cs b/src/Cuemon.Core/Disposable.cs
@@ -8,7 +8,11 @@ namespace Cuemon
     /// <seealso cref="IDisposable" />
     public abstract class Disposable : IDisposable
     {
+#if NET9_0_OR_GREATER
+        private readonly System.Threading.Lock _lock = new();
+#else
         private readonly object _lock = new();
+#endif
 
         /// <summary>
         /// Gets a value indicating whether this <see cref="Disposable"/> object is disposed.
diff --git a/src/Cuemon.Core/Runtime/Dependency.cs b/src/Cuemon.Core/Runtime/Dependency.cs
@@ -12,7 +12,11 @@ public abstract class Dependency : IDependency
     {
         private IEnumerable<IWatcher> _watchers;
         private readonly Func<EventHandler<WatcherEventArgs>, IEnumerable<IWatcher>> _watchersHandler;
-        private readonly object _locker = new();
+#if NET9_0_OR_GREATER
+        private readonly System.Threading.Lock _lock = new();
+#else
+        private readonly object _lock = new();
+#endif
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Dependency" /> class.
@@ -101,7 +105,7 @@ protected virtual void OnWatcherChanged(object sender, WatcherEventArgs args)
             SetUtcLastModified(utcLastModified);
             if (BreakTieOnChanged && _watchers != null)
             {
-                lock (_locker)
+                lock (_lock)
                 {
                     if (_watchers != null)
                     {
diff --git a/src/Cuemon.Core/Runtime/FileWatcher.cs b/src/Cuemon.Core/Runtime/FileWatcher.cs
@@ -11,7 +11,11 @@ namespace Cuemon.Runtime
     /// <seealso cref="Watcher" />
     public class FileWatcher : Watcher
     {
-        private readonly object _locker = new();
+#if NET9_0_OR_GREATER
+        private readonly System.Threading.Lock _lock = new();
+#else
+        private readonly object _lock = new();
+#endif
 
         /// <summary>
         /// Initializes a new instance of the <see cref="FileWatcher"/> class.
@@ -58,7 +62,7 @@ public FileWatcher(string path, bool readFile = false, Action<WatcherOptions> se
         /// </summary>
         protected override Task HandleSignalingAsync()
         {
-            lock (_locker)
+            lock (_lock)
             {
                 var utcLastModified = File.GetLastWriteTimeUtc(Path);
                 if (ReadFile)
diff --git a/src/Cuemon.Core/Runtime/Watcher.cs b/src/Cuemon.Core/Runtime/Watcher.cs
@@ -10,7 +10,11 @@ namespace Cuemon.Runtime
     /// </summary>
     public abstract class Watcher : Disposable, IWatcher
     {
-        private readonly object _locker = new();
+#if NET9_0_OR_GREATER
+        private readonly Lock _lock = new();
+#else
+        private readonly object _lock = new();
+#endif
         private Timer _watcherTimer;
         private Timer _watcherPostponingTimer;
 
@@ -68,7 +72,7 @@ protected Watcher(Action<WatcherOptions> setup)
         /// </summary>
         public void StartMonitoring()
         {
-            lock (_locker)
+            lock (_lock)
             {
                 _watcherTimer ??= TimerFactory.CreateNonCapturingTimer(TimerInvoking, null, DueTime, Period);
             }
@@ -169,7 +173,7 @@ protected virtual void OnChangedRaised(WatcherEventArgs e)
             if (_watcherPostponingTimer != null) { return; } // we already have a postponed signaling
             if (DueTimeOnChanged != TimeSpan.Zero)
             {
-                lock (_locker)
+                lock (_lock)
                 {
                     _watcherPostponingTimer ??= TimerFactory.CreateNonCapturingTimer(PostponedHandleSignaling, e, DueTimeOnChanged, Timeout.InfiniteTimeSpan);
                 }
diff --git a/src/Cuemon.Data/DatabaseWatcher.cs b/src/Cuemon.Data/DatabaseWatcher.cs
@@ -14,7 +14,11 @@ namespace Cuemon.Data
     /// <seealso cref="Watcher" />
     public class DatabaseWatcher : Watcher
     {
-        private readonly object _locker = new();
+#if NET9_0_OR_GREATER
+        private readonly System.Threading.Lock _lock = new();
+#else
+        private readonly object _lock = new();
+#endif
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DatabaseWatcher"/> class.
@@ -54,7 +58,7 @@ public DatabaseWatcher(IDbConnection connection, Func<IDbConnection, IDataReader
         /// <returns>The task object representing the asynchronous operation.</returns>
         protected override Task HandleSignalingAsync()
         {
-            lock (_locker)
+            lock (_lock)
             {
                 try
                 {
diff --git a/src/Cuemon.Extensions.AspNetCore.Text.Json/Bootstrapper.cs b/src/Cuemon.Extensions.AspNetCore.Text.Json/Bootstrapper.cs
@@ -1,11 +1,12 @@
-﻿using Cuemon.Extensions.AspNetCore.Text.Json.Converters;
+﻿using System.Threading;
+using Cuemon.Extensions.AspNetCore.Text.Json.Converters;
 using Cuemon.Extensions.Text.Json.Formatters;
 
 namespace Cuemon.Extensions.AspNetCore.Text.Json
 {
     internal static class Bootstrapper
     {
-        private static readonly object PadLock = new();
+        private static readonly Lock PadLock = new();
         private static bool _initialized;
 
         internal static void Initialize()
diff --git a/src/Cuemon.Extensions.AspNetCore.Xml/Bootstrapper.cs b/src/Cuemon.Extensions.AspNetCore.Xml/Bootstrapper.cs
@@ -1,11 +1,12 @@
-﻿using Cuemon.Extensions.AspNetCore.Xml.Converters;
+﻿using System.Threading;
+using Cuemon.Extensions.AspNetCore.Xml.Converters;
 using Cuemon.Xml.Serialization.Formatters;
 
 namespace Cuemon.Extensions.AspNetCore.Xml
 {
     internal static class Bootstrapper
     {
-        private static readonly object PadLock = new();
+        private static readonly Lock PadLock = new();
         private static bool _initialized;
 
         internal static void Initialize()
diff --git a/src/Cuemon.Extensions.Net/Http/SlimHttpClientFactory.cs b/src/Cuemon.Extensions.Net/Http/SlimHttpClientFactory.cs
@@ -29,7 +29,11 @@ public class SlimHttpClientFactory : IHttpClientFactory
         private readonly ConcurrentDictionary<string, Lazy<ActiveHandler>> _activeHandlers = new();
         private readonly ConcurrentQueue<ExpiredHandler> _expiredHandlers = new();
         private readonly Func<HttpClientHandler> _handlerFactory;
-        private readonly object _locker = new();
+#if NET9_0_OR_GREATER
+        private readonly Lock _lock = new();
+#else
+        private readonly object _lock = new();
+#endif
         private readonly SlimHttpClientFactoryOptions _options;
         internal static readonly TimeSpan ExpirationTimerDueTime = TimeSpan.FromSeconds(15);
         private Timer _expirationTimer;
@@ -70,7 +74,7 @@ public HttpMessageHandler CreateHandler(string name)
 
         private void StartExpirationTimer(string name)
         {
-            lock (_locker)
+            lock (_lock)
             {
                 if (_expirationTimer == null)
                 {
@@ -82,7 +86,7 @@ private void StartExpirationTimer(string name)
 
         private void StopExpirationTimer()
         {
-            lock (_locker)
+            lock (_lock)
             {
                 _expirationTimer.Dispose();
                 _expirationTimer = null;
@@ -112,7 +116,7 @@ private void SetActiveHandlerToExpiredHandler(string name)
 
         private void ExpiredHandlersSweep()
         {
-            lock (_locker)
+            lock (_lock)
             {
                 var queueCount = _expiredHandlers.Count;
                 Debug.WriteLine($"{nameof(ExpiredHandlersSweep)} has {queueCount} expired handlers to sweep.");
diff --git a/src/Cuemon.Extensions.Runtime.Caching/CacheEnumerableExtensions.cs b/src/Cuemon.Extensions.Runtime.Caching/CacheEnumerableExtensions.cs
@@ -712,7 +712,11 @@ public static Func<T1, T2, T3, T4, T5, TResult> Memoize<TKey, T1, T2, T3, T4, T5
             };
         }
 
-        private static readonly object PadLock = new();
+#if NET9_0_OR_GREATER
+        private readonly static System.Threading.Lock PadLock = new();
+#else
+        private readonly static object PadLock = new();
+#endif
 
         private static TResult Memoize<TKey, TTuple, TResult>(ICacheEnumerable<TKey> cache, string key, CacheInvalidation invalidation, FuncFactory<TTuple, TResult> valueFactory) where TTuple : MutableTuple
         {
diff --git a/src/Cuemon.Extensions.Text.Json/Formatters/JsonFormatterOptions.cs b/src/Cuemon.Extensions.Text.Json/Formatters/JsonFormatterOptions.cs
@@ -16,7 +16,11 @@ namespace Cuemon.Extensions.Text.Json.Formatters
     /// </summary>
     public class JsonFormatterOptions : IContentNegotiation, IExceptionDescriptorOptions, IValidatableParameterObject
     {
-        private readonly object _locker = new();
+#if NET9_0_OR_GREATER
+        private readonly System.Threading.Lock _lock = new();
+#else
+        private readonly object _lock = new();
+#endif
         private bool _refreshed;
 
         /// <summary>
@@ -117,7 +121,7 @@ public JsonFormatterOptions()
 
         internal JsonSerializerOptions RefreshWithConverterDependencies()
         {
-            lock (_locker)
+            lock (_lock)
             {
                 if (!_refreshed)
                 {
diff --git a/src/Cuemon.Resilience/AsyncTransientWorker.cs b/src/Cuemon.Resilience/AsyncTransientWorker.cs
@@ -27,7 +27,7 @@ protected async Task<bool> ResilientCatchAsync(int attempts, TimeSpan waitTime,
 
         private async Task ResilientCatchInnerTry(int attempts, TimeSpan waitTime, Exception ex, Func<Task> awaiter)
         {
-            lock (AggregatedExceptions) { AggregatedExceptions.Insert(0, ex); }
+            lock (_lock) { AggregatedExceptions.Insert(0, ex); }
             IsTransientFault = Options.DetectionStrategy(ex);
             if (attempts >= Options.RetryAttempts) { ExceptionDispatchInfo.Capture(ex).Throw(); }
             if (!IsTransientFault) { ExceptionDispatchInfo.Capture(ex).Throw(); }
@@ -37,4 +37,4 @@ private async Task ResilientCatchInnerTry(int attempts, TimeSpan waitTime, Excep
             Latency = DateTime.UtcNow.Subtract(TimeStamp).Subtract(TotalWaitTime);
         }
     }
-}
+}
diff --git a/src/Cuemon.Resilience/Transient.cs b/src/Cuemon.Resilience/Transient.cs
@@ -8,6 +8,12 @@ namespace Cuemon.Resilience
 {
     internal abstract class Transient<TOptions> where TOptions : TransientOperationOptions, new()
     {
+#if NET9_0_OR_GREATER
+        protected readonly System.Threading.Lock _lock = new();
+#else
+        protected readonly object _lock = new();
+#endif
+
         protected Transient(MethodInfo delegateInfo, object[] runtimeArguments, Action<TOptions> setup)
         {
             Validator.ThrowIfInvalidConfigurator(setup, out var options);
@@ -64,9 +70,9 @@ protected void ResilientCatchInnerCatch(int attempts)
                 if (Options is AsyncTransientOperationOptions asyncOptions) { runtimeArguments = Arguments.Concat(RuntimeArguments, Arguments.ToArray(asyncOptions.CancellationToken)); } // we need to match the signature of async methods on TransientOperation
                 var evidence = new TransientFaultEvidence(attempts, LastWaitTime, TotalWaitTime, Latency, new MethodDescriptor(DelegateInfo).AppendRuntimeArguments(runtimeArguments));
                 var transientException = new TransientFaultException("The amount of retry attempts has been reached.", evidence);
-                lock (AggregatedExceptions) { AggregatedExceptions.Insert(0, transientException); }
+                lock (_lock) { AggregatedExceptions.Insert(0, transientException); }
                 TransientOperation.FaultCallback?.Invoke(evidence);
             }
         }
     }
-}
+}
diff --git a/src/Cuemon.Resilience/TransientWorker.cs b/src/Cuemon.Resilience/TransientWorker.cs
@@ -26,7 +26,7 @@ protected bool ResilientCatch(int attempts, TimeSpan waitTime, Exception ex, Act
 
         private void ResilientCatchInnerTry(int attempts, TimeSpan waitTime, Exception ex, Action awaiter)
         {
-            lock (AggregatedExceptions) { AggregatedExceptions.Insert(0, ex); }
+            lock (_lock) { AggregatedExceptions.Insert(0, ex); }
             IsTransientFault = Options.DetectionStrategy(ex);
             if (attempts >= Options.RetryAttempts) { ExceptionDispatchInfo.Capture(ex).Throw(); }
             if (!IsTransientFault) { ExceptionDispatchInfo.Capture(ex).Throw(); }
@@ -36,4 +36,4 @@ private void ResilientCatchInnerTry(int attempts, TimeSpan waitTime, Exception e
             Latency = DateTime.UtcNow.Subtract(TimeStamp).Subtract(TotalWaitTime);
         }
     }
-}
+}
diff --git a/src/Cuemon.Xml/Serialization/Formatters/XmlFormatterOptions.cs b/src/Cuemon.Xml/Serialization/Formatters/XmlFormatterOptions.cs
@@ -13,7 +13,11 @@ namespace Cuemon.Xml.Serialization.Formatters
     /// </summary>
     public class XmlFormatterOptions : IExceptionDescriptorOptions, IContentNegotiation, IValidatableParameterObject
     {
-        private readonly object _locker = new();
+#if NET9_0_OR_GREATER
+        private readonly System.Threading.Lock _lock = new();
+#else
+        private readonly object _lock = new();
+#endif
         private bool _refreshed;
 
         /// <summary>
@@ -117,7 +121,7 @@ public XmlFormatterOptions()
 
         internal XmlSerializerOptions RefreshWithConverterDependencies()
         {
-            lock (_locker)
+            lock (_lock)
             {
                 if (!_refreshed)
                 {

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,11 @@ public abstract class Dependency : IDependency`
`12`	`12`	`{`
`13`	`13`	`private IEnumerable<IWatcher> _watchers;`
`14`	`14`	`private readonly Func<EventHandler<WatcherEventArgs>, IEnumerable<IWatcher>> _watchersHandler;`
`15`		`- private readonly object _locker = new();`
	`15`	`+#if NET9_0_OR_GREATER`
	`16`	`+ private readonly System.Threading.Lock _lock = new();`
	`17`	`+#else`
	`18`	`+ private readonly object _lock = new();`
	`19`	`+#endif`
`16`	`20`
`17`	`21`	`/// <summary>`
`18`	`22`	`/// Initializes a new instance of the <see cref="Dependency" /> class.`
`@@ -101,7 +105,7 @@ protected virtual void OnWatcherChanged(object sender, WatcherEventArgs args)`
`101`	`105`	`SetUtcLastModified(utcLastModified);`
`102`	`106`	`if (BreakTieOnChanged && _watchers != null)`
`103`	`107`	`{`
`104`		`- lock (_locker)`
	`108`	`+ lock (_lock)`
`105`	`109`	`{`
`106`	`110`	`if (_watchers != null)`
`107`	`111`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,11 @@ namespace Cuemon.Runtime`
`10`	`10`	`/// </summary>`
`11`	`11`	`public abstract class Watcher : Disposable, IWatcher`
`12`	`12`	`{`
`13`		`- private readonly object _locker = new();`
	`13`	`+#if NET9_0_OR_GREATER`
	`14`	`+ private readonly Lock _lock = new();`
	`15`	`+#else`
	`16`	`+ private readonly object _lock = new();`
	`17`	`+#endif`
`14`	`18`	`private Timer _watcherTimer;`
`15`	`19`	`private Timer _watcherPostponingTimer;`
`16`	`20`
`@@ -68,7 +72,7 @@ protected Watcher(Action<WatcherOptions> setup)`
`68`	`72`	`/// </summary>`
`69`	`73`	`public void StartMonitoring()`
`70`	`74`	`{`
`71`		`- lock (_locker)`
	`75`	`+ lock (_lock)`
`72`	`76`	`{`
`73`	`77`	`_watcherTimer ??= TimerFactory.CreateNonCapturingTimer(TimerInvoking, null, DueTime, Period);`
`74`	`78`	`}`
`@@ -169,7 +173,7 @@ protected virtual void OnChangedRaised(WatcherEventArgs e)`
`169`	`173`	`if (_watcherPostponingTimer != null) { return; } // we already have a postponed signaling`
`170`	`174`	`if (DueTimeOnChanged != TimeSpan.Zero)`
`171`	`175`	`{`
`172`		`- lock (_locker)`
	`176`	`+ lock (_lock)`
`173`	`177`	`{`
`174`	`178`	`_watcherPostponingTimer ??= TimerFactory.CreateNonCapturingTimer(PostponedHandleSignaling, e, DueTimeOnChanged, Timeout.InfiniteTimeSpan);`
`175`	`179`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,11 @@ namespace Cuemon.Data`
`14`	`14`	`/// <seealso cref="Watcher" />`
`15`	`15`	`public class DatabaseWatcher : Watcher`
`16`	`16`	`{`
`17`		`- private readonly object _locker = new();`
	`17`	`+#if NET9_0_OR_GREATER`
	`18`	`+ private readonly System.Threading.Lock _lock = new();`
	`19`	`+#else`
	`20`	`+ private readonly object _lock = new();`
	`21`	`+#endif`
`18`	`22`
`19`	`23`	`/// <summary>`
`20`	`24`	`/// Initializes a new instance of the <see cref="DatabaseWatcher"/> class.`
`@@ -54,7 +58,7 @@ public DatabaseWatcher(IDbConnection connection, Func<IDbConnection, IDataReader`
`54`	`58`	`/// <returns>The task object representing the asynchronous operation.</returns>`
`55`	`59`	`protected override Task HandleSignalingAsync()`
`56`	`60`	`{`
`57`		`- lock (_locker)`
	`61`	`+ lock (_lock)`
`58`	`62`	`{`
`59`	`63`	`try`
`60`	`64`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,12 @@`
`1`		`-using Cuemon.Extensions.AspNetCore.Text.Json.Converters;`
	`1`	`+using System.Threading;`
	`2`	`+using Cuemon.Extensions.AspNetCore.Text.Json.Converters;`
`2`	`3`	`using Cuemon.Extensions.Text.Json.Formatters;`
`3`	`4`
`4`	`5`	`namespace Cuemon.Extensions.AspNetCore.Text.Json`
`5`	`6`	`{`
`6`	`7`	`internal static class Bootstrapper`
`7`	`8`	`{`
`8`		`- private static readonly object PadLock = new();`
	`9`	`+ private static readonly Lock PadLock = new();`
`9`	`10`	`private static bool _initialized;`
`10`	`11`
`11`	`12`	`internal static void Initialize()`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,12 @@`
`1`		`-using Cuemon.Extensions.AspNetCore.Xml.Converters;`
	`1`	`+using System.Threading;`
	`2`	`+using Cuemon.Extensions.AspNetCore.Xml.Converters;`
`2`	`3`	`using Cuemon.Xml.Serialization.Formatters;`
`3`	`4`
`4`	`5`	`namespace Cuemon.Extensions.AspNetCore.Xml`
`5`	`6`	`{`
`6`	`7`	`internal static class Bootstrapper`
`7`	`8`	`{`
`8`		`- private static readonly object PadLock = new();`
	`9`	`+ private static readonly Lock PadLock = new();`
`9`	`10`	`private static bool _initialized;`
`10`	`11`
`11`	`12`	`internal static void Initialize()`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,11 @@ public class SlimHttpClientFactory : IHttpClientFactory`
`29`	`29`	`private readonly ConcurrentDictionary<string, Lazy<ActiveHandler>> _activeHandlers = new();`
`30`	`30`	`private readonly ConcurrentQueue<ExpiredHandler> _expiredHandlers = new();`
`31`	`31`	`private readonly Func<HttpClientHandler> _handlerFactory;`
`32`		`- private readonly object _locker = new();`
	`32`	`+#if NET9_0_OR_GREATER`
	`33`	`+ private readonly Lock _lock = new();`
	`34`	`+#else`
	`35`	`+ private readonly object _lock = new();`
	`36`	`+#endif`
`33`	`37`	`private readonly SlimHttpClientFactoryOptions _options;`
`34`	`38`	`internal static readonly TimeSpan ExpirationTimerDueTime = TimeSpan.FromSeconds(15);`
`35`	`39`	`private Timer _expirationTimer;`
`@@ -70,7 +74,7 @@ public HttpMessageHandler CreateHandler(string name)`
`70`	`74`
`71`	`75`	`private void StartExpirationTimer(string name)`
`72`	`76`	`{`
`73`		`- lock (_locker)`
	`77`	`+ lock (_lock)`
`74`	`78`	`{`
`75`	`79`	`if (_expirationTimer == null)`
`76`	`80`	`{`
`@@ -82,7 +86,7 @@ private void StartExpirationTimer(string name)`
`82`	`86`
`83`	`87`	`private void StopExpirationTimer()`
`84`	`88`	`{`
`85`		`- lock (_locker)`
	`89`	`+ lock (_lock)`
`86`	`90`	`{`
`87`	`91`	`_expirationTimer.Dispose();`
`88`	`92`	`_expirationTimer = null;`
`@@ -112,7 +116,7 @@ private void SetActiveHandlerToExpiredHandler(string name)`
`112`	`116`
`113`	`117`	`private void ExpiredHandlersSweep()`
`114`	`118`	`{`
`115`		`- lock (_locker)`
	`119`	`+ lock (_lock)`
`116`	`120`	`{`
`117`	`121`	`var queueCount = _expiredHandlers.Count;`
`118`	`122`	`Debug.WriteLine($"{nameof(ExpiredHandlersSweep)} has {queueCount} expired handlers to sweep.");`
Original file line number	Diff line number	Diff line change
`@@ -712,7 +712,11 @@ public static Func<T1, T2, T3, T4, T5, TResult> Memoize<TKey, T1, T2, T3, T4, T5`
`712`	`712`	`};`
`713`	`713`	`}`
`714`	`714`
`715`		`- private static readonly object PadLock = new();`
	`715`	`+#if NET9_0_OR_GREATER`
	`716`	`+ private readonly static System.Threading.Lock PadLock = new();`
	`717`	`+#else`
	`718`	`+ private readonly static object PadLock = new();`
	`719`	`+#endif`
`716`	`720`
`717`	`721`	`private static TResult Memoize<TKey, TTuple, TResult>(ICacheEnumerable<TKey> cache, string key, CacheInvalidation invalidation, FuncFactory<TTuple, TResult> valueFactory) where TTuple : MutableTuple`
`718`	`722`	`{`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,11 @@ namespace Cuemon.Extensions.Text.Json.Formatters`
`16`	`16`	`/// </summary>`
`17`	`17`	`public class JsonFormatterOptions : IContentNegotiation, IExceptionDescriptorOptions, IValidatableParameterObject`
`18`	`18`	`{`
`19`		`- private readonly object _locker = new();`
	`19`	`+#if NET9_0_OR_GREATER`
	`20`	`+ private readonly System.Threading.Lock _lock = new();`
	`21`	`+#else`
	`22`	`+ private readonly object _lock = new();`
	`23`	`+#endif`
`20`	`24`	`private bool _refreshed;`
`21`	`25`
`22`	`26`	`/// <summary>`
`@@ -117,7 +121,7 @@ public JsonFormatterOptions()`
`117`	`121`
`118`	`122`	`internal JsonSerializerOptions RefreshWithConverterDependencies()`
`119`	`123`	`{`
`120`		`- lock (_locker)`
	`124`	`+ lock (_lock)`
`121`	`125`	`{`
`122`	`126`	`if (!_refreshed)`
`123`	`127`	`{`