Release 5.25.1

Author: sakno

CHANGELOG.md

@@ -1,6 +1,31 @@
 Release Notes
 ====
 
+# 09-15-2025
+<a href="https://www.nuget.org/packages/dotnext/5.25.0">DotNext 5.25.0</a>
+* Added `CatchException` extension method to capture the exception produced by `await` operator instead of raising it at the call site
+* Various performance improvements
+
+<a href="https://www.nuget.org/packages/dotnext.metaprogramming/5.25.0">DotNext.Metaprogramming 5.25.0</a>
+* Fixed mutability modifiers for properties of `UnmanagedMemory<T>` type
+
+<a href="https://www.nuget.org/packages/dotnext.unsafe/5.25.0">DotNext.Unsafe 5.25.0</a>
+* Updated dependencies
+
+<a href="https://www.nuget.org/packages/dotnext.threading/5.25.0">DotNext.Threading 5.25.0</a>
+* Added optional hard concurrency limit for async lock primitives
+* Rewritten the internal engine for async lock primitives to decrease the lock contention and increase the response time
+* Async lock primitive no longer produce lock contention time to improve the response time
+
+<a href="https://www.nuget.org/packages/dotnext.io/5.25.0">DotNext.IO 5.25.0</a>
+* Updated dependencies
+
+<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.25.0">DotNext.Net.Cluster 5.25.0</a>
+* Updated dependencies
+
+<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.25.0">DotNext.AspNetCore.Cluster 5.25.0</a>
+* Updated dependencies
+
 # 08-23-2025
 <a href="https://www.nuget.org/packages/dotnext.net.cluster/5.24.1">DotNext.Net.Cluster 5.24.1</a>
 * Fixed stream ID inflation of the multiplexing protocol client if underlying TCP connection is unstable

README.md

@@ -44,31 +44,30 @@ All these things are implemented in 100% managed code on top of existing .NET AP
 * [NuGet Packages](https://www.nuget.org/profiles/rvsakno)
 
 # What's new
-Release Date: 08-19-2025
+Release Date: 09-15-2025
 
-<a href="https://www.nuget.org/packages/dotnext/5.24.0">DotNext 5.24.0</a>
-* Merged [258](https://github.com/dotnet/dotNext/pull/258)
-* Added `CopyTo` extension method overload for [ReadOnlySequence&lt;T&gt;](https://learn.microsoft.com/en-us/dotnet/api/system.buffers.readonlysequence-1) data type that returns the position within the sequence
-* Fixed correctness of atomic read/write operations exposed by `Atomic` static class for **double** data type on 32-bit platforms
-* `LockAcquisition` static methods are no longer extension methods to avoid ambiguity (see [267](https://github.com/dotnet/dotNext/discussions/267))
+<a href="https://www.nuget.org/packages/dotnext/5.25.0">DotNext 5.25.0</a>
+* Added `CatchException` extension method to capture the exception produced by `await` operator instead of raising it at the call site
+* Various performance improvements
 
-<a href="https://www.nuget.org/packages/dotnext.metaprogramming/5.24.0">DotNext.Metaprogramming 5.24.0</a>
-* Updated dependencies
+<a href="https://www.nuget.org/packages/dotnext.metaprogramming/5.25.0">DotNext.Metaprogramming 5.25.0</a>
+* Fixed mutability modifiers for properties of `UnmanagedMemory<T>` type
 
-<a href="https://www.nuget.org/packages/dotnext.unsafe/5.24.0">DotNext.Unsafe 5.24.0</a>
-* Added custom marshallers for `IUnmanagedMemory<T>` interface and `Pointer<T>` data type that are compatible with PInvoke source generator
+<a href="https://www.nuget.org/packages/dotnext.unsafe/5.25.0">DotNext.Unsafe 5.25.0</a>
+* Updated dependencies
 
-<a href="https://www.nuget.org/packages/dotnext.threading/5.24.0">DotNext.Threading 5.24.0</a>
-* `AsyncLockAcquisition` static methods are no longer extension methods to avoid ambiguity (see [267](https://github.com/dotnet/dotNext/discussions/267))
-* Lock contention reported by all async lock primitives is now an up-down counter rather than regular counter
+<a href="https://www.nuget.org/packages/dotnext.threading/5.25.0">DotNext.Threading 5.25.0</a>
+* Added optional hard concurrency limit for async lock primitives
+* Rewritten the internal engine for async lock primitives to decrease the lock contention and increase the response time
+* Async lock primitive no longer produce lock contention time to improve the response time
 
-<a href="https://www.nuget.org/packages/dotnext.io/5.24.0">DotNext.IO 5.24.0</a>
-* Improved behavioral compatibility with [Pipe](https://learn.microsoft.com/en-us/dotnet/api/system.io.pipelines.pipe) class by extension methods exposed by `PipeExtensions` class
+<a href="https://www.nuget.org/packages/dotnext.io/5.25.0">DotNext.IO 5.25.0</a>
+* Updated dependencies
 
-<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.24.1">DotNext.Net.Cluster 5.24.1</a>
-* Added `DotNext.Net.Multiplexing` namespace that exposes simple unencrypted multiplexing protocol implementation on top of TCP. The multiplexed channel is exposed as [IDuplexPipe](https://learn.microsoft.com/en-us/dotnet/api/system.io.pipelines.iduplexpipe). The main purpose of this implementation is the efficient communication between nodes within the cluster inside the trusted LAN
+<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.25.0">DotNext.Net.Cluster 5.25.0</a>
+* Updated dependencies
 
-<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.24.1">DotNext.AspNetCore.Cluster 5.24.1</a>
+<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.25.0">DotNext.AspNetCore.Cluster 5.25.0</a>
 * Updated dependencies
 
 <a href="https://www.nuget.org/packages/dotnext.maintenanceservices/0.6.0">DotNext.MaintenanceServices 0.6.0</a>

src/DotNext.Tests/DelegateHelpersTests.cs

@@ -149,7 +149,8 @@ public static void TryInvokeFunc()
         static MethodInfo GetMethod(int argCount)
         {
             const BindingFlags flags = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
-            return Single(typeof(Func).GetMethods(flags), candidate => candidate.Name == nameof(Func.TryInvoke) && candidate.GetParameters().Length == argCount + 1);
+            return Single(typeof(Func).GetMethods(flags),
+                candidate => candidate.Name is nameof(Func.TryInvoke) && candidate.GetParameters().Length == argCount + 1);
         }
 
         var successValue = Expression.Constant(42, typeof(int));
@@ -611,7 +612,7 @@ static MethodInfo GetMethod(int argCount)
         {
             const BindingFlags flags = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
             return Single(typeof(DelegateHelpers).GetMethods(flags),
-                candidate => candidate.Name == nameof(DelegateHelpers.TryInvoke) && candidate.GetParameters().Length == argCount + 1);
+                candidate => candidate.Name is nameof(DelegateHelpers.TryInvoke) && candidate.GetParameters().Length == argCount + 1);
         }
 
         var successValue = Expression.Empty();

src/DotNext.Tests/Threading/QueuedSynchronizerTests.cs

@@ -0,0 +1,25 @@
+namespace DotNext.Threading;
+
+public sealed class QueuedSynchronizerTests : Test
+{
+    [Fact]
+    public static async Task ThrowOnAcquisitionAsync()
+    {
+        await using var synchronizer = new MySynchronizer();
+        await ThrowsAsync<ArithmeticException>(synchronizer.ThrowAsync().AsTask);
+        False(synchronizer.TryAcquire());
+    }
+    
+    private sealed class MySynchronizer : QueuedSynchronizer<bool>
+    {
+        public ValueTask ThrowAsync(CancellationToken token = default)
+            => AcquireAsync(context: false, token);
+
+        public bool TryAcquire() => TryAcquire(context: false);
+
+        protected override bool CanAcquire(bool context) => context;
+
+        protected override Exception GetAcquisitionException(bool canAcquire)
+            => canAcquire ? null : new ArithmeticException();
+    }
+}

src/DotNext.Tests/Threading/Tasks/ConversionTests.cs

@@ -50,11 +50,11 @@ public static async Task SuspendException()
         await Task.FromException(new Exception()).SuspendException(Predicate.Constant<Exception>(true)).ConfigureAwait(true);
         await ValueTask.FromException(new Exception()).SuspendException(Predicate.Constant<Exception>(true)).ConfigureAwait(true);
 
-        var result = await Task.FromException<int>(new ArithmeticException()).SuspendException().ConfigureAwait(true);
+        var result = await Task.FromException<int>(new ArithmeticException()).CatchException().ConfigureAwait(true);
         False(result.IsSuccessful);
         IsType<ArithmeticException>(result.Error);
 
-        result = await ValueTask.FromException<int>(new ArithmeticException()).SuspendException().ConfigureAwait(true);
+        result = await ValueTask.FromException<int>(new ArithmeticException()).CatchException().ConfigureAwait(true);
         False(result.IsSuccessful);
         IsType<ArithmeticException>(result.Error);
     }
@@ -80,11 +80,11 @@ public static async Task SuspendException2()
     [Fact]
     public static async Task ConvertExceptionToError()
     {
-        var result = await Task.FromException<int>(new Exception()).SuspendException(ToError).ConfigureAwait(true);
+        var result = await Task.FromException<int>(new Exception()).CatchException(ToError).ConfigureAwait(true);
         False(result.IsSuccessful);
         Equal(EnvironmentVariableTarget.Machine, result.Error);
 
-        result = await ValueTask.FromException<int>(new Exception()).SuspendException(ToError).ConfigureAwait(true);
+        result = await ValueTask.FromException<int>(new Exception()).CatchException(ToError).ConfigureAwait(true);
         False(result.IsSuccessful);
         Equal(EnvironmentVariableTarget.Machine, result.Error);
 

src/DotNext.Tests/Threading/Tasks/GenericValueTaskCompletionSourceTests.cs

@@ -68,7 +68,7 @@ public static async Task CompleteWithToken(bool runContinuationsAsynchronously)
         var source = new ValueTaskCompletionSource<int>(runContinuationsAsynchronously);
         var completionToken = source.Reset();
         var task = source.CreateTask(InfiniteTimeSpan, default);
-        False(source.TrySetResult(short.MaxValue, 42));
+        False(source.TrySetResult(completionData: null, short.MaxValue, 42));
         False(task.IsCompleted);
         True(source.TrySetResult(completionToken, 42));
         Equal(42, await task);

src/DotNext.Tests/Threading/Tasks/ValueTaskCompletionSourceTests.cs

@@ -61,7 +61,7 @@ public static async Task CompleteWithToken(bool runContinuationsAsynchronously)
         var source = new ValueTaskCompletionSource(runContinuationsAsynchronously);
         var completionToken = source.Reset();
         var task = source.CreateTask(InfiniteTimeSpan, default);
-        False(source.TrySetResult(short.MaxValue));
+        False(source.TrySetResult(completionData: null, short.MaxValue));
         False(task.IsCompleted);
         True(source.TrySetResult(completionToken));
         await task;
@@ -167,4 +167,29 @@ public static async Task CanceledToken()
         var task = source.CreateTask(InfiniteTimeSpan, new(true)).AsTask();
         await ThrowsAsync<OperationCanceledException>(Func.Constant(task));
     }
+
+    [Fact]
+    public static async Task LazyCompletion()
+    {
+        var source = new TestCompletionSource();
+        var task = source.CreateTask(InfiniteTimeSpan, CancellationToken.None).AsTask();
+        
+        True(source.TrySetResult(string.Empty, completionToken: null, e: null, out var resumable));
+        True(resumable);
+        Same(string.Empty, source.CompletionData);
+        False(task.IsCompleted);
+        
+        source.NotifyConsumer();
+        await task;
+    }
+    
+    private sealed class TestCompletionSource : ValueTaskCompletionSource
+    {
+        public new bool TrySetResult(object completionData, short? completionToken, Exception e, out bool resumable)
+            => base.TrySetResult(completionData, completionToken, e, out resumable);
+
+        public new object CompletionData => base.CompletionData;
+
+        public new void NotifyConsumer() => base.NotifyConsumer();
+    }
 }

src/DotNext.Threading/DotNext.Threading.csproj

@@ -7,7 +7,7 @@
     <ImplicitUsings>true</ImplicitUsings>
     <IsAotCompatible>true</IsAotCompatible>
     <Features>nullablePublicOnly</Features>
-    <VersionPrefix>5.25.0</VersionPrefix>
+    <VersionPrefix>5.25.1</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <Authors>.NET Foundation and Contributors</Authors>
     <Product>.NEXT Family of Libraries</Product>

src/DotNext.Threading/Threading/AsyncAutoResetEvent.cs

@@ -93,7 +93,7 @@ public bool Set()
                 }
             }
 
-            suspendedCaller?.Resume();
+            suspendedCaller?.NotifyConsumer();
         }
 
         return result;

src/DotNext.Threading/Threading/AsyncCorrelationSource.cs

@@ -77,7 +77,7 @@ public bool Pulse(TKey eventId, in Result<TValue> value, out object? userData)
             userData = node.UserData;
             result = node.TrySetResult(Sentinel.Instance, completionToken, in value, out var resumable);
             if (resumable)
-                node.Resume();
+                node.NotifyConsumer();
         }
         else
         {