Modified lockasync to proritize Task over ValueTask

Author: Simnico99

src/ZirconNet.Core/Async/LockAsync.cs

@@ -2,6 +2,8 @@
 // This software is distributed under the MIT license and its code is open-source and free for use, modification, and distribution.
 // </copyright>
 
+using ZirconNet.Core.Runtime;
+
 namespace ZirconNet.Core.Async;
 
 /// <summary>
@@ -17,61 +19,97 @@ public LockAsync()
         _semaphore = new(1, 1);
     }
 
-    public async Task Lock(Func<Task> worker)
+    public async Task Lock(Func<Task> taskWorker)
     {
         await _semaphore.WaitAsync().ConfigureAwait(false);
         try
         {
-            await worker().ConfigureAwait(false);
+            await taskWorker().ConfigureAwait(false);
         }
         finally
         {
-            _ = _semaphore?.Release();
+            _semaphore?.Release();
         }
     }
 
-    public async Task<T> Lock<T>(Func<Task<T>> worker)
+    public async Task<T> Lock<T>(Func<Task<T>> taskWorker)
     {
         await _semaphore.WaitAsync().ConfigureAwait(false);
         try
         {
-            return await worker().ConfigureAwait(false);
+            return await taskWorker().ConfigureAwait(false);
         }
         finally
         {
-            _ = _semaphore?.Release();
+            _semaphore?.Release();
         }
     }
 
-    public async Task Lock(Func<ValueTask> worker)
+    /// <summary>
+    /// Acquires a lock and executes the provided asynchronous <see cref="ValueTask"/> operation.
+    /// Use <c>Lock(valueTaskWorker: () => { actions... })</c> to specify it is a <see cref="ValueTask"/>.
+    /// Do not use the dummy parameter.
+    /// </summary>
+    /// <remarks>
+    /// The method is specifically designed for <see cref="ValueTask"/> operations. The second parameter is a dummy and should not be used.
+    /// </remarks>
+    /// <param name="valueTaskWorker">
+    /// The <see cref="ValueTask"/> worker delegate that represents the asynchronous operation to be performed under the lock.
+    /// </param>
+    /// <param name="_">
+    /// <b>DUMMY PARAMETER - DO NOT USE.</b> This parameter is included for prioritizing the methods.
+    /// </param>
+    /// <returns>
+    /// A <see cref="Task"/> that represents the asynchronous operation.
+    /// </returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313:Parameter names should begin with lower-case letter", Justification = "Is an empty parameter")]
+    public async Task Lock(Func<ValueTask> valueTaskWorker, DummyParameter? _ = null)
     {
         await _semaphore.WaitAsync().ConfigureAwait(false);
         try
         {
-            await worker().ConfigureAwait(false);
+            await valueTaskWorker().ConfigureAwait(false);
         }
         finally
         {
-            _ = _semaphore?.Release();
+            _semaphore?.Release();
         }
     }
 
-    public Task Lock<T>(Func<T> worker)
+    public Task Lock<T>(Func<T> taskWorker)
         where T : Task
     {
-        return Lock(worker);
+        return Lock(taskWorker);
     }
 
-    public async Task<T> Lock<T>(Func<ValueTask<T>> worker)
+    /// <summary>
+    /// Acquires a lock and executes the provided asynchronous <see cref="ValueTask"/> operation.
+    /// Use <c>Lock(valueTaskWorker: () => { actions... })</c> to specify it is a <see cref="ValueTask"/>.
+    /// Do not use the dummy parameter.
+    /// </summary>
+    /// <remarks>
+    /// The method is specifically designed for <see cref="ValueTask"/> operations. The second parameter is a dummy and should not be used.
+    /// </remarks>
+    /// <param name="valueTaskWorker">
+    /// The <see cref="ValueTask"/> worker delegate that represents the asynchronous operation to be performed under the lock.
+    /// </param>
+    /// <param name="_">
+    /// <b>DUMMY PARAMETER - DO NOT USE.</b> This parameter is included for prioritizing the methods.
+    /// </param>
+    /// <returns>
+    /// A <see cref="Task"/> that represents the asynchronous operation.
+    /// </returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1313:Parameter names should begin with lower-case letter", Justification = "Is an empty parameter")]
+    public async Task<T> Lock<T>(Func<ValueTask<T>> valueTaskWorker, DummyParameter? _ = null)
     {
         await _semaphore.WaitAsync().ConfigureAwait(false);
         try
         {
-            return await worker().ConfigureAwait(false);
+            return await valueTaskWorker().ConfigureAwait(false);
         }
         finally
         {
-            _ = _semaphore?.Release();
+            _semaphore?.Release();
         }
     }
 

src/ZirconNet.Core/Runtime/DummyParameter.cs

@@ -0,0 +1,16 @@
+// <copyright file="DummyParameter.cs" company="Zircon Technology">
+// This software is distributed under the MIT license and its code is open-source and free for use, modification, and distribution.
+// </copyright>
+
+namespace ZirconNet.Core.Runtime;
+
+/// <summary>
+/// Dummy parameter to force one function or another SHOULD NOT BE USED.
+/// </summary>
+public abstract class DummyParameter
+{
+    public DummyParameter()
+    {
+        throw new InvalidOperationException("Dummy parameter shouldn't be used or initialized.");
+    }
+}