com.wallstop-studios.unity-helpers 2.0.0-rc54 → 2.0.0-rc56

package/Runtime/Core/Extension/AsyncOperationExtensions.cs

@@ -0,0 +1,108 @@
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Runtime.CompilerServices;
+    using System.Threading.Tasks;
+    using UnityEngine;
+
+    public static class AsyncOperationExtensions
+    {
+        private static readonly ConcurrentDictionary<
+            AsyncOperation,
+            Action<AsyncOperation>
+        > Handlers = new();
+        private static readonly ConcurrentDictionary<AsyncOperation, Action> Continuations = new();
+
+        public readonly struct AsyncOperationAwaiter : INotifyCompletion
+        {
+            private readonly AsyncOperation _operation;
+
+            public AsyncOperationAwaiter(AsyncOperation operation)
+            {
+                _operation = operation ?? throw new ArgumentNullException(nameof(operation));
+            }
+
+            public bool IsCompleted => _operation.isDone;
+
+            public void OnCompleted(Action continuation)
+            {
+                Continuations[_operation] = continuation;
+
+                Action<AsyncOperation> handler = CachedHandler;
+                if (!Handlers.TryAdd(_operation, handler))
+                {
+                    return;
+                }
+
+                Handlers[_operation] = handler;
+                _operation.completed += handler;
+            }
+
+            public void GetResult() { }
+        }
+
+        private static readonly Action<AsyncOperation> CachedHandler = OnOperationCompleted;
+
+        private static void OnOperationCompleted(AsyncOperation operation)
+        {
+            Handlers.Remove(operation, out Action<AsyncOperation> _);
+            if (!Continuations.Remove(operation, out Action completionCondition))
+            {
+                return;
+            }
+
+            completionCondition?.Invoke();
+        }
+
+        public static async Task AsTask(this AsyncOperation asyncOp)
+        {
+            if (asyncOp.isDone)
+            {
+                return;
+            }
+
+            await asyncOp;
+        }
+
+        public static async ValueTask AsValueTask(this AsyncOperation asyncOp)
+        {
+            if (asyncOp.isDone)
+            {
+                return;
+            }
+
+            await asyncOp;
+        }
+
+        public static AsyncOperationAwaiter GetAwaiter(this AsyncOperation op)
+        {
+            return new AsyncOperationAwaiter(op);
+        }
+
+        public static async ValueTask WithContinuation(this ValueTask task, Action continuation)
+        {
+            await task;
+            continuation?.Invoke();
+        }
+
+        public static async ValueTask<TResult> WithContinuation<TResult>(
+            this ValueTask<TResult> task,
+            Func<TResult, TResult> continuation
+        )
+        {
+            TResult result = await task;
+            return continuation(result);
+        }
+
+        public static async ValueTask WithContinuation<TResult>(
+            this ValueTask<TResult> task,
+            Action<TResult> continuation
+        )
+        {
+            TResult result = await task;
+            continuation(result);
+        }
+    }
+}

package/Runtime/Core/Extension/AsyncOperationExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 198fd29beff34b32b0d4c19eb0ce843b
+timeCreated: 1743991510

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -1578,13 +1578,6 @@
             return false;
         }
 
-        public static Task AsTask(this AsyncOperation asyncOp)
-        {
-            TaskCompletionSource<bool> taskCompletionSource = new();
-            asyncOp.completed += _ => taskCompletionSource.SetResult(true);
-            return taskCompletionSource.Task;
-        }
-
 #if UNITY_EDITOR
         public static IEnumerable<Sprite> GetSpritesFromClip(this AnimationClip clip)
         {

package/Runtime/Core/Helper/SceneHelper.cs

@@ -41,19 +41,17 @@
 #endif
         }
 
-        public static async Task<DeferredDisposalResult<T>> GetObjectOfTypeInScene<T>(
+        public static async ValueTask<DeferredDisposalResult<T>> GetObjectOfTypeInScene<T>(
             string scenePath
         )
             where T : Object
         {
             DeferredDisposalResult<T[]> result = await GetAllObjectsOfTypeInScene<T>(scenePath);
-            return new DeferredDisposalResult<T>(
-                result.result.FirstOrDefault(),
-                result.DisposeAsync
-            );
+            T value = result.result.Length == 0 ? default : result.result[0];
+            return new DeferredDisposalResult<T>(value, result.DisposeAsync);
         }
 
-        public static async Task<DeferredDisposalResult<T[]>> GetAllObjectsOfTypeInScene<T>(
+        public static async ValueTask<DeferredDisposalResult<T[]>> GetAllObjectsOfTypeInScene<T>(
             string scenePath
         )
             where T : Object
@@ -63,24 +61,23 @@
             TaskCompletionSource<T[]> taskCompletionSource = new();
 
             SceneLoadScope sceneScope = new(scenePath, OnSceneLoaded);
-            return await taskCompletionSource.Task.ContinueWith(result =>
-            {
-                return new DeferredDisposalResult<T[]>(
-                    result.Result,
-                    async () =>
-                    {
-                        TaskCompletionSource<bool> disposalComplete = new();
-                        UnityMainThreadDispatcher.Instance.RunOnMainThread(
-                            () =>
-                                sceneScope
-                                    .DisposeAsync()
-                                    .ContinueWith(_ => disposalComplete.SetResult(true))
-                        );
+            T[] result = await taskCompletionSource.Task;
 
-                        await disposalComplete.Task;
-                    }
-                );
-            });
+            return new DeferredDisposalResult<T[]>(
+                result,
+                async () =>
+                {
+                    TaskCompletionSource<bool> disposalComplete = new();
+                    UnityMainThreadDispatcher.Instance.RunOnMainThread(
+                        () =>
+                            _ = sceneScope
+                                .DisposeAsync()
+                                .WithContinuation(() => disposalComplete.SetResult(true))
+                    );
+
+                    await disposalComplete.Task;
+                }
+            );
 
             void OnSceneLoaded(Scene scene, LoadSceneMode mode)
             {
@@ -102,13 +99,21 @@
                         return go.scene == scene;
                     })
                     .ToArray();
-                taskCompletionSource.TrySetResult(foundObjects);
+                taskCompletionSource.SetResult(foundObjects);
             }
         }
 
-        public sealed class SceneLoadScope
+        public
+#if UNITY_EDITOR
+        readonly
+#endif
+        struct SceneLoadScope
         {
-            private Scene? _openedScene;
+            private
+#if UNITY_EDITOR
+            readonly
+#endif
+            Scene? _openedScene;
             private readonly UnityAction<Scene, LoadSceneMode> _onSceneLoaded;
             private readonly bool _eventAdded;
 
@@ -167,7 +172,7 @@
                 }
             }
 
-            public async Task DisposeAsync()
+            public async ValueTask DisposeAsync()
             {
                 if (_eventAdded)
                 {
@@ -193,22 +198,14 @@
 #if UNITY_EDITOR
                 if (Application.isPlaying)
                 {
-                    AsyncOperation asyncOperation = SceneManager.UnloadSceneAsync(
-                        openedScene,
-                        UnloadSceneOptions.None
-                    );
-                    await asyncOperation.AsTask();
+                    await SceneManager.UnloadSceneAsync(openedScene, UnloadSceneOptions.None);
                 }
                 else
                 {
                     EditorSceneManager.CloseScene(openedScene, true);
                 }
 #else
-                AsyncOperation asyncOperation = SceneManager.UnloadSceneAsync(
-                    openedScene,
-                    UnloadSceneOptions.None
-                );
-                await asyncOperation.AsTask();
+                await SceneManager.UnloadSceneAsync(openedScene, UnloadSceneOptions.None);
 #endif
             }
         }

package/Runtime/Utils/DeferredDisposalResult.cs

@@ -3,19 +3,19 @@
     using System;
     using System.Threading.Tasks;
 
-    public sealed class DeferredDisposalResult<T>
+    public readonly struct DeferredDisposalResult<T>
     {
         public readonly T result;
 
-        private readonly Func<Task> _disposeAsync;
+        private readonly Func<ValueTask> _disposeAsync;
 
-        public DeferredDisposalResult(T result, Func<Task> disposeAsync)
+        public DeferredDisposalResult(T result, Func<ValueTask> disposeAsync)
         {
             this.result = result;
             _disposeAsync = disposeAsync ?? throw new ArgumentNullException(nameof(disposeAsync));
         }
 
-        public async Task DisposeAsync()
+        public async ValueTask DisposeAsync()
         {
             await _disposeAsync();
         }

package/Tests/Runtime/Helper/SceneHelperTests.cs

@@ -13,12 +13,14 @@
 
     public sealed class SceneHelperTests
     {
-        private readonly List<Func<Task>> _disposalTasks = new();
+        private readonly List<Func<ValueTask>> _disposalTasks = new();
 
         [UnityTearDown]
         public IEnumerator TearDown()
         {
-            foreach (Task disposal in _disposalTasks.Select(disposalProducer => disposalProducer()))
+            foreach (
+                ValueTask disposal in _disposalTasks.Select(disposalProducer => disposalProducer())
+            )
             {
                 while (!disposal.IsCompleted)
                 {
@@ -55,7 +57,7 @@
         [UnityTest]
         public IEnumerator GetObjectOfTypeInScene()
         {
-            Task<DeferredDisposalResult<SpriteRenderer>> task =
+            ValueTask<DeferredDisposalResult<SpriteRenderer>> task =
                 SceneHelper.GetObjectOfTypeInScene<SpriteRenderer>(
                     @"Packages\com.wallstop-studios.unity-helpers\Tests\Runtime\Scenes\Test1.unity"
                 );
@@ -63,7 +65,7 @@
             {
                 yield return null;
             }
-            Assert.IsTrue(task.IsCompletedSuccessfully, task.Exception?.ToString() ?? string.Empty);
+            Assert.IsTrue(task.IsCompletedSuccessfully);
 
             _disposalTasks.Add(task.Result.DisposeAsync);
             SpriteRenderer found = task.Result.result;
@@ -73,7 +75,7 @@
         [UnityTest]
         public IEnumerator GetAllObjectOfTypeInScene()
         {
-            Task<DeferredDisposalResult<SpriteRenderer[]>> task =
+            ValueTask<DeferredDisposalResult<SpriteRenderer[]>> task =
                 SceneHelper.GetAllObjectsOfTypeInScene<SpriteRenderer>(
                     @"Packages\com.wallstop-studios.unity-helpers\Tests\Runtime\Scenes\Test1.unity"
                 );
@@ -83,7 +85,7 @@
                 yield return null;
             }
 
-            Assert.IsTrue(task.IsCompletedSuccessfully, task.Exception?.ToString() ?? string.Empty);
+            Assert.IsTrue(task.IsCompletedSuccessfully);
             _disposalTasks.Add(task.Result.DisposeAsync);
             SpriteRenderer[] found = task.Result.result;
             Assert.That(found, Has.Length.EqualTo(7));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc54",
+  "version": "2.0.0-rc56",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},