Make AsyncLock code return IDisposables

Author: kroymann

src/ImageSharp.Web/Middleware/ImageSharpMiddleware.cs

@@ -289,7 +289,7 @@ private async Task ProcessRequestAsync(
             RecyclableMemoryStream outStream = null;
             try
             {
-                Task<AsyncReaderWriterLock.Releaser> takeLockTask = this.asyncKeyLock.WriterLockAsync(key);
+                Task<IDisposable> takeLockTask = this.asyncKeyLock.WriterLockAsync(key);
                 bool lockWasAlreadyHeld = takeLockTask.Status != TaskStatus.RanToCompletion;
                 using (await takeLockTask)
                 {

src/ImageSharp.Web/Synchronization/AsyncKeyLock.cs

@@ -39,9 +39,9 @@ public AsyncKeyLock(int maxPoolSize = 64)
         /// </summary>
         /// <param name="key">The key identifying the specific object to lock against.</param>
         /// <returns>
-        /// The <see cref="AsyncLock.Releaser"/> that will release the lock.
+        /// The <see cref="IDisposable"/> that will release the lock.
         /// </returns>
-        public Task<AsyncLock.Releaser> LockAsync(TKey key)
+        public Task<IDisposable> LockAsync(TKey key)
             => this.activeLocks.Get(key).LockAsync();
 
         /// <summary>

src/ImageSharp.Web/Synchronization/AsyncKeyReaderWriterLock.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
 
@@ -38,19 +39,19 @@ public AsyncKeyReaderWriterLock(int maxPoolSize = 64)
         /// </summary>
         /// <param name="key">The key identifying the specific object to lock against.</param>
         /// <returns>
-        /// The <see cref="AsyncReaderWriterLock.Releaser"/> that will release the lock.
+        /// The <see cref="IDisposable"/> that will release the lock.
         /// </returns>
-        public Task<AsyncReaderWriterLock.Releaser> ReaderLockAsync(TKey key)
+        public Task<IDisposable> ReaderLockAsync(TKey key)
             => this.activeLocks.Get(key).ReaderLockAsync();
 
         /// <summary>
         /// Locks the current thread in write mode asynchronously.
         /// </summary>
         /// <param name="key">The key identifying the specific object to lock against.</param>
         /// <returns>
-        /// The <see cref="AsyncReaderWriterLock.Releaser"/> that will release the lock.
+        /// The <see cref="IDisposable"/> that will release the lock.
         /// </returns>
-        public Task<AsyncReaderWriterLock.Releaser> WriterLockAsync(TKey key)
+        public Task<IDisposable> WriterLockAsync(TKey key)
             => this.activeLocks.Get(key).WriterLockAsync();
 
         private AsyncReaderWriterLock CreateLeasedLock(TKey key)

src/ImageSharp.Web/Synchronization/AsyncLock.cs

@@ -16,9 +16,9 @@ public class AsyncLock : IDisposable
     {
         private readonly SemaphoreSlim semaphore;
 #pragma warning disable IDE0069 // Disposable fields should be disposed
-        private readonly Releaser releaser;
+        private readonly IDisposable releaser;
 #pragma warning restore IDE0069 // Disposable fields should be disposed
-        private readonly Task<Releaser> releaserTask;
+        private readonly Task<IDisposable> releaserTask;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="AsyncLock"/> class.
@@ -36,12 +36,12 @@ public AsyncLock()
         public Action? OnRelease { get; set; }
 
         /// <summary>
-        /// Asynchronously obtains the lock. Dispose the returned <see cref="Releaser"/> to release the lock.
+        /// Asynchronously obtains the lock. Dispose the returned <see cref="IDisposable"/> to release the lock.
         /// </summary>
         /// <returns>
-        /// The <see cref="Releaser"/> that will release the lock.
+        /// The <see cref="IDisposable"/> that will release the lock.
         /// </returns>
-        public Task<Releaser> LockAsync()
+        public Task<IDisposable> LockAsync()
         {
             Task wait = this.semaphore.WaitAsync();
 
@@ -50,7 +50,7 @@ public Task<Releaser> LockAsync()
                 ? this.releaserTask
                 : AwaitThenReturn(wait, this.releaser);
 
-            static async Task<Releaser> AwaitThenReturn(Task t, Releaser r)
+            static async Task<IDisposable> AwaitThenReturn(Task t, IDisposable r)
             {
                 await t;
                 return r;
@@ -77,7 +77,7 @@ private void Release()
         /// <summary>
         /// Utility class that releases an <see cref="AsyncLock"/> on disposal.
         /// </summary>
-        public sealed class Releaser : IDisposable
+        private sealed class Releaser : IDisposable
         {
             private readonly AsyncLock toRelease;
 

src/ImageSharp.Web/Synchronization/AsyncReaderWriterLock.cs

@@ -19,12 +19,12 @@ namespace SixLabors.ImageSharp.Web.Synchronization
     public class AsyncReaderWriterLock
     {
         private readonly object stateLock;
-        private readonly Releaser writerReleaser;
-        private readonly Releaser readerReleaser;
-        private readonly Task<Releaser> writerReleaserTask;
-        private readonly Task<Releaser> readerReleaserTask;
-        private readonly Queue<TaskCompletionSource<Releaser>> waitingWriters;
-        private TaskCompletionSource<Releaser>? waitingReaders;
+        private readonly IDisposable writerReleaser;
+        private readonly IDisposable readerReleaser;
+        private readonly Task<IDisposable> writerReleaserTask;
+        private readonly Task<IDisposable> readerReleaserTask;
+        private readonly Queue<TaskCompletionSource<IDisposable>> waitingWriters;
+        private TaskCompletionSource<IDisposable>? waitingReaders;
         private int readersWaiting;
 
         /// <summary>
@@ -45,7 +45,7 @@ public AsyncReaderWriterLock()
             this.readerReleaser = new Releaser(this, false);
             this.writerReleaserTask = Task.FromResult(this.writerReleaser);
             this.readerReleaserTask = Task.FromResult(this.readerReleaser);
-            this.waitingWriters = new Queue<TaskCompletionSource<Releaser>>();
+            this.waitingWriters = new Queue<TaskCompletionSource<IDisposable>>();
             this.waitingReaders = null;
             this.readersWaiting = 0;
             this.status = 0;
@@ -57,13 +57,13 @@ public AsyncReaderWriterLock()
         public Action? OnRelease { get; set; }
 
         /// <summary>
-        /// Asynchronously obtains the lock in shared reader mode. Dispose the returned <see cref="Releaser"/>
+        /// Asynchronously obtains the lock in shared reader mode. Dispose the returned <see cref="IDisposable"/>
         /// to release the lock.
         /// </summary>
         /// <returns>
-        /// The <see cref="Releaser"/> that will release the lock.
+        /// The <see cref="IDisposable"/> that will release the lock.
         /// </returns>
-        public Task<Releaser> ReaderLockAsync()
+        public Task<IDisposable> ReaderLockAsync()
         {
             lock (this.stateLock)
             {
@@ -82,7 +82,7 @@ public Task<Releaser> ReaderLockAsync()
 
                     if (this.waitingReaders == null)
                     {
-                        this.waitingReaders = new TaskCompletionSource<Releaser>(TaskCreationOptions.RunContinuationsAsynchronously);
+                        this.waitingReaders = new TaskCompletionSource<IDisposable>(TaskCreationOptions.RunContinuationsAsynchronously);
                     }
 
                     return this.waitingReaders.Task;
@@ -91,13 +91,13 @@ public Task<Releaser> ReaderLockAsync()
         }
 
         /// <summary>
-        /// Asynchronously obtains the lock in exclusive writer mode. Dispose the returned <see cref="Releaser"/>
+        /// Asynchronously obtains the lock in exclusive writer mode. Dispose the returned <see cref="IDisposable"/>
         /// to release the lock.
         /// </summary>
         /// <returns>
-        /// The <see cref="Releaser"/> that will release the lock.
+        /// The <see cref="IDisposable"/> that will release the lock.
         /// </returns>
-        public Task<Releaser> WriterLockAsync()
+        public Task<IDisposable> WriterLockAsync()
         {
             lock (this.stateLock)
             {
@@ -112,7 +112,7 @@ public Task<Releaser> WriterLockAsync()
                 {
                     // This writer has to wait to obtain the lock. Create a new tcs for this writer, add it to the
                     // queue of waiting writers, and return the task.
-                    var waiter = new TaskCompletionSource<Releaser>(TaskCreationOptions.RunContinuationsAsynchronously);
+                    var waiter = new TaskCompletionSource<IDisposable>(TaskCreationOptions.RunContinuationsAsynchronously);
                     this.waitingWriters.Enqueue(waiter);
                     return waiter.Task;
                 }
@@ -123,7 +123,7 @@ private void ReaderRelease()
         {
             try
             {
-                TaskCompletionSource<Releaser>? nextLockHolder = null;
+                TaskCompletionSource<IDisposable>? nextLockHolder = null;
 
                 lock (this.stateLock)
                 {
@@ -148,8 +148,8 @@ private void WriterRelease()
         {
             try
             {
-                TaskCompletionSource<Releaser>? nextLockHolder;
-                Releaser releaser;
+                TaskCompletionSource<IDisposable>? nextLockHolder;
+                IDisposable releaser;
 
                 lock (this.stateLock)
                 {
@@ -188,7 +188,7 @@ private void WriterRelease()
         /// <summary>
         /// Utility class that releases an <see cref="AsyncReaderWriterLock"/> on disposal.
         /// </summary>
-        public sealed class Releaser : IDisposable
+        private sealed class Releaser : IDisposable
         {
             private readonly AsyncReaderWriterLock toRelease;
             private readonly bool writer;

tests/ImageSharp.Web.Tests/Synchronization/AsyncLockTests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Web.Synchronization;
 using Xunit;
@@ -14,10 +15,10 @@ public class AsyncLockTests
         [Fact]
         public async Task OneAtATime()
         {
-            Task<AsyncLock.Releaser> first = this.l.LockAsync();
+            Task<IDisposable> first = this.l.LockAsync();
             Assert.True(first.IsCompletedSuccessfully);
 
-            Task<AsyncLock.Releaser> second = this.l.LockAsync();
+            Task<IDisposable> second = this.l.LockAsync();
             Assert.False(second.IsCompleted);
 
             // Release first hold on the lock and then await the second task to confirm it completes.

tests/ImageSharp.Web.Tests/Synchronization/AsyncReaderWriterLockTests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Threading.Tasks;
 using SixLabors.ImageSharp.Web.Synchronization;
 using Xunit;
@@ -14,10 +15,10 @@ public class AsyncReaderWriterLockTests
         [Fact]
         public void OneWriterAtATime()
         {
-            Task<AsyncReaderWriterLock.Releaser> first = this.l.WriterLockAsync();
+            Task<IDisposable> first = this.l.WriterLockAsync();
             Assert.True(first.IsCompletedSuccessfully);
 
-            Task<AsyncReaderWriterLock.Releaser> second = this.l.WriterLockAsync();
+            Task<IDisposable> second = this.l.WriterLockAsync();
             Assert.False(second.IsCompleted);
 
             first.Result.Dispose();
@@ -27,10 +28,10 @@ public void OneWriterAtATime()
         [Fact]
         public void WriterBlocksReaders()
         {
-            Task<AsyncReaderWriterLock.Releaser> first = this.l.WriterLockAsync();
+            Task<IDisposable> first = this.l.WriterLockAsync();
             Assert.True(first.IsCompletedSuccessfully);
 
-            Task<AsyncReaderWriterLock.Releaser> second = this.l.ReaderLockAsync();
+            Task<IDisposable> second = this.l.ReaderLockAsync();
             Assert.False(second.IsCompleted);
 
             first.Result.Dispose();
@@ -40,13 +41,13 @@ public void WriterBlocksReaders()
         [Fact]
         public void WaitingWriterBlocksReaders()
         {
-            Task<AsyncReaderWriterLock.Releaser> first = this.l.ReaderLockAsync();
+            Task<IDisposable> first = this.l.ReaderLockAsync();
             Assert.True(first.IsCompletedSuccessfully);
 
-            Task<AsyncReaderWriterLock.Releaser> second = this.l.WriterLockAsync();
+            Task<IDisposable> second = this.l.WriterLockAsync();
             Assert.False(second.IsCompleted);
 
-            Task<AsyncReaderWriterLock.Releaser> third = this.l.ReaderLockAsync();
+            Task<IDisposable> third = this.l.ReaderLockAsync();
             Assert.False(third.IsCompleted);
 
             first.Result.Dispose();
@@ -60,29 +61,29 @@ public void WaitingWriterBlocksReaders()
         [Fact]
         public void MultipleReadersAtOnce()
         {
-            Task<AsyncReaderWriterLock.Releaser> first = this.l.ReaderLockAsync();
+            Task<IDisposable> first = this.l.ReaderLockAsync();
             Assert.True(first.IsCompletedSuccessfully);
 
-            Task<AsyncReaderWriterLock.Releaser> second = this.l.ReaderLockAsync();
+            Task<IDisposable> second = this.l.ReaderLockAsync();
             Assert.True(second.IsCompletedSuccessfully);
 
-            Task<AsyncReaderWriterLock.Releaser> third = this.l.ReaderLockAsync();
+            Task<IDisposable> third = this.l.ReaderLockAsync();
             Assert.True(third.IsCompletedSuccessfully);
         }
 
         [Fact]
         public void AllWaitingReadersReleasedConcurrently()
         {
-            Task<AsyncReaderWriterLock.Releaser> writer = this.l.WriterLockAsync();
+            Task<IDisposable> writer = this.l.WriterLockAsync();
             Assert.True(writer.IsCompletedSuccessfully);
 
-            Task<AsyncReaderWriterLock.Releaser> reader1 = this.l.ReaderLockAsync();
+            Task<IDisposable> reader1 = this.l.ReaderLockAsync();
             Assert.False(reader1.IsCompleted);
 
-            Task<AsyncReaderWriterLock.Releaser> reader2 = this.l.ReaderLockAsync();
+            Task<IDisposable> reader2 = this.l.ReaderLockAsync();
             Assert.False(reader2.IsCompleted);
 
-            Task<AsyncReaderWriterLock.Releaser> reader3 = this.l.ReaderLockAsync();
+            Task<IDisposable> reader3 = this.l.ReaderLockAsync();
             Assert.False(reader3.IsCompleted);
 
             writer.Result.Dispose();