Never return from disposed caches

Author: danylofitel

README.md

@@ -274,11 +274,15 @@ Notes:
 * Some of the classes implement `IDisposable` interface and should be correctly disposed.
 * Be cautious when caching types that implement `IDisposable` interface as the values will not be automatically disposed by the caches.
 * Be cautious when using classes with `LazyThreadSafetyMode.PublicationOnly` behavior together with `IDisposable` types as discarded instances will not be disposed.
+* `PublicationOnly` implementations may run multiple factories concurrently and publish the first successful result.
+* Async lazy and initializer methods throw `InvalidOperationException` if a factory returns a null `Task`.
 
 #### Lazy
 
 Two different implementations of async lazy values are available — `LazyAsyncPublicationOnly` and `LazyAsyncExecutionAndPublication`. Those are async versions of `System.Lazy` class with `LazyThreadSafetyMode.PublicationOnly` and `LazyThreadSafetyMode.ExecutionAndPublication` modes respectively. The reason that async lazy implementations are separate classes is that `LazyAsyncExecutionAndPublication` implements `IDisposable` due to its usage of an instance of `SemaphoreSlim` whereas `LazyAsyncPublicationOnly` does not need to implement `IDisposable`.
 
+`LazyAsyncExecutionAndPublication` runs at most one in-flight factory and retries after failed or canceled attempts. `LazyAsyncPublicationOnly` may execute multiple concurrent factories, but only the first successfully published value is retained.
+
 ```csharp
     using LibSharp.Caching;
 
@@ -309,6 +313,8 @@ Two different implementations of async lazy values are available — `LazyAsyncP
 
 Initializers in LibSharp are equivalents of lazy types, with the only difference being that the value factory is provided at lazy initialization time instead of creation time. They also enable cases where different factories can be used to initialize the value, where only one will succeed at setting the value.
 
+`InitializerAsyncExecutionAndPublication` runs at most one in-flight factory and retries after failed or canceled attempts. `InitializerAsyncPublicationOnly` may execute multiple concurrent factories, but only the first successfully published value is retained.
+
 ```csharp
     using LibSharp.Caching;
 

src/LibSharp/Caching/IInitializerAsync.cs

@@ -26,8 +26,10 @@ public interface IInitializerAsync<T>
     /// <returns>The value.</returns>
     /// <remarks>
     /// If the factory faults or is canceled, the value is not considered initialized and a later call may retry.
+    /// Publication-only implementations may execute multiple factories concurrently, but only one successful result will be published.
     /// </remarks>
     /// <exception cref="ObjectDisposedException">Thrown if the initializer has been disposed.</exception>
     /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken"/> is canceled before the value is produced.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if <paramref name="factory"/> returns a null task.</exception>
     Task<T> GetValueAsync(Func<CancellationToken, Task<T>> factory, CancellationToken cancellationToken = default);
 }

src/LibSharp/Caching/InitializerAsyncExecutionAndPublication.cs

@@ -48,6 +48,8 @@ public async Task<T> GetValueAsync(Func<CancellationToken, Task<T>> factory, Can
                     m_hasValue = true;
                 }
 
+                ObjectDisposedException.ThrowIf(Volatile.Read(ref m_isDisposed) != 0, this);
+
                 return m_value;
             }
         }

src/LibSharp/Caching/InitializerAsyncPublicationOnly.cs

@@ -11,7 +11,11 @@ namespace LibSharp.Caching;
 /// Async initializer with LazyThreadSafetyMode.PublicationOnly.
 /// </summary>
 /// <typeparam name="T">Value type.</typeparam>
-/// <remarks>Should not be used with IDisposable or IAsyncDisposable value types since it does not dispose of values.</remarks>
+/// <remarks>
+/// Should not be used with IDisposable or IAsyncDisposable value types since it does not dispose of values.
+/// Concurrent callers may execute different factories more than once; only the first successfully published value is retained and returned to all callers.
+/// Faulted or canceled attempts are not cached and may be retried by later callers.
+/// </remarks>
 public sealed class InitializerAsyncPublicationOnly<T> : IInitializerAsync<T>
 {
     /// <inheritdoc/>

src/LibSharp/Caching/LazyAsyncExecutionAndPublication.cs

@@ -12,7 +12,10 @@ namespace LibSharp.Caching;
 /// Async lazy with LazyThreadSafetyMode.ExecutionAndPublication.
 /// </summary>
 /// <typeparam name="T">Value type.</typeparam>
-/// <remarks>Should not be used with IDisposable or IAsyncDisposable value types since it does not dispose of values.</remarks>
+/// <remarks>
+/// Should not be used with IDisposable or IAsyncDisposable value types since it does not dispose of values.
+/// A successful initialization is cached permanently. Faulted or canceled attempts are not cached and may be retried by later callers.
+/// </remarks>
 public sealed class LazyAsyncExecutionAndPublication<T> : IDisposable
 {
     /// <summary>
@@ -55,6 +58,9 @@ public bool HasValue
     /// </summary>
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>The value.</returns>
+    /// <exception cref="ObjectDisposedException">Thrown if this instance has been disposed.</exception>
+    /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken"/> is canceled before the value is produced.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if the value factory returns a null task.</exception>
     public async Task<T> GetValueAsync(CancellationToken cancellationToken = default)
     {
         ObjectDisposedException.ThrowIf(Volatile.Read(ref m_isDisposed) != 0, this);
@@ -71,6 +77,8 @@ public async Task<T> GetValueAsync(CancellationToken cancellationToken = default
                     m_hasValue = true;
                 }
 
+                ObjectDisposedException.ThrowIf(Volatile.Read(ref m_isDisposed) != 0, this);
+
                 return m_value;
             }
         }

src/LibSharp/Caching/LazyAsyncPublicationOnly.cs

@@ -11,7 +11,11 @@ namespace LibSharp.Caching;
 /// Async lazy with LazyThreadSafetyMode.PublicationOnly.
 /// </summary>
 /// <typeparam name="T">Value type.</typeparam>
-/// <remarks>Should not be used with IDisposable or IAsyncDisposable value types since it does not dispose of values.</remarks>
+/// <remarks>
+/// Should not be used with IDisposable or IAsyncDisposable value types since it does not dispose of values.
+/// Concurrent callers may execute the factory more than once; only the first successfully published value is retained and returned to all callers.
+/// Faulted or canceled attempts are not cached and may be retried by later callers.
+/// </remarks>
 public sealed class LazyAsyncPublicationOnly<T>
 {
     /// <summary>
@@ -44,6 +48,8 @@ public LazyAsyncPublicationOnly(Func<CancellationToken, Task<T>> factory)
     /// </summary>
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>The value.</returns>
+    /// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken"/> is canceled before a published value is produced.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if the value factory returns a null task.</exception>
     public async Task<T> GetValueAsync(CancellationToken cancellationToken = default)
     {
         if (!HasValue)

test/LibSharp.UnitTests/Caching/InitializerAsyncExecutionAndPublicationUnitTests.cs

@@ -159,4 +159,30 @@ public async Task GetValueAsync_FactoryReturningNullTask_ThrowsInvalidOperationE
         _ = await Assert.ThrowsExactlyAsync<InvalidOperationException>(async () =>
             await initializer.GetValueAsync(_ => null, CancellationToken.None).ConfigureAwait(false)).ConfigureAwait(false);
     }
+
+    [TestMethod]
+    public async Task GetValueAsync_DisposedWhileFactoryIsInFlight_ThrowsObjectDisposedException()
+    {
+        // Arrange
+        using InitializerAsyncExecutionAndPublication<int> initializer = new InitializerAsyncExecutionAndPublication<int>();
+        TaskCompletionSource<bool> factoryStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<int> factoryTcs = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        Task<int> getTask = initializer.GetValueAsync(
+            cancellationToken =>
+            {
+                _ = factoryStarted.TrySetResult(true);
+                return factoryTcs.Task;
+            },
+            CancellationToken.None);
+
+        _ = await factoryStarted.Task.WaitAsync(CancellationToken.None).ConfigureAwait(false);
+
+        // Act
+        initializer.Dispose();
+        factoryTcs.SetResult(42);
+
+        // Assert
+        _ = await Assert.ThrowsExactlyAsync<ObjectDisposedException>(() => getTask).ConfigureAwait(false);
+    }
 }

test/LibSharp.UnitTests/Caching/InitializerAsyncPublicationOnlyUnitTests.cs

@@ -54,4 +54,37 @@ public async Task GetValueAsync_FactoryReturningNullTask_ThrowsInvalidOperationE
         _ = await Assert.ThrowsExactlyAsync<InvalidOperationException>(async () =>
             await lazy.GetValueAsync(_ => null, CancellationToken.None).ConfigureAwait(false)).ConfigureAwait(false);
     }
+
+    [TestMethod]
+    public async Task GetValueAsync_ConcurrentCallers_PublishSingleWinningValue()
+    {
+        // Arrange
+        InitializerAsyncPublicationOnly<int> initializer = new InitializerAsyncPublicationOnly<int>();
+        TaskCompletionSource<bool> bothFactoriesStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        int executionCount = 0;
+
+        async Task<int> Factory(CancellationToken cancellationToken)
+        {
+            int count = Interlocked.Increment(ref executionCount);
+            if (count == 2)
+            {
+                _ = bothFactoriesStarted.TrySetResult(true);
+            }
+
+            _ = await bothFactoriesStarted.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
+            return count;
+        }
+
+        // Act
+        Task<int> first = Task.Run(() => initializer.GetValueAsync(Factory, CancellationToken.None), CancellationToken.None);
+        Task<int> second = Task.Run(() => initializer.GetValueAsync(Factory, CancellationToken.None), CancellationToken.None);
+        int[] results = await Task.WhenAll(first, second).ConfigureAwait(false);
+        int published = await initializer.GetValueAsync(Factory, CancellationToken.None).ConfigureAwait(false);
+
+        // Assert
+        Assert.AreEqual(2, executionCount);
+        Assert.AreEqual(results[0], results[1]);
+        Assert.AreEqual(results[0], published);
+        Assert.IsTrue(initializer.HasValue);
+    }
 }

test/LibSharp.UnitTests/Caching/LazyAsyncExecutionAndPublicationUnitTests.cs

@@ -142,6 +142,66 @@ public async Task FromValueFactory_TokenCanceled_Throws()
         }
     }
 
+    [TestMethod]
+    public async Task GetValueAsync_ConcurrentCallers_OnlyOneFactoryExecutes()
+    {
+        // Arrange
+        TaskCompletionSource<bool> factoryStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<bool> releaseFactory = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        int executionCount = 0;
+
+        using LazyAsyncExecutionAndPublication<int> lazy = new LazyAsyncExecutionAndPublication<int>(
+            async cancellationToken =>
+            {
+                _ = Interlocked.Increment(ref executionCount);
+                _ = factoryStarted.TrySetResult(true);
+                _ = await releaseFactory.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
+                return 42;
+            });
+
+        Task<int>[] callers = new Task<int>[8];
+        for (int i = 0; i < callers.Length; i++)
+        {
+            callers[i] = Task.Run(() => lazy.GetValueAsync(CancellationToken.None), CancellationToken.None);
+        }
+
+        _ = await factoryStarted.Task.WaitAsync(CancellationToken.None).ConfigureAwait(false);
+        Assert.AreEqual(1, executionCount);
+
+        // Act
+        releaseFactory.SetResult(true);
+        int[] results = await Task.WhenAll(callers).ConfigureAwait(false);
+
+        // Assert
+        CollectionAssert.AreEqual(new[] { 42, 42, 42, 42, 42, 42, 42, 42 }, results);
+        Assert.IsTrue(lazy.HasValue);
+    }
+
+    [TestMethod]
+    public async Task GetValueAsync_DisposedWhileFactoryIsInFlight_ThrowsObjectDisposedException()
+    {
+        // Arrange
+        TaskCompletionSource<bool> factoryStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        TaskCompletionSource<int> factoryTcs = new TaskCompletionSource<int>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        using LazyAsyncExecutionAndPublication<int> lazy = new LazyAsyncExecutionAndPublication<int>(
+            cancellationToken =>
+            {
+                _ = factoryStarted.TrySetResult(true);
+                return factoryTcs.Task;
+            });
+
+        Task<int> getTask = lazy.GetValueAsync(CancellationToken.None);
+        _ = await factoryStarted.Task.WaitAsync(CancellationToken.None).ConfigureAwait(false);
+
+        // Act
+        lazy.Dispose();
+        factoryTcs.SetResult(42);
+
+        // Assert
+        _ = await Assert.ThrowsExactlyAsync<ObjectDisposedException>(() => getTask).ConfigureAwait(false);
+    }
+
     [TestMethod]
     public async Task FromFactory_NullTask_ThrowsInvalidOperationException()
     {

test/LibSharp.UnitTests/Caching/LazyAsyncPublicationOnlyUnitTests.cs

@@ -106,5 +106,37 @@ public async Task FromFactory_NullTask_ThrowsInvalidOperationException()
             await lazy.GetValueAsync(CancellationToken.None).ConfigureAwait(false)).ConfigureAwait(false);
     }
 
+    [TestMethod]
+    public async Task GetValueAsync_ConcurrentCallers_PublishSingleWinningValue()
+    {
+        // Arrange
+        TaskCompletionSource<bool> bothFactoriesStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        int executionCount = 0;
+
+        LazyAsyncPublicationOnly<int> lazy = new LazyAsyncPublicationOnly<int>(async cancellationToken =>
+        {
+            int count = Interlocked.Increment(ref executionCount);
+            if (count == 2)
+            {
+                _ = bothFactoriesStarted.TrySetResult(true);
+            }
+
+            _ = await bothFactoriesStarted.Task.WaitAsync(cancellationToken).ConfigureAwait(false);
+            return count;
+        });
+
+        // Act
+        Task<int> first = Task.Run(() => lazy.GetValueAsync(CancellationToken.None), CancellationToken.None);
+        Task<int> second = Task.Run(() => lazy.GetValueAsync(CancellationToken.None), CancellationToken.None);
+        int[] results = await Task.WhenAll(first, second).ConfigureAwait(false);
+        int published = await lazy.GetValueAsync(CancellationToken.None).ConfigureAwait(false);
+
+        // Assert
+        Assert.AreEqual(2, executionCount);
+        Assert.AreEqual(results[0], results[1]);
+        Assert.AreEqual(results[0], published);
+        Assert.IsTrue(lazy.HasValue);
+    }
+
     public TestContext TestContext { get; set; }
 }