Fix UnobservedTaskException for AsyncAtomicFactory

BitFaster.Caching.UnitTests/Atomic/AsyncAtomicFactoryTests.cs

@@ -156,6 +156,45 @@ await Task.WhenAll(first, second)
             }
         }
 
+        [Fact]
+        public async Task WhenValueCreateThrowsDoesNotCauseUnobservedTaskException()
+        {
+            bool unobservedExceptionThrown = false;
+            TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
+
+            try
+            {
+                await AsyncAtomicFactoryGetValueAsync();
+
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+            }
+            finally
+            {
+                TaskScheduler.UnobservedTaskException -= OnUnobservedTaskException;
+            }
+
+            unobservedExceptionThrown.Should().BeFalse();
+
+            void OnUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e)
+            {
+                unobservedExceptionThrown = true;
+                e.SetObserved();
+            }
+
+            static async Task AsyncAtomicFactoryGetValueAsync()
+            {
+                var a = new AsyncAtomicFactory<int, int>();
+                try
+                {
+                    _ = await a.GetValueAsync(12, i => throw new ArithmeticException());
+                }
+                catch (ArithmeticException)
+                {
+                }
+            }
+        }
+
         [Fact]
         public void WhenValueNotCreatedHashCodeIsZero()
         {

BitFaster.Caching.UnitTests/Atomic/ScopedAsyncAtomicFactoryTests.cs

@@ -156,7 +156,6 @@ public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
             winnerCount.Should().Be(1);
         }
 
-
         [Fact]
         public async Task WhenCallersRunConcurrentlyWithFailureSameExceptionIsPropagated()
         {
@@ -199,6 +198,48 @@ await Task.WhenAll(first, second)
             }
         }
 
+        [Fact]
+        public async Task WhenValueCreateThrowsDoesNotCauseUnobservedTaskException()
+        {
+            bool unobservedExceptionThrown = false;
+            TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
+
+            try
+            {
+                await AsyncAtomicFactoryGetValueAsync();
+
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+            }
+            finally
+            {
+                TaskScheduler.UnobservedTaskException -= OnUnobservedTaskException;
+            }
+
+            unobservedExceptionThrown.Should().BeFalse();
+
+            void OnUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e)
+            {
+                unobservedExceptionThrown = true;
+                e.SetObserved();
+            }
+
+            static async Task AsyncAtomicFactoryGetValueAsync()
+            {
+                var a = new ScopedAsyncAtomicFactory<int, IntHolder>();
+                try
+                {
+                    _ = await a.TryCreateLifetimeAsync(1, k =>
+                    {
+                        throw new ArithmeticException();
+                    });
+                }
+                catch (ArithmeticException)
+                {
+                }
+            }
+        }
+
         [Fact]
         public async Task WhenDisposedWhileInitResultIsDisposed()
         {

BitFaster.Caching/Atomic/AsyncAtomicFactory.cs

@@ -159,7 +159,10 @@ public async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFactor
                     {
                         Volatile.Write(ref isInitialized, false);
                         tcs.SetException(ex);
-                        throw;
+
+                        // always await the task to avoid unobserved task exceptions - normal case is that no other thread is waiting.
+                        // this will re-throw the exception.
+                        await tcs.Task.ConfigureAwait(false);
                     }
                 }
 

BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs

@@ -178,7 +178,10 @@ public async ValueTask<Scoped<V>> CreateScopeAsync<TFactory>(K key, TFactory val
                     {
                         Volatile.Write(ref isTaskInitialized, false);
                         tcs.SetException(ex);
-                        throw;
+
+                        // always await the task to avoid unobserved task exceptions - normal case is that no other thread is waiting.
+                        // this will re-throw the exception.
+                        await tcs.Task.ConfigureAwait(false);
                     }
                 }