Fix: Some renames

Author: AnnaSasDev

src/CodeOfChaos.Types/AsynLazy.cs

@@ -9,31 +9,38 @@ namespace System;
 public class AsyncLazy<T>(Func<CancellationToken, Task<T>> valueFactory) : IAsyncDisposable {
     private readonly SemaphoreSlim _semaphore = new(1, 1);
     private Task<T>? _value;
+    private bool _disposed;
 
     // -----------------------------------------------------------------------------------------------------------------
     // Methods
     // -----------------------------------------------------------------------------------------------------------------
-    public async Task<T> GetValueAsync(CancellationToken ct = default) {
+    public async ValueTask<T> GetValueAsync(CancellationToken ct = default) {
         ct.ThrowIfCancellationRequested();
 
-        Task<T>? value = _value;
-        if (value != null) return await value.ConfigureAwait(false);
+        
+        if (_value is {} value ) return await value.ConfigureAwait(false);
 
         await _semaphore.WaitAsync(ct).ConfigureAwait(false);
+        
         try {
-            value = _value;
-            if (value == null) {
-                _value = value = valueFactory(ct);
-            }
+            // Check once more within the semaphore lock
+            _value ??= valueFactory(ct);
+        }
+        catch (Exception ex) {
+            _value = Task.FromException<T>(ex);
+            throw;
         }
         finally {
             _semaphore.Release();
         }
 
-        return await value.ConfigureAwait(false);
+        return await _value.ConfigureAwait(false);
     }
 
     public async ValueTask DisposeAsync() {
+        if (_disposed) return;
+        _disposed = true;
+        
         // First do all the regular stuff
         _semaphore.Dispose();
         GC.SuppressFinalize(this);

src/CodeOfChaos.Types/SemanticVersion.cs

@@ -21,7 +21,10 @@ namespace CodeOfChaos.Types;
 ///     The Addendum is allowed to contain any information.
 /// </remarks>
 [StructLayout(LayoutKind.Sequential)]
-public readonly struct SemanticVersion(int major, int minor, int patch, string? addendum = null) : IComparable<SemanticVersion>, IEquatable<SemanticVersion> {
+public readonly struct SemanticVersion(int major, int minor, int patch, string? addendum = null) : 
+    IComparable<SemanticVersion>,
+    IEquatable<SemanticVersion>
+{
     [XmlIgnore] public int Major { get; } = major;
     [XmlIgnore] public int Minor { get; } = minor;
     [XmlIgnore] public int Patch { get; } = patch;

tests/Tests.CodeOfChaos.Types/AsyncLazyTests.cs

@@ -13,7 +13,7 @@ namespace Tests.CodeOfChaos.Types;
 [TestSubject(typeof(AsyncLazy<>))]
 public class AsyncLazyTests {
     [Test]
-    public async Task GetValueAsync_ShouldReturnValue_FromTestoryMethod() {
+    public async Task GetValueAsync_ShouldReturnValue_FromFactoryMethod() {
         // Arrange
         int expectedValue = 42;
         var lazy = new AsyncLazy<int>(_ => Task.FromResult(expectedValue));
@@ -53,7 +53,7 @@ public async Task GetValueAsync_ShouldHandleCancellationToken() {
 
         // Act & Assert
         await cts.CancelAsync();
-        await Assert.ThrowsAsync<OperationCanceledException>(() => lazy.GetValueAsync(cts.Token));
+        await Assert.ThrowsAsync<OperationCanceledException>(async () => await lazy.GetValueAsync(cts.Token));
     }
 
     [Test]
@@ -118,7 +118,7 @@ public async Task GetValueAsync_ShouldEnsureAtomicity() {
 
         // Act
         for (int i = 0; i < count; i++) {
-            tasks.Add(lazy.GetValueAsync());// Initiate concurrent access to the value
+            tasks.Add(lazy.GetValueAsync().AsTask());// Initiate concurrent access to the value
         }
 
         int[] results = await Task.WhenAll(tasks);