Added support of custom exception

Author: sakno

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.Threading/Threading/QueuedSynchronizer.Acquisition.cs

@@ -30,6 +30,8 @@ private protected interface ITaskBuilder<out TOutput> : ITaskBuilder, ISupplier<
         where TOutput : struct, IEquatable<TOutput>
     {
         static abstract bool ThrowOnTimeout { get; }
+
+        static abstract TOutput FromException(Exception e);
     }
 
     [StructLayout(LayoutKind.Auto)]
@@ -84,6 +86,8 @@ readonly ValueTask ISupplier<ValueTask>.Invoke()
         }
 
         static bool ITaskBuilder<ValueTask>.ThrowOnTimeout => true;
+
+        static ValueTask ITaskBuilder<ValueTask>.FromException(Exception e) => ValueTask.FromException(e);
     }
 
     [StructLayout(LayoutKind.Auto)]
@@ -164,6 +168,10 @@ readonly ValueTask<bool> ISupplier<ValueTask<bool>>.Invoke()
         static bool ITaskBuilder<ValueTask>.ThrowOnTimeout => true;
 
         static bool ITaskBuilder<ValueTask<bool>>.ThrowOnTimeout => false;
+        
+        static ValueTask ITaskBuilder<ValueTask>.FromException(Exception e) => ValueTask.FromException(e);
+        
+        static ValueTask<bool> ITaskBuilder<ValueTask<bool>>.FromException(Exception e) => ValueTask.FromException<bool>(e);
     }
 
     [StructLayout(LayoutKind.Auto)]
@@ -198,6 +206,8 @@ void IDisposable.Dispose()
         T ISupplier<T>.Invoke() => Builder.Invoke();
 
         static bool ITaskBuilder<T>.ThrowOnTimeout => TBuilder.ThrowOnTimeout;
+
+        static T ITaskBuilder<T>.FromException(Exception e) => TBuilder.FromException(e);
     }
 
     private protected CancellationTokenOnly CreateTaskBuilder(CancellationToken token)

src/DotNext.Threading/Threading/QueuedSynchronizer.Queue.cs

@@ -180,6 +180,8 @@ private bool SignalCurrent(in Result<bool> result)
 
         public bool SignalCurrent() => SignalCurrent(result: true);
 
+        public void SignalCurrent(Exception e) => SignalCurrent(result: new(e));
+
         public bool SignalCurrent<TLockManager>(ref TLockManager manager)
             where TLockManager : struct, ILockManager
         {

src/DotNext.Threading/Threading/QueuedSynchronizer.T.cs

@@ -41,8 +41,16 @@ protected QueuedSynchronizer()
     /// </summary>
     /// <param name="context">The context associated with the suspended caller or supplied externally.</param>
     /// <returns><see langword="true"/> if acquisition is allowed; otherwise, <see langword="false"/>.</returns>
+    /// <exception cref="Exception">A custom exception is thrown.</exception>
     protected abstract bool CanAcquire(TContext context);
 
+    /// <summary>
+    /// Returns an optional exception if <see cref="CanAcquire"/> returns <see langword="false"/>.
+    /// </summary>
+    /// <param name="context">The acquisition context.</param>
+    /// <returns>The exception; or <see langword="null"/>.</returns>
+    protected virtual Exception? GetAcquisitionException(TContext context) => null;
+
     /// <summary>
     /// Modifies the internal state according to acquisition semantics.
     /// </summary>
@@ -69,11 +77,19 @@ private protected sealed override void DrainWaitQueue(ref WaitQueueVisitor waitQ
     {
         for (; !waitQueueVisitor.IsEndOfQueue<WaitNode, TContext>(out var context); waitQueueVisitor.Advance())
         {
-            if (!CanAcquire(context))
-                break;
-
-            if (waitQueueVisitor.SignalCurrent())
-                AcquireCore(context);
+            switch (CanAcquire(context))
+            {
+                case false when GetAcquisitionException(context) is { } e:
+                    waitQueueVisitor.SignalCurrent(e);
+                    goto default;
+                case false:
+                    return;
+                case true when waitQueueVisitor.SignalCurrent():
+                    AcquireCore(context);
+                    goto default;
+                default:
+                    continue;
+            }
         }
     }
 
@@ -194,6 +210,34 @@ protected ValueTask AcquireAsync(TContext context, CancellationToken token)
         return AcquireAsync<ValueTask, CancellationTokenOnly>(context, ref builder);
     }
 
+    private T AcquireAsync<T, TBuilder>(TContext context, ref TBuilder builder)
+        where T : struct, IEquatable<T>
+        where TBuilder : struct, ITaskBuilder<T>
+    {
+        T result;
+        if (!builder.IsCompleted)
+        {
+            var acquired = TryAcquireCore(context);
+            if (!acquired && GetAcquisitionException(context) is { } e)
+            {
+                result = TBuilder.FromException(e);
+                goto exit;
+            }
+
+            if (Acquire<T, TBuilder, WaitNode>(ref builder, acquired) is { } node)
+            {
+                node.DrainOnReturn = true;
+                node.Context = context;
+            }
+        }
+
+        result = builder.Invoke();
+
+        exit:
+        builder.Dispose();
+        return result;
+    }
+
     private bool TryAcquireCore(TContext context)
     {
         Debug.Assert(Monitor.IsEntered(SyncRoot));
@@ -206,24 +250,4 @@ private bool TryAcquireCore(TContext context)
 
         return false;
     }
-
-    private T AcquireAsync<T, TBuilder>(TContext context, ref TBuilder builder)
-        where T : struct, IEquatable<T>
-        where TBuilder : struct, ITaskBuilder<T>
-    {
-        switch (builder.IsCompleted)
-        {
-            case true:
-                goto default;
-            case false when Acquire<T, TBuilder, WaitNode>(ref builder, TryAcquireCore(context)) is { } node:
-                node.DrainOnReturn = true;
-                node.Context = context;
-                goto default;
-            default:
-                builder.Dispose();
-                break;
-        }
-
-        return builder.Invoke();
-    }
 }