com.wallstop-studios.unity-helpers 2.0.0-rc55 → 2.0.0-rc57

package/Runtime/Core/Extension/AsyncOperationExtensions.cs

@@ -0,0 +1,110 @@
+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;
+        }
+
+#if !UNITY_2023_1_OR_NEWER
+        public static AsyncOperationAwaiter GetAwaiter(this AsyncOperation op)
+        {
+            return new AsyncOperationAwaiter(op);
+        }
+#endif
+
+        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
@@ -67,17 +65,17 @@
 
             return new DeferredDisposalResult<T[]>(
                 result,
-                () =>
+                async () =>
                 {
                     TaskCompletionSource<bool> disposalComplete = new();
                     UnityMainThreadDispatcher.Instance.RunOnMainThread(
                         () =>
-                            sceneScope
+                            _ = sceneScope
                                 .DisposeAsync()
-                                .ContinueWith(_ => disposalComplete.SetResult(true))
+                                .WithContinuation(() => disposalComplete.SetResult(true))
                     );
 
-                    return disposalComplete.Task;
+                    await disposalComplete.Task;
                 }
             );
 
@@ -105,9 +103,17 @@
             }
         }
 
-        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;
 
@@ -166,7 +172,7 @@
                 }
             }
 
-            public async Task DisposeAsync()
+            public async ValueTask DisposeAsync()
             {
                 if (_eventAdded)
                 {
@@ -192,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/Core/Helper/UnityMainThreadDispatcher.cs

@@ -2,9 +2,11 @@
 {
     using System;
     using System.Collections.Concurrent;
-    using UnityEditor;
     using UnityEngine;
     using Utils;
+#if UNITY_EDITOR
+    using UnityEditor;
+#endif
 
     [ExecuteAlways]
     public sealed class UnityMainThreadDispatcher : RuntimeSingleton<UnityMainThreadDispatcher>

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-rc55",
+  "version": "2.0.0-rc57",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},