fix

Fixed AwaitForAllAssets()

.gitignore

@@ -253,3 +253,5 @@ src/UniTask/UnityEngine.UI.Player.csproj
 src/UniTask/DOTween.Modules.Player.csproj
 
 src/UniTask/Assembly-CSharp.Player.csproj
+
+src/UniTask/Unity.EditorCoroutines.Editor.csproj

README.md

@@ -14,7 +14,8 @@ Provides an efficient allocation free async/await integration to Unity.
 * Highly compatible behaviour with Task/ValueTask/IValueTaskSource
 
 Techinical details, see blog post: [UniTask v2 — Zero Allocation async/await for Unity, with Asynchronous LINQ
-](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd)
+](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd)  
+Advanced tips, see blog post: [Extends UnityWebRequest via async decorator pattern — Advanced Techniques of UniTask](https://medium.com/@neuecc/extends-unitywebrequest-via-async-decorator-pattern-advanced-techniques-of-unitask-ceff9c5ee846)
 
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
@@ -32,6 +33,9 @@ Techinical details, see blog post: [UniTask v2 — Zero Allocation async/await f
 - [Awaitable Events](#awaitable-events)
 - [Channel](#channel)
 - [For Unit Testing](#for-unit-testing)
+- [ThreadPool limitation](#threadpool-limitation)
+- [IEnumerator.ToUniTask limitation](#ienumeratortounitask-limitation)
+- [For UnityEditor](#for-unityeditor)
 - [Compare with Standard Task API](#compare-with-standard-task-api)
 - [Pooling Configuration](#pooling-configuration)
 - [Allocation on Profiler](#allocation-on-profiler)
@@ -780,6 +784,26 @@ public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () =>
 
 UniTask itself's unit test is written by Unity Test Runner and [Cysharp/RuntimeUnitTestToolkit](https://github.com/Cysharp/RuntimeUnitTestToolkit) to check on CI and IL2CPP working.
 
+ThreadPool limitation
+---
+Most UniTask methods run in a single thread (PlayerLoop), but only `UniTask.Run` and `UniTask.SwitchToThreadPool` run on a thread pool. If you use a thread pool, it won't work with WebGL and so on.
+
+`UniTask.Run` will be deprecated in the future (marked with an Obsolete) and only `RunOnThreadPool` will be used. Also, if you use `UniTask.Run`, consider whether you can use `UniTask.Create` or `UniTask.Void`.
+
+IEnumerator.ToUniTask limitation
+---
+You can convert coroutine(IEnumerator) to UniTask(or await directly) but has some limitations.
+
+* `WaitForEndOfFrame`/`WaitForFixedUpdate` is not supported, used `yield return null` instead.
+* Consuming loop timing is not same as StartCoroutine, it is used specified PlayerLoopTiming, and default's `PlayerLoopTiming.Update` is run before MonoBehaviour's Update and StartCoroutine's loop.
+
+For UnityEditor
+---
+UniTask can run on Unity Edtitor like Editor Coroutine. However, there are some limitations.
+
+* Delay, DelayFrame is not work correctly because can not get deltaTime in editor. Return the result of the await immediately; you can use `DelayType.Realtime` to wait for the right time.
+* All PlayerLoopTiming run on timing, `EditorApplication.update`.
+
 Compare with Standard Task API
 ---
 UniTask has many standard Task-like APIs. This table shows what is the alternative apis.
@@ -882,7 +906,7 @@ After Unity 2019.3.4f1, Unity 2020.1a21, that support path query parameter of gi
 
 or add `"com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask"` to `Packages/manifest.json`.
 
-If you want to set a target version, UniTask is using `*.*.*` release tag so you can specify a version like `#2.0.31`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.0.31`.
+If you want to set a target version, UniTask is using `*.*.*` release tag so you can specify a version like `#2.0.34`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.0.34`.
 
 ### Install via OpenUPM
 

src/UniTask.NetCore/NetCore/UniTask.Yield.cs

@@ -62,7 +62,8 @@ namespace Cysharp.Threading.Tasks
             sealed class ThreadPoolWorkItem : IThreadPoolWorkItem, ITaskPoolNode<ThreadPoolWorkItem>
             {
                 static TaskPool<ThreadPoolWorkItem> pool;
-                public ThreadPoolWorkItem NextNode { get; set; }
+                ThreadPoolWorkItem nextNode;
+                public ref ThreadPoolWorkItem NextNode => ref nextNode;
 
                 static ThreadPoolWorkItem()
                 {

src/UniTask.NetCoreSandbox/QueueCheck.cs

@@ -10,11 +10,14 @@ public class QueueCheck
 {
     Node node1 = new Node();
     Node node2 = new Node();
+    RefNode refNode1 = new RefNode();
+    RefNode refNode2 = new RefNode();
     Queue<Node> q1 = new Queue<Node>();
     Stack<Node> s1 = new Stack<Node>();
     ConcurrentQueue<Node> cq = new ConcurrentQueue<Node>();
     ConcurrentStack<Node> cs = new ConcurrentStack<Node>();
     static TaskPool<Node> pool;
+    static TaskPoolRefNode<RefNode> poolRefNode;
     static TaskPoolEqualNull<Node> poolEqualNull;
     static TaskPoolClass<Node> poolClass = new TaskPoolClass<Node>();
     static TaskPoolWithoutSize<Node> poolWithoutSize;
@@ -82,6 +85,14 @@ public class QueueCheck
         pool.TryPop(out _);
         pool.TryPop(out _);
     }
+    [Benchmark]
+    public void TaskPoolRefNode()
+    {
+        poolRefNode.TryPush(refNode1);
+        poolRefNode.TryPush(refNode2);
+        poolRefNode.TryPop(out _);
+        poolRefNode.TryPop(out _);
+    }
 
     [Benchmark]
     public void TaskPoolEqualNull()
@@ -130,6 +141,18 @@ public interface ITaskPoolNode<T>
     T NextNode { get; set; }
 }
 
+public sealed class RefNode :ITaskPoolRefNode<RefNode>
+{
+    RefNode nextNode;
+    public ref RefNode NextNode => ref nextNode;
+}
+
+public interface ITaskPoolRefNode<T>
+{
+    ref T NextNode { get; }
+}
+
+
 // mutable struct, don't mark readonly.
 [StructLayout(LayoutKind.Auto)]
 public struct TaskPoolWithoutLock<T>
@@ -237,6 +260,60 @@ public struct TaskPool<T>
         return false;
     }
 }
+[StructLayout(LayoutKind.Auto)]
+public struct TaskPoolRefNode<T>
+    where T : class, ITaskPoolRefNode<T>
+{
+    int gate;
+    int size;
+    T root;
+
+    public int Size => size;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPop(out T result)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            var v = root;
+            if (!(v is null))
+            {
+                ref var nextNode = ref v.NextNode;
+                root = nextNode;
+                nextNode = null;
+                size--;
+                result = v;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+
+            Volatile.Write(ref gate, 0);
+        }
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPush(T item)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            //if (size < TaskPool.MaxPoolSize)
+            {
+                item.NextNode = root;
+                root = item;
+                size++;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+            //else
+            {
+                //  Volatile.Write(ref gate, 0);
+            }
+        }
+        return false;
+    }
+}
 
 [StructLayout(LayoutKind.Auto)]
 public struct TaskPoolEqualNull<T>

src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncReactiveProperty.cs

@@ -87,7 +87,8 @@ namespace Cysharp.Threading.Tasks
             static Action<object> cancellationCallback = CancellationCallback;
 
             static TaskPool<WaitAsyncSource> pool;
-            WaitAsyncSource ITaskPoolNode<WaitAsyncSource>.NextNode { get; set; }
+            WaitAsyncSource nextNode;
+            ref WaitAsyncSource ITaskPoolNode<WaitAsyncSource>.NextNode => ref nextNode;
 
             static WaitAsyncSource()
             {
@@ -404,7 +405,8 @@ namespace Cysharp.Threading.Tasks
             static Action<object> cancellationCallback = CancellationCallback;
 
             static TaskPool<WaitAsyncSource> pool;
-            WaitAsyncSource ITaskPoolNode<WaitAsyncSource>.NextNode { get; set; }
+            WaitAsyncSource nextNode;
+            ref WaitAsyncSource ITaskPoolNode<WaitAsyncSource>.NextNode => ref nextNode;
 
             static WaitAsyncSource()
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/StateMachineRunner.cs

@@ -87,7 +87,8 @@ namespace Cysharp.Threading.Tasks.CompilerServices
             TaskPool.RegisterSizeGetter(typeof(AsyncUniTaskVoid<TStateMachine>), () => pool.Size);
         }
 
-        public AsyncUniTaskVoid<TStateMachine> NextNode { get; set; }
+        AsyncUniTaskVoid<TStateMachine> nextNode;
+        public ref AsyncUniTaskVoid<TStateMachine> NextNode => ref nextNode;
 
         public void Return()
         {
@@ -157,7 +158,8 @@ namespace Cysharp.Threading.Tasks.CompilerServices
             result.stateMachine = stateMachine; // copy struct StateMachine(in release build).
         }
 
-        public AsyncUniTask<TStateMachine> NextNode { get; set; }
+        AsyncUniTask<TStateMachine> nextNode;
+        public ref AsyncUniTask<TStateMachine> NextNode => ref nextNode;
 
         static AsyncUniTask()
         {
@@ -279,7 +281,8 @@ namespace Cysharp.Threading.Tasks.CompilerServices
             result.stateMachine = stateMachine; // copy struct StateMachine(in release build).
         }
 
-        public AsyncUniTask<TStateMachine, T> NextNode { get; set; }
+        AsyncUniTask<TStateMachine, T> nextNode;
+        public ref AsyncUniTask<TStateMachine, T> NextNode => ref nextNode;
 
         static AsyncUniTask()
         {

src/UniTask/Assets/Plugins/UniTask/Runtime/EnumeratorAsyncExtensions.cs

@@ -35,7 +35,8 @@ namespace Cysharp.Threading.Tasks
         sealed class EnumeratorPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<EnumeratorPromise>
         {
             static TaskPool<EnumeratorPromise> pool;
-            public EnumeratorPromise NextNode { get; set; }
+            EnumeratorPromise nextNode;
+            public ref EnumeratorPromise NextNode => ref nextNode;
 
             static EnumeratorPromise()
             {
@@ -45,6 +46,8 @@ namespace Cysharp.Threading.Tasks
             IEnumerator innerEnumerator;
             CancellationToken cancellationToken;
             int initialFrame;
+            bool loopRunning;
+            bool calledGetResult;
 
             UniTaskCompletionSourceCore<object> core;
 
@@ -67,6 +70,8 @@ namespace Cysharp.Threading.Tasks
 
                 result.innerEnumerator = ConsumeEnumerator(innerEnumerator);
                 result.cancellationToken = cancellationToken;
+                result.loopRunning = true;
+                result.calledGetResult = false;
                 result.initialFrame = -1;
 
                 PlayerLoopHelper.AddAction(timing, result);
@@ -81,11 +86,15 @@ namespace Cysharp.Threading.Tasks
             {
                 try
                 {
+                    calledGetResult = true;
                     core.GetResult(token);
                 }
                 finally
                 {
-                    TryReturn();
+                    if (!loopRunning)
+                    {
+                        TryReturn();
+                    }
                 }
             }
 
@@ -106,8 +115,21 @@ namespace Cysharp.Threading.Tasks
 
             public bool MoveNext()
             {
+                if (calledGetResult)
+                {
+                    loopRunning = false;
+                    TryReturn();
+                    return false;
+                }
+
+                if (innerEnumerator == null) // invalid status, returned but loop running?
+                {
+                    return false;
+                }
+
                 if (cancellationToken.IsCancellationRequested)
                 {
+                    loopRunning = false;
                     core.TrySetCanceled(cancellationToken);
                     return false;
                 }
@@ -134,10 +156,12 @@ namespace Cysharp.Threading.Tasks
                 }
                 catch (Exception ex)
                 {
+                    loopRunning = false;
                     core.TrySetException(ex);
                     return false;
                 }
 
+                loopRunning = false;
                 core.TrySetResult(null);
                 return false;
             }
@@ -162,11 +186,10 @@ namespace Cysharp.Threading.Tasks
                     {
                         yield return null;
                     }
-                    else if (current is CustomYieldInstruction)
+                    else if (current is CustomYieldInstruction cyi)
                     {
                         // WWW, WaitForSecondsRealtime
-                        var e2 = UnwrapWaitCustomYieldInstruction((CustomYieldInstruction)current);
-                        while (e2.MoveNext())
+                        while (cyi.keepWaiting)
                         {
                             yield return null;
                         }
@@ -211,15 +234,6 @@ namespace Cysharp.Threading.Tasks
                 }
             }
 
-            // WWW and others as CustomYieldInstruction.
-            static IEnumerator UnwrapWaitCustomYieldInstruction(CustomYieldInstruction yieldInstruction)
-            {
-                while (yieldInstruction.keepWaiting)
-                {
-                    yield return null;
-                }
-            }
-
             static readonly FieldInfo waitForSeconds_Seconds = typeof(WaitForSeconds).GetField("m_Seconds", BindingFlags.Instance | BindingFlags.GetField | BindingFlags.NonPublic);
 
             static IEnumerator UnwrapWaitForSeconds(WaitForSeconds waitForSeconds)

src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables/AddressablesAsyncExtensions.cs

@@ -13,7 +13,7 @@ namespace Cysharp.Threading.Tasks
 {
     public static class AddressablesAsyncExtensions
     {
-        #region AsyncOperationHandle
+#region AsyncOperationHandle
 
         public static UniTask.Awaiter GetAwaiter(this AsyncOperationHandle handle)
         {
@@ -31,7 +31,8 @@ namespace Cysharp.Threading.Tasks
 
             if (!handle.IsValid())
             {
-                throw new Exception("Attempting to use an invalid operation handle");
+                // autoReleaseHandle:true handle is invalid(immediately internal handle == null) so return completed.
+                return UniTask.CompletedTask;
             }
 
             if (handle.IsDone)
@@ -94,7 +95,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleConfiguredSource>
         {
             static TaskPool<AsyncOperationHandleConfiguredSource> pool;
-            public AsyncOperationHandleConfiguredSource NextNode { get; set; }
+            AsyncOperationHandleConfiguredSource nextNode;
+            public ref AsyncOperationHandleConfiguredSource NextNode => ref nextNode;
 
             static AsyncOperationHandleConfiguredSource()
             {
@@ -221,9 +223,9 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        #endregion
+#endregion
 
-        #region AsyncOperationHandle_T
+#region AsyncOperationHandle_T
 
         public static UniTask<T>.Awaiter GetAwaiter<T>(this AsyncOperationHandle<T> handle)
         {
@@ -259,7 +261,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AsyncOperationHandleConfiguredSource<T> : IUniTaskSource<T>, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleConfiguredSource<T>>
         {
             static TaskPool<AsyncOperationHandleConfiguredSource<T>> pool;
-            public AsyncOperationHandleConfiguredSource<T> NextNode { get; set; }
+            AsyncOperationHandleConfiguredSource<T> nextNode;
+            public ref AsyncOperationHandleConfiguredSource<T> NextNode => ref nextNode;
 
             static AsyncOperationHandleConfiguredSource()
             {
@@ -391,7 +394,7 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        #endregion
+#endregion
     }
 }
 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween/DOTweenAsyncExtensions.cs

@@ -135,7 +135,8 @@ namespace Cysharp.Threading.Tasks
         sealed class TweenConfiguredSource : IUniTaskSource, ITaskPoolNode<TweenConfiguredSource>
         {
             static TaskPool<TweenConfiguredSource> pool;
-            public TweenConfiguredSource NextNode { get; set; }
+            TweenConfiguredSource nextNode;
+            public ref TweenConfiguredSource NextNode => ref nextNode;
 
             static TweenConfiguredSource()
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ContinuationQueue.cs

@@ -170,9 +170,9 @@ namespace Cysharp.Threading.Tasks.Internal
 
             for (int i = 0; i < actionListCount; i++)
             {
+
                 var action = actionList[i];
                 actionList[i] = null;
-
                 try
                 {
                     action();

src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PlayerLoopRunner.cs

@@ -143,6 +143,7 @@ namespace Cysharp.Threading.Tasks.Internal
             {
                 var j = tail - 1;
 
+                var loopItems = this.loopItems;
                 // eliminate array-bound check for i
                 for (int i = 0; i < loopItems.Length; i++)
                 {

src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PooledDelegate.cs

@@ -7,7 +7,8 @@ namespace Cysharp.Threading.Tasks.Internal
     {
         static TaskPool<PooledDelegate<T>> pool;
 
-        public PooledDelegate<T> NextNode { get; set; }
+        PooledDelegate<T> nextNode;
+        public ref PooledDelegate<T> NextNode => ref nextNode;
 
         static PooledDelegate()
         {

src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs

@@ -288,7 +288,7 @@ namespace Cysharp.Threading.Tasks
             // Initialization
             copyList[0].subSystemList = InsertRunner(copyList[0], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(PlayerLoopTiming.Initialization),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldInitialization), yielders[1] = new ContinuationQueue(PlayerLoopTiming.LastInitialization),
-                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[1] = new PlayerLoopRunner(PlayerLoopTiming.Initialization),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[0] = new PlayerLoopRunner(PlayerLoopTiming.Initialization),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastInitialization), runners[1] = new PlayerLoopRunner(PlayerLoopTiming.LastInitialization));
             // EarlyUpdate
             copyList[1].subSystemList = InsertRunner(copyList[1], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[2] = new ContinuationQueue(PlayerLoopTiming.EarlyUpdate),

src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs

@@ -55,7 +55,7 @@ namespace Cysharp.Threading.Tasks
 
     public interface ITaskPoolNode<T>
     {
-        T NextNode { get; set; }
+        ref T NextNode { get; }
     }
 
     // mutable struct, don't mark readonly.
@@ -77,8 +77,9 @@ namespace Cysharp.Threading.Tasks
                 var v = root;
                 if (!(v is null))
                 {
-                    root = v.NextNode;
-                    v.NextNode = null;
+                    ref var nextNode = ref v.NextNode;
+                    root = nextNode;
+                    nextNode = null;
                     size--;
                     result = v;
                     Volatile.Write(ref gate, 0);

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs

@@ -127,7 +127,8 @@ namespace Cysharp.Threading.Tasks
         sealed class YieldPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<YieldPromise>
         {
             static TaskPool<YieldPromise> pool;
-            public YieldPromise NextNode { get; set; }
+            YieldPromise nextNode;
+            public ref YieldPromise NextNode => ref nextNode;
 
             static YieldPromise()
             {
@@ -215,7 +216,8 @@ namespace Cysharp.Threading.Tasks
         sealed class NextFramePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<NextFramePromise>
         {
             static TaskPool<NextFramePromise> pool;
-            public NextFramePromise NextNode { get; set; }
+            NextFramePromise nextNode;
+            public ref NextFramePromise NextNode => ref nextNode;
 
             static NextFramePromise()
             {
@@ -309,7 +311,8 @@ namespace Cysharp.Threading.Tasks
         sealed class DelayFramePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<DelayFramePromise>
         {
             static TaskPool<DelayFramePromise> pool;
-            public DelayFramePromise NextNode { get; set; }
+            DelayFramePromise nextNode;
+            public ref DelayFramePromise NextNode => ref nextNode;
 
             static DelayFramePromise()
             {
@@ -424,7 +427,8 @@ namespace Cysharp.Threading.Tasks
         sealed class DelayPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<DelayPromise>
         {
             static TaskPool<DelayPromise> pool;
-            public DelayPromise NextNode { get; set; }
+            DelayPromise nextNode;
+            public ref DelayPromise NextNode => ref nextNode;
 
             static DelayPromise()
             {
@@ -534,7 +538,8 @@ namespace Cysharp.Threading.Tasks
         sealed class DelayIgnoreTimeScalePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<DelayIgnoreTimeScalePromise>
         {
             static TaskPool<DelayIgnoreTimeScalePromise> pool;
-            public DelayIgnoreTimeScalePromise NextNode { get; set; }
+            DelayIgnoreTimeScalePromise nextNode;
+            public ref DelayIgnoreTimeScalePromise NextNode => ref nextNode;
 
             static DelayIgnoreTimeScalePromise()
             {
@@ -644,7 +649,8 @@ namespace Cysharp.Threading.Tasks
         sealed class DelayRealtimePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<DelayRealtimePromise>
         {
             static TaskPool<DelayRealtimePromise> pool;
-            public DelayRealtimePromise NextNode { get; set; }
+            DelayRealtimePromise nextNode;
+            public ref DelayRealtimePromise NextNode => ref nextNode;
 
             static DelayRealtimePromise()
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Run.cs

@@ -7,7 +7,11 @@ namespace Cysharp.Threading.Tasks
 {
     public partial struct UniTask
     {
-        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        #region OBSOLETE_RUN
+
+        // Run is a confusing name, use only RunOnThreadPool in the future.
+
+        /// <summary>[Obsolete]recommend to use RunOnThreadPool(or UniTask.Void(async void), UniTask.Create(async UniTask)).</summary>
         public static async UniTask Run(Action action, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -35,7 +39,7 @@ namespace Cysharp.Threading.Tasks
             cancellationToken.ThrowIfCancellationRequested();
         }
 
-        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        /// <summary>[Obsolete]recommend to use RunOnThreadPool(or UniTask.Void(async void), UniTask.Create(async UniTask)).</summary>
         public static async UniTask Run(Action<object> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -63,7 +67,7 @@ namespace Cysharp.Threading.Tasks
             cancellationToken.ThrowIfCancellationRequested();
         }
 
-        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        /// <summary>[Obsolete]recommend to use RunOnThreadPool(or UniTask.Void(async void), UniTask.Create(async UniTask)).</summary>
         public static async UniTask Run(Func<UniTask> action, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -91,7 +95,7 @@ namespace Cysharp.Threading.Tasks
             cancellationToken.ThrowIfCancellationRequested();
         }
 
-        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        /// <summary>[Obsolete]recommend to use RunOnThreadPool(or UniTask.Void(async void), UniTask.Create(async UniTask)).</summary>
         public static async UniTask Run(Func<object, UniTask> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -119,7 +123,7 @@ namespace Cysharp.Threading.Tasks
             cancellationToken.ThrowIfCancellationRequested();
         }
 
-        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        /// <summary>[Obsolete]recommend to use RunOnThreadPool(or UniTask.Void(async void), UniTask.Create(async UniTask)).</summary>
         public static async UniTask<T> Run<T>(Func<T> func, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -146,7 +150,7 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        /// <summary>[Obsolete]recommend to use RunOnThreadPool(or UniTask.Void(async void), UniTask.Create(async UniTask)).</summary>
         public static async UniTask<T> Run<T>(Func<UniTask<T>> func, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -176,7 +180,7 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        /// <summary>[Obsolete]recommend to use RunOnThreadPool(or UniTask.Void(async void), UniTask.Create(async UniTask)).</summary>
         public static async UniTask<T> Run<T>(Func<object, T> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -203,7 +207,7 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        /// <summary>[Obsolete]recommend to use RunOnThreadPool(or UniTask.Void(async void), UniTask.Create(async UniTask)).</summary>
         public static async UniTask<T> Run<T>(Func<object, UniTask<T>> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -232,6 +236,235 @@ namespace Cysharp.Threading.Tasks
                 return result;
             }
         }
+
+        #endregion
+
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask RunOnThreadPool(Action action, bool configureAwait = true, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    action();
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                action();
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask RunOnThreadPool(Action<object> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    action(state);
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                action(state);
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask RunOnThreadPool(Func<UniTask> action, bool configureAwait = true, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    await action();
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                await action();
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask RunOnThreadPool(Func<object, UniTask> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    await action(state);
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                await action(state);
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask<T> RunOnThreadPool<T>(Func<T> func, bool configureAwait = true, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    return func();
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                    cancellationToken.ThrowIfCancellationRequested();
+                }
+            }
+            else
+            {
+                return func();
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask<T> RunOnThreadPool<T>(Func<UniTask<T>> func, bool configureAwait = true, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    return await func();
+                }
+                finally
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    await UniTask.Yield();
+                    cancellationToken.ThrowIfCancellationRequested();
+                }
+            }
+            else
+            {
+                var result = await func();
+                cancellationToken.ThrowIfCancellationRequested();
+                return result;
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask<T> RunOnThreadPool<T>(Func<object, T> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    return func(state);
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                    cancellationToken.ThrowIfCancellationRequested();
+                }
+            }
+            else
+            {
+                return func(state);
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask<T> RunOnThreadPool<T>(Func<object, UniTask<T>> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    return await func(state);
+                }
+                finally
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    await UniTask.Yield();
+                    cancellationToken.ThrowIfCancellationRequested();
+                }
+            }
+            else
+            {
+                var result = await func(state);
+                cancellationToken.ThrowIfCancellationRequested();
+                return result;
+            }
+        }
     }
 }
 

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Threading.cs

@@ -224,7 +224,8 @@ namespace Cysharp.Threading.Tasks
         sealed class ThreadPoolWorkItem : IThreadPoolWorkItem, ITaskPoolNode<ThreadPoolWorkItem>
         {
             static TaskPool<ThreadPoolWorkItem> pool;
-            public ThreadPoolWorkItem NextNode { get; set; }
+            ThreadPoolWorkItem nextNode;
+            public ref ThreadPoolWorkItem NextNode => ref nextNode;
 
             static ThreadPoolWorkItem()
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WaitUntil.cs

@@ -38,7 +38,8 @@ namespace Cysharp.Threading.Tasks
         sealed class WaitUntilPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<WaitUntilPromise>
         {
             static TaskPool<WaitUntilPromise> pool;
-            public WaitUntilPromise NextNode { get; set; }
+            WaitUntilPromise nextNode;
+            public ref WaitUntilPromise NextNode => ref nextNode;
 
             static WaitUntilPromise()
             {
@@ -142,7 +143,8 @@ namespace Cysharp.Threading.Tasks
         sealed class WaitWhilePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<WaitWhilePromise>
         {
             static TaskPool<WaitWhilePromise> pool;
-            public WaitWhilePromise NextNode { get; set; }
+            WaitWhilePromise nextNode;
+            public ref WaitWhilePromise NextNode => ref nextNode;
 
             static WaitWhilePromise()
             {
@@ -246,7 +248,8 @@ namespace Cysharp.Threading.Tasks
         sealed class WaitUntilCanceledPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<WaitUntilCanceledPromise>
         {
             static TaskPool<WaitUntilCanceledPromise> pool;
-            public WaitUntilCanceledPromise NextNode { get; set; }
+            WaitUntilCanceledPromise nextNode;
+            public ref WaitUntilCanceledPromise NextNode => ref nextNode;
 
             static WaitUntilCanceledPromise()
             {
@@ -334,7 +337,8 @@ namespace Cysharp.Threading.Tasks
         sealed class WaitUntilValueChangedUnityObjectPromise<T, U> : IUniTaskSource<U>, IPlayerLoopItem, ITaskPoolNode<WaitUntilValueChangedUnityObjectPromise<T, U>>
         {
             static TaskPool<WaitUntilValueChangedUnityObjectPromise<T, U>> pool;
-            public WaitUntilValueChangedUnityObjectPromise<T, U> NextNode { get; set; }
+            WaitUntilValueChangedUnityObjectPromise<T, U> nextNode;
+            public ref WaitUntilValueChangedUnityObjectPromise<T, U> NextNode => ref nextNode;
 
             static WaitUntilValueChangedUnityObjectPromise()
             {
@@ -457,7 +461,8 @@ namespace Cysharp.Threading.Tasks
             where T : class
         {
             static TaskPool<WaitUntilValueChangedStandardObjectPromise<T, U>> pool;
-            public WaitUntilValueChangedStandardObjectPromise<T, U> NextNode { get; set; }
+            WaitUntilValueChangedStandardObjectPromise<T, U> nextNode;
+            public ref WaitUntilValueChangedStandardObjectPromise<T, U> NextNode => ref nextNode;
 
             static WaitUntilValueChangedStandardObjectPromise()
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskCompletionSource.cs

@@ -319,7 +319,8 @@ namespace Cysharp.Threading.Tasks
     public class AutoResetUniTaskCompletionSource : IUniTaskSource, ITaskPoolNode<AutoResetUniTaskCompletionSource>, IPromise
     {
         static TaskPool<AutoResetUniTaskCompletionSource> pool;
-        public AutoResetUniTaskCompletionSource NextNode { get; set; }
+        AutoResetUniTaskCompletionSource nextNode;
+        public ref AutoResetUniTaskCompletionSource NextNode => ref nextNode;
 
         static AutoResetUniTaskCompletionSource()
         {
@@ -441,7 +442,8 @@ namespace Cysharp.Threading.Tasks
     public class AutoResetUniTaskCompletionSource<T> : IUniTaskSource<T>, ITaskPoolNode<AutoResetUniTaskCompletionSource<T>>, IPromise<T>
     {
         static TaskPool<AutoResetUniTaskCompletionSource<T>> pool;
-        public AutoResetUniTaskCompletionSource<T> NextNode { get; set; }
+        AutoResetUniTaskCompletionSource<T> nextNode;
+        public ref AutoResetUniTaskCompletionSource<T> NextNode => ref nextNode;
 
         static AutoResetUniTaskCompletionSource()
         {

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.cs

@@ -732,10 +732,50 @@ namespace Cysharp.Threading.Tasks
             return await await task;
         }
 
-        public static async UniTask Unwrap<T>(this UniTask<UniTask> task)
+        public static async UniTask Unwrap(this UniTask<UniTask> task)
         {
             await await task;
         }
+        
+        public static async UniTask<T> Unwrap<T>(this Task<UniTask<T>> task)
+        {
+            return await await task;
+        }
+        
+        public static async UniTask<T> Unwrap<T>(this Task<UniTask<T>> task, bool continueOnCapturedContext)
+        {
+            return await await task.ConfigureAwait(continueOnCapturedContext);
+        }
+
+        public static async UniTask Unwrap(this Task<UniTask> task)
+        {
+            await await task;
+        }
+
+        public static async UniTask Unwrap(this Task<UniTask> task, bool continueOnCapturedContext)
+        {
+            await await task.ConfigureAwait(continueOnCapturedContext);
+        }
+        
+        public static async UniTask<T> Unwrap<T>(this UniTask<Task<T>> task)
+        {
+            return await await task;
+        }
+        
+        public static async UniTask<T> Unwrap<T>(this UniTask<Task<T>> task, bool continueOnCapturedContext)
+        {
+            return await (await task).ConfigureAwait(continueOnCapturedContext);
+        }
+
+        public static async UniTask Unwrap(this UniTask<Task> task)
+        {
+            await await task;
+        }
+
+        public static async UniTask Unwrap(this UniTask<Task> task, bool continueOnCapturedContext)
+        {
+            await (await task).ConfigureAwait(continueOnCapturedContext);
+        }
 
 #if UNITY_2018_3_OR_NEWER
 

src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AssetBundleRequestAllAssets.cs

@@ -46,6 +46,11 @@ namespace Cysharp.Threading.Tasks
                 this.continuationAction = null;
             }
 
+            public AssetBundleRequestAllAssetsAwaiter GetAwaiter()
+            {
+                return this;
+            }
+
             public bool IsCompleted => asyncOperation.isDone;
 
             public UnityEngine.Object[] GetResult()
@@ -82,7 +87,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AssetBundleRequestAllAssetsWithCancellationSource : IUniTaskSource<UnityEngine.Object[]>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestAllAssetsWithCancellationSource>
         {
             static TaskPool<AssetBundleRequestAllAssetsWithCancellationSource> pool;
-            public AssetBundleRequestAllAssetsWithCancellationSource NextNode { get; set; }
+            AssetBundleRequestAllAssetsWithCancellationSource nextNode;
+            public ref AssetBundleRequestAllAssetsWithCancellationSource NextNode => ref nextNode;
 
             static AssetBundleRequestAllAssetsWithCancellationSource()
             {
@@ -204,7 +210,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AssetBundleRequestAllAssetsConfiguredSource : IUniTaskSource<UnityEngine.Object[]>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestAllAssetsConfiguredSource>
         {
             static TaskPool<AssetBundleRequestAllAssetsConfiguredSource> pool;
-            public AssetBundleRequestAllAssetsConfiguredSource NextNode { get; set; }
+            AssetBundleRequestAllAssetsConfiguredSource nextNode;
+            public ref AssetBundleRequestAllAssetsConfiguredSource NextNode => ref nextNode;
 
             static AssetBundleRequestAllAssetsConfiguredSource()
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AsyncGPUReadback.cs

@@ -29,7 +29,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AsyncGPUReadbackRequestAwaiterConfiguredSource : IUniTaskSource<AsyncGPUReadbackRequest>, IPlayerLoopItem, ITaskPoolNode<AsyncGPUReadbackRequestAwaiterConfiguredSource>
         {
             static TaskPool<AsyncGPUReadbackRequestAwaiterConfiguredSource> pool;
-            public AsyncGPUReadbackRequestAwaiterConfiguredSource NextNode { get; set; }
+            AsyncGPUReadbackRequestAwaiterConfiguredSource nextNode;
+            public ref AsyncGPUReadbackRequestAwaiterConfiguredSource NextNode => ref nextNode;
 
             static AsyncGPUReadbackRequestAwaiterConfiguredSource()
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.cs

@@ -80,7 +80,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AsyncOperationWithCancellationSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationWithCancellationSource>
         {
             static TaskPool<AsyncOperationWithCancellationSource> pool;
-            public AsyncOperationWithCancellationSource NextNode { get; set; }
+            AsyncOperationWithCancellationSource nextNode;
+            public ref AsyncOperationWithCancellationSource NextNode => ref nextNode;
 
             static AsyncOperationWithCancellationSource()
             {
@@ -198,7 +199,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AsyncOperationConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationConfiguredSource>
         {
             static TaskPool<AsyncOperationConfiguredSource> pool;
-            public AsyncOperationConfiguredSource NextNode { get; set; }
+            AsyncOperationConfiguredSource nextNode;
+            public ref AsyncOperationConfiguredSource NextNode => ref nextNode;
 
             static AsyncOperationConfiguredSource()
             {
@@ -374,7 +376,8 @@ namespace Cysharp.Threading.Tasks
         sealed class ResourceRequestWithCancellationSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<ResourceRequestWithCancellationSource>
         {
             static TaskPool<ResourceRequestWithCancellationSource> pool;
-            public ResourceRequestWithCancellationSource NextNode { get; set; }
+            ResourceRequestWithCancellationSource nextNode;
+            public ref ResourceRequestWithCancellationSource NextNode => ref nextNode;
 
             static ResourceRequestWithCancellationSource()
             {
@@ -496,7 +499,8 @@ namespace Cysharp.Threading.Tasks
         sealed class ResourceRequestConfiguredSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<ResourceRequestConfiguredSource>
         {
             static TaskPool<ResourceRequestConfiguredSource> pool;
-            public ResourceRequestConfiguredSource NextNode { get; set; }
+            ResourceRequestConfiguredSource nextNode;
+            public ref ResourceRequestConfiguredSource NextNode => ref nextNode;
 
             static ResourceRequestConfiguredSource()
             {
@@ -677,7 +681,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AssetBundleRequestWithCancellationSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestWithCancellationSource>
         {
             static TaskPool<AssetBundleRequestWithCancellationSource> pool;
-            public AssetBundleRequestWithCancellationSource NextNode { get; set; }
+            AssetBundleRequestWithCancellationSource nextNode;
+            public ref AssetBundleRequestWithCancellationSource NextNode => ref nextNode;
 
             static AssetBundleRequestWithCancellationSource()
             {
@@ -799,7 +804,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AssetBundleRequestConfiguredSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestConfiguredSource>
         {
             static TaskPool<AssetBundleRequestConfiguredSource> pool;
-            public AssetBundleRequestConfiguredSource NextNode { get; set; }
+            AssetBundleRequestConfiguredSource nextNode;
+            public ref AssetBundleRequestConfiguredSource NextNode => ref nextNode;
 
             static AssetBundleRequestConfiguredSource()
             {
@@ -981,7 +987,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AssetBundleCreateRequestWithCancellationSource : IUniTaskSource<AssetBundle>, IPlayerLoopItem, ITaskPoolNode<AssetBundleCreateRequestWithCancellationSource>
         {
             static TaskPool<AssetBundleCreateRequestWithCancellationSource> pool;
-            public AssetBundleCreateRequestWithCancellationSource NextNode { get; set; }
+            AssetBundleCreateRequestWithCancellationSource nextNode;
+            public ref AssetBundleCreateRequestWithCancellationSource NextNode => ref nextNode;
 
             static AssetBundleCreateRequestWithCancellationSource()
             {
@@ -1103,7 +1110,8 @@ namespace Cysharp.Threading.Tasks
         sealed class AssetBundleCreateRequestConfiguredSource : IUniTaskSource<AssetBundle>, IPlayerLoopItem, ITaskPoolNode<AssetBundleCreateRequestConfiguredSource>
         {
             static TaskPool<AssetBundleCreateRequestConfiguredSource> pool;
-            public AssetBundleCreateRequestConfiguredSource NextNode { get; set; }
+            AssetBundleCreateRequestConfiguredSource nextNode;
+            public ref AssetBundleCreateRequestConfiguredSource NextNode => ref nextNode;
 
             static AssetBundleCreateRequestConfiguredSource()
             {
@@ -1307,7 +1315,8 @@ namespace Cysharp.Threading.Tasks
         sealed class UnityWebRequestAsyncOperationWithCancellationSource : IUniTaskSource<UnityWebRequest>, IPlayerLoopItem, ITaskPoolNode<UnityWebRequestAsyncOperationWithCancellationSource>
         {
             static TaskPool<UnityWebRequestAsyncOperationWithCancellationSource> pool;
-            public UnityWebRequestAsyncOperationWithCancellationSource NextNode { get; set; }
+            UnityWebRequestAsyncOperationWithCancellationSource nextNode;
+            public ref UnityWebRequestAsyncOperationWithCancellationSource NextNode => ref nextNode;
 
             static UnityWebRequestAsyncOperationWithCancellationSource()
             {
@@ -1438,7 +1447,8 @@ namespace Cysharp.Threading.Tasks
         sealed class UnityWebRequestAsyncOperationConfiguredSource : IUniTaskSource<UnityWebRequest>, IPlayerLoopItem, ITaskPoolNode<UnityWebRequestAsyncOperationConfiguredSource>
         {
             static TaskPool<UnityWebRequestAsyncOperationConfiguredSource> pool;
-            public UnityWebRequestAsyncOperationConfiguredSource NextNode { get; set; }
+            UnityWebRequestAsyncOperationConfiguredSource nextNode;
+            public ref UnityWebRequestAsyncOperationConfiguredSource NextNode => ref nextNode;
 
             static UnityWebRequestAsyncOperationConfiguredSource()
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.tt

@@ -154,7 +154,8 @@ namespace Cysharp.Threading.Tasks
         sealed class <#= t.typeName #>WithCancellationSource : <#= ToIUniTaskSourceReturnType(t.returnType) #>, IPlayerLoopItem, ITaskPoolNode<<#= t.typeName #>WithCancellationSource>
         {
             static TaskPool<<#= t.typeName #>WithCancellationSource> pool;
-            public <#= t.typeName #>WithCancellationSource NextNode { get; set; }
+            <#= t.typeName #>WithCancellationSource nextNode;
+            public ref <#= t.typeName #>WithCancellationSource NextNode => ref nextNode;
 
             static <#= t.typeName #>WithCancellationSource()
             {
@@ -297,7 +298,8 @@ namespace Cysharp.Threading.Tasks
         sealed class <#= t.typeName #>ConfiguredSource : <#= ToIUniTaskSourceReturnType(t.returnType) #>, IPlayerLoopItem, ITaskPoolNode<<#= t.typeName #>ConfiguredSource>
         {
             static TaskPool<<#= t.typeName #>ConfiguredSource> pool;
-            public <#= t.typeName #>ConfiguredSource NextNode { get; set; }
+            <#= t.typeName #>ConfiguredSource nextNode;
+            public ref <#= t.typeName #>ConfiguredSource NextNode => ref nextNode;
 
             static <#= t.typeName #>ConfiguredSource()
             {

src/UniTask/Assets/Plugins/UniTask/package.json

@@ -1,7 +1,7 @@
 {
     "name": "com.cysharp.unitask",
     "displayName": "UniTask",
-    "version": "2.0.31",
+    "version": "2.0.34",
     "unity": "2018.4",
     "description": "Provides an efficient async/await integration to Unity.",
     "keywords": [ "async/await", "async", "Task", "UniTask" ],

src/UniTask/Assets/Scenes/ExceptionExamples.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using UnityEngine;
+// using UnityEngine.AddressableAssets;
 
 /*UNniTastWhenAnyTester*/
 
@@ -49,4 +50,9 @@ public class ExceptionExamples : MonoBehaviour
         await UniTask.Delay(100);
         return taskIndex;
     }
+
+    //void AddressablesTest()
+    //{
+    //    Addressables.ClearDependencyCacheAsync("key", true);
+    //}
 }

src/UniTask/Assets/Scenes/SandboxMain.cs

@@ -492,7 +492,6 @@ public class SandboxMain : MonoBehaviour
         Debug.Log("Current SyncContext:" + SynchronizationContext.Current.GetType().FullName);
     }
 
-
     async UniTaskVoid Start()
     {
         //Expression.Lambda<Func<int>>(null).Compile(true);

src/UniTask/Assets/Tests/CoroutineToUniTaskTest.cs

@@ -96,6 +96,45 @@ namespace Cysharp.Threading.TasksTests
         //    l[1].Item2.Should().NotBe(currentFrame);
         //}
 
+        [UnityTest]
+        public IEnumerator ImmediateRunTest() => UniTask.ToCoroutine(async () =>
+        {
+            var l = new List<int>();
+            var x1 = Immediate(l);
+            var x2 = Immediate(l);
+            var x3 = DelayOne(l);
+
+            var t1 = x1.ToUniTask();
+            CollectionAssert.AreEqual(l, new[] { 1, 2, 3 });
+            await t1;
+
+            var t2 = x2.ToUniTask();
+            CollectionAssert.AreEqual(l, new[] { 1, 2, 3, 1, 2, 3 });
+
+            var t3 = x3.ToUniTask();
+            CollectionAssert.AreEqual(l, new[] { 1, 2, 3, 1, 2, 3, 10 });
+
+            await UniTask.WhenAll(t2, t3);
+            CollectionAssert.AreEqual(l, new[] { 1, 2, 3, 1, 2, 3, 10, 20, 30 });
+
+        });
+
+        IEnumerator Immediate(List<int> l)
+        {
+            l.Add(1);
+            l.Add(2);
+            l.Add(3);
+            yield break;
+        }
+
+        IEnumerator DelayOne(List<int> l)
+        {
+            l.Add(10);
+            yield return null;
+            l.Add(20);
+            l.Add(30);
+        }
+
         [UnityTest]
         public IEnumerator WaitForSecondsTest() => UniTask.ToCoroutine(async () =>
         {