2.0.33

Fixed AwaitForAllAssets()

README.md

@@ -15,6 +15,7 @@ Provides an efficient allocation free async/await integration to Unity.
 
 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)  
+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 -->

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

@@ -46,6 +46,8 @@ namespace Cysharp.Threading.Tasks
             IEnumerator innerEnumerator;
             CancellationToken cancellationToken;
             int initialFrame;
+            bool loopRunning;
+            bool calledGetResult;
 
             UniTaskCompletionSourceCore<object> core;
 
@@ -68,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);
@@ -82,11 +86,15 @@ namespace Cysharp.Threading.Tasks
             {
                 try
                 {
+                    calledGetResult = true;
                     core.GetResult(token);
                 }
                 finally
                 {
-                    TryReturn();
+                    if (!loopRunning)
+                    {
+                        TryReturn();
+                    }
                 }
             }
 
@@ -107,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;
                 }
@@ -135,10 +156,12 @@ namespace Cysharp.Threading.Tasks
                 }
                 catch (Exception ex)
                 {
+                    loopRunning = false;
                     core.TrySetException(ex);
                     return false;
                 }
 
+                loopRunning = false;
                 core.TrySetResult(null);
                 return false;
             }

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

@@ -732,7 +732,7 @@ 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;
         }
@@ -742,21 +742,41 @@ namespace Cysharp.Threading.Tasks
             return await await task;
         }
         
-        public static async UniTask Unwrap<T>(this Task<UniTask> 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 Unwrap<T>(this UniTask<Task> 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
 
         sealed class ToCoroutineEnumerator : IEnumerator

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()

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

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

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 () =>
         {