2.0.28

chore: remove generate unity alf (activation license file)

.github/workflows/build-debug.yml

@@ -42,13 +42,6 @@ jobs:
     steps:
       - run: apt update && apt install git -y
       - uses: actions/checkout@v2
-      # create unity activation file and store to artifacts.
-      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -logFile -createManualActivationFile || exit 0
-      - uses: actions/upload-artifact@v1
-        with:
-          name: Unity_v${{ matrix.unity }}.alf
-          path: ./Unity_v${{ matrix.unity }}.alf
-      # activate Unity from manual license file(ulf)
       - run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
         env:
           UNITY_LICENSE: ${{ secrets[matrix.license] }}

.gitignore

@@ -205,3 +205,51 @@ src/UniTask/UnityEngine.Monetization.csproj
 src/UniTask/UnityEngine.TestRunner.csproj
 
 src/UniTask/UnityEngine.UI.csproj
+
+src/UniTask/TempAsm.csproj
+
+src/UniTask/UniTask.Addressables.csproj
+
+src/UniTask/UniTask.DOTween.csproj
+
+src/UniTask/UniTask.TextMeshPro.csproj
+
+src/UniTask/RuntimeUnitTestToolkit.Player.csproj
+
+src/UniTask/TempAsm.Player.csproj
+
+src/UniTask/UniTask.Addressables.Player.csproj
+
+src/UniTask/UniTask.DOTween.Player.csproj
+
+src/UniTask/UniTask.Linq.Player.csproj
+
+src/UniTask/UniTask.Player.csproj
+
+src/UniTask/UniTask.Tests.Player.csproj
+
+src/UniTask/UniTask.TextMeshPro.Player.csproj
+
+src/UniTask/Unity.Addressables.Player.csproj
+
+src/UniTask/Unity.Analytics.DataPrivacy.Player.csproj
+
+src/UniTask/Unity.ResourceManager.Player.csproj
+
+src/UniTask/Unity.ScriptableBuildPipeline.Player.csproj
+
+src/UniTask/Unity.TextMeshPro.Player.csproj
+
+src/UniTask/Unity.Timeline.Player.csproj
+
+src/UniTask/UnityEngine.Advertisements.Player.csproj
+
+src/UniTask/UnityEngine.Monetization.Player.csproj
+
+src/UniTask/UnityEngine.TestRunner.Player.csproj
+
+src/UniTask/UnityEngine.UI.Player.csproj
+
+src/UniTask/DOTween.Modules.Player.csproj
+
+src/UniTask/Assembly-CSharp.Player.csproj

README.md

@@ -34,6 +34,8 @@ Techinical details, see blog post: [UniTask v2 — Zero Allocation async/await f
 - [For Unit Testing](#for-unit-testing)
 - [Compare with Standard Task API](#compare-with-standard-task-api)
 - [Pooling Configuration](#pooling-configuration)
+- [Allocation on Profiler](#allocation-on-profiler)
+- [UniTaskSynchronizationContext](#unitasksynchronizationcontext)
 - [API References](#api-references)
 - [UPM Package](#upm-package)
   - [Install via git URL](#install-via-git-url)
@@ -136,7 +138,7 @@ UniTask feature rely on C# 7.0([task-like custom async method builder feature](h
 
 Why UniTask(custom task-like object) is required? Because Task is too heavy, not matched to Unity threading(single-thread). UniTask does not use thread and SynchronizationContext/ExecutionContext because almost Unity's asynchronous object is automaticaly dispatched by Unity's engine layer. It acquires more fast and more less allocation, completely integrated with Unity.
 
-You can await `AsyncOperation`, `ResourceRequest`, `AssetBundleRequest`, `AssetBundleCreateRequest`, `UnityWebRequestAsyncOperation`, `IEnumerator` and others when `using Cysharp.Threading.Tasks;`.
+You can await `AsyncOperation`, `ResourceRequest`, `AssetBundleRequest`, `AssetBundleCreateRequest`, `UnityWebRequestAsyncOperation`, `AsyncGPUReadbackRequest`, `IEnumerator` and others when `using Cysharp.Threading.Tasks;`.
 
 UniTask provides three pattern of extension methods.
 
@@ -150,25 +152,24 @@ UniTask provides three pattern of extension methods.
 
 > Note: WithCancellation is returned from native timing of PlayerLoop but ToUniTask is returned from specified PlayerLoopTiming. Details of timing, see: [PlayerLoop](#playerloop) section.
 
+> Note: AssetBundleRequest has `asset` and `allAssets`, in default await returns `asset`. If you want to get `allAssets`, you can use `AwaitForAllAssets()` method.
+
 The type of `UniTask` can use utility like `UniTask.WhenAll`, `UniTask.WhenAny`. It is like Task.WhenAll/WhenAny but return type is more useful, returns value tuple so can deconsrtuct each result and pass multiple type.
 
 ```csharp
-public class SceneAssets
+public async UniTaskVoid LoadManyAsync()
 {
-    public SceneAssets()
-    {
-        // parallel load.
-        var (a, b, c) = await UniTask.WhenAll(
-            LoadAsSprite("foo"),
-            LoadAsSprite("bar"),
-            LoadAsSprite("baz"));
-    }
+    // parallel load.
+    var (a, b, c) = await UniTask.WhenAll(
+        LoadAsSprite("foo"),
+        LoadAsSprite("bar"),
+        LoadAsSprite("baz"));
+}
 
-    async UniTask<Sprite> LoadAsSprite(string path)
-    {
-        var resource = await Resources.LoadAsync<Sprite>(path);
-        return (resource as Sprite);
-    }
+async UniTask<Sprite> LoadAsSprite(string path)
+{
+    var resource = await Resources.LoadAsync<Sprite>(path);
+    return (resource as Sprite);
 }
 ```
 
@@ -208,7 +209,7 @@ await task;
 await task; // NG, throws Exception
 ```
 
-Store to the class field, you can use `UniTask.Lazy` that gurantee call multipletimes. `.Prevent()` allows for multiple calls (internally cached results). This is useful when multiple calls in a function scope.
+Store to the class field, you can use `UniTask.Lazy` that gurantee call multipletimes. `.Preserve()` allows for multiple calls (internally cached results). This is useful when multiple calls in a function scope.
 
 Cancellation and Exception handling
 ---
@@ -384,9 +385,19 @@ var playerLoop = ScriptBehaviourUpdateOrder.CurrentPlayerLoop;
 PlayerLoopHelper.Initialize(ref playerLoop);
 ```
 
+You can diagnostic UniTask's player loop is ready by `PlayerLoopHelper.IsInjectedUniTaskPlayerLoop()`. And also `PlayerLoopHelper.DumpCurrentPlayerLoop` shows current all playerloop to console.
+
+```csharp
+void Start()
+{
+    UnityEngine.Debug.Log("UniTaskPlayerLoop ready? " + PlayerLoopHelper.IsInjectedUniTaskPlayerLoop());
+    PlayerLoopHelper.DumpCurrentPlayerLoop();
+}
+```
+
 async void vs async UniTaskVoid
 ---
-`async void` is a standard C# taks system so does not run on UniTask systems. It is better not to use. `async UniTaskVoid` is a lightweight version of `async UniTask` because it does not have awaitable completion and report error immediately to `UniTaskScheduler.UnobservedTaskException`. If you don't require to await it(fire and forget), use `UniTaskVoid` is better. Unfortunately to dismiss warning, require to using with `Forget()`.
+`async void` is a standard C# task system so does not run on UniTask systems. It is better not to use. `async UniTaskVoid` is a lightweight version of `async UniTask` because it does not have awaitable completion and report error immediately to `UniTaskScheduler.UnobservedTaskException`. If you don't require to await it(fire and forget), use `UniTaskVoid` is better. Unfortunately to dismiss warning, require to using with `Forget()`.
 
 ```csharp
 public async UniTaskVoid FireAndForgetMethod()
@@ -431,6 +442,18 @@ actEvent += UniTask.Action(async () => { await UniTask.Yield(); });
 unityEvent += UniTask.UnityAction(async () => { await UniTask.Yield(); });
 ```
 
+`UniTaskVoid` can also use in MonoBehaviour's `Start` method.
+
+```csharp
+class Sample : MonoBehaviour
+{
+    async UniTaskVoid Start()
+    {
+        // async init code.
+    }
+}
+```
+
 UniTaskTracker
 ---
 useful for check(leak) UniTasks. You can open tracker window in `Window -> UniTask Tracker`.
@@ -447,9 +470,11 @@ For debug use, enable tracking and capture stacktrace is useful but it it declin
 
 External Assets
 ---
-In default, UniTask supports DOTween and Addressables(`AsyncOperationHandle` and `AsyncOpereationHandle<T>` as awaitable).
+In default, UniTask supports TextMeshPro(`BindTo(TMP_Text)` and `TMP_InputField` event extensions like standard uGUI `InputField`), DOTween(`Tween` as awaitable) and Addressables(`AsyncOperationHandle` and `AsyncOpereationHandle<T>` as awaitable).
 
-For DOTween support, require to `com.demigiant.dotween` import from [OpenUPM](https://openupm.com/packages/com.demigiant.dotween/) or define `UNITASK_DOTWEEN_SUPPORT` to enable it.
+There are defined in separated asmdef like `UniTask.TextMeshPro`, `UniTask.DOTween`, `UniTask.Addressables`.
+
+TextMeshPro and Addressables support are automatically enabled when import there package from package manager. However DOTween support, require to `com.demigiant.dotween` import from [OpenUPM](https://openupm.com/packages/com.demigiant.dotween/) or define `UNITASK_DOTWEEN_SUPPORT` to enable it.
 
 ```csharp
 // sequential
@@ -506,7 +531,7 @@ Async LINQ is enabled when `using Cysharp.Threading.Tasks.Linq;`, and `UniTaskAs
 
 It's closer to UniRx (Reactive Extensions), but UniTaskAsyncEnumerable is a pull-based asynchronous stream, whereas Rx was a push-based asynchronous stream. Note that although similar, the characteristics are different and the details behave differently along with them.
 
-`UniTaskAsyncEnumerable` is the entry point like `Enumerbale`. In addition to the standard query operators, there are other generators for Unity such as `EveryUpdate`, `Timer`, `TimerFrame`, `Interval`, `IntervalFrame`, and `EveryValueChanged`. And also added additional UniTask original query operators like `Append`, `Prepend`, `DistinctUntilChanged`, `ToHashSet`, `Buffer`, `CombineLatest`, `Do`, `Never`, `ForEachAsync`, `Pairwise`, `Publish`, `Queue`, `Return`, `SkipUntilCanceled`, `TakeUntilCanceled`, `TakeLast`, `Subscribe`.
+`UniTaskAsyncEnumerable` is the entry point like `Enumerbale`. In addition to the standard query operators, there are other generators for Unity such as `EveryUpdate`, `Timer`, `TimerFrame`, `Interval`, `IntervalFrame`, and `EveryValueChanged`. And also added additional UniTask original query operators like `Append`, `Prepend`, `DistinctUntilChanged`, `ToHashSet`, `Buffer`, `CombineLatest`, `Do`, `Never`, `ForEachAsync`, `Pairwise`, `Publish`, `Queue`, `Return`, `SkipUntil`, `TakeUntil`, `SkipUntilCanceled`, `TakeUntilCanceled`, `TakeLast`, `Subscribe`.
 
 The method with Func as an argument has three additional overloads, `***Await`, `***AwaitWithCancellation`.
 
@@ -518,6 +543,38 @@ SelectAwaitWithCancellation(Func<T, CancellationToken, UniTask<TR>> selector)
 
 If you want to use the `async` method inside the func, use the `***Await` or `***AwaitWithCancellation`.
 
+How to create async iterator, C# 8.0 supports async iterator(`async yield return`) but it only allows `IAsyncEnumerable<T>` and of course requires C# 8.0. UniTask supports `UniTaskAsyncEnumerable.Create` method to create custom async iterator.
+
+```csharp
+// IAsyncEnumerable, C# 8.0 version of async iterator. ( do not use this style, IAsyncEnumerable is not controled in UniTask).
+public async IAsyncEnumerable<int> MyEveryUpdate([EnumeratorCancellation]CancellationToken cancelationToken = default)
+{
+    var frameCount = 0;
+    await UniTask.Yield();
+    while (!token.IsCancellationRequested)
+    {
+        yield return frameCount++;
+        await UniTask.Yield();
+    }
+}
+
+// UniTaskAsyncEnumerable.Create and use `await writer.YieldAsync` instead of `yield return`.
+public IUniTaskAsyncEnumerable<int> MyEveryUpdate()
+{
+    // writer(IAsyncWriter<T>) has `YieldAsync(value)` method.
+    return UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
+    {
+        var frameCount = 0;
+        await UniTask.Yield();
+        while (!token.IsCancellationRequested)
+        {
+            await writer.YieldAsync(frameCount++); // instead of `yield return`
+            await UniTask.Yield();
+        }
+    });
+}
+```
+
 Awaitable Events
 ---
 All uGUI component implements `***AsAsyncEnumerable` to convert asynchronous streams of events.
@@ -778,7 +835,32 @@ foreach (var (type, size) in TaskPool.GetCacheSizeInfo())
 }
 ```
 
-> In UnityEditor profiler shows allocation of compiler generated AsyncStateMachine but it only occurs in debug(development) build. C# Compiler generate AsyncStateMachine as class on Debug build and as struct on Release build.
+Allocation on Profiler
+---
+In UnityEditor profiler shows allocation of compiler generated AsyncStateMachine but it only occurs in debug(development) build. C# Compiler generate AsyncStateMachine as class on Debug build and as struct on Release build.
+
+After Unity 2020.1 supports Code Optimization option on UnityEditor(right, footer).
+
+![](https://user-images.githubusercontent.com/46207/89967342-2f944600-dc8c-11ea-99fc-0b74527a16f6.png)
+
+You can change C# compiler optimization to release, it removes AsyncStateMachine allocation. Andalso optimization option can set via `Compilation.CompilationPipeline-codeOptimization`, and `Compilation.CodeOptimization`.
+
+UniTaskSynchronizationContext
+---
+Unity's default SynchronizationContext(`UnitySynchronizationContext`) is poor implementation for performance. UniTask itself is bypass `SynchronizationContext`(and `ExecutionContext`) so does not use it but if exists in `async Task`, still used it. `UniTaskSynchronizationContext` is replacement of `UnitySynchronizationContext`, it is better for performance.
+
+```csharp
+public class SyncContextInjecter
+{
+    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+    public static void Inject()
+    {
+        SynchronizationContext.SetSynchronizationContext(new UniTaskSynchronizationContext());
+    }
+}
+```
+
+This is an optional choice and is not always recommended; `UniTaskSynchronizationContext` is less performance than `async UniTask` and is not a complete UniTask replacement. It also does not guarantee full behavioral compatibility with the `UnitySynchronizationContext`.
 
 API References
 ---
@@ -798,7 +880,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.19`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.0.19`.
+If you want to set a target version, UniTask is using `*.*.*` release tag so you can specify a version like `#2.0.24`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.0.24`.
 
 ### Install via OpenUPM
 

src/UniTask.NetCore/UniTask.NetCore.csproj

@@ -36,7 +36,9 @@
 ..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\DiagnosticsExtensions.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\PlayerLoopRunner.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\ContinuationQueue.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\UnityWebRequestExtensions.cs;
   
+..\UniTask\Assets\Plugins\UniTask\Runtime\UniTaskSynchronizationContext.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\CancellationTokenSourceExtensions.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\EnumeratorAsyncExtensions.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\PlayerLoopHelper.cs;
@@ -44,9 +46,7 @@
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Run.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Bridge.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.WaitUntil.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.uGUI.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.MonoBehaviour.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.*;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UnityBindingExtensions.cs;
 " />
     </ItemGroup>

src/UniTask.NetCoreSandbox/Program.cs

@@ -1,4 +1,6 @@
-using Cysharp.Threading.Tasks;
+#pragma warning disable CS1998
+
+using Cysharp.Threading.Tasks;
 
 using System.Linq;
 using System;
@@ -56,6 +58,24 @@ namespace NetCoreSandbox
 
     }
 
+    class Foo
+    {
+        public async UniTask MethodFooAsync()
+        {
+            await MethodBarAsync();
+        }
+
+        private async UniTask MethodBarAsync()
+
+        {
+            Throw();
+        }
+
+        private void Throw()
+        {
+            throw new Exception();
+        }
+    }
 
     public struct TestAwaiter : ICriticalNotifyCompletion
     {
@@ -275,53 +295,25 @@ namespace NetCoreSandbox
             //await new ComparisonBenchmarks().ViaUniTaskT();
             return;
 #endif
-            // await new AllocationCheck().ViaUniTaskVoid();
 
-            // AsyncTest().Forge
-
-            Console.WriteLine("A?");
-            var a = await new ZeroAllocAsyncAwaitInDotNetCore().NanikaAsync(1, 2);
-            Console.WriteLine("RET:" + a);
-            await WhereSelect();
-
-            SynchronizationContext.SetSynchronizationContext(new MySyncContext());
-
-            await Aaa();
-
-
-
-
-            //AsyncTest().Forget();
-
-            // AsyncTest().Forget();
-
-            ThreadPool.SetMinThreads(100, 100);
-
-            //List<UniTask<int>> list = new List<UniTask<int>>();
-            for (int i = 0; i < short.MaxValue; i++)
+            var e = UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
             {
-                ////    list.Add(AsyncTest());
-                await YieldCore();
+                for (int i = 0; i < 5; i++)
+                {
+                    Console.WriteLine($"Start {i}");
+                    await writer.YieldAsync(i);
+                    Console.WriteLine($"End {i}");
+                }
+            });
+
+            var ee = e.GetAsyncEnumerator();
+            while (await ee.MoveNextAsync())
+            {
+                Console.WriteLine("ForEach " + ee.Current);
             }
-            //await UniTask.WhenAll(list);
-
-            //Console.WriteLine("TOGO");
-
-            //var a = await AsyncTest();
-            //var b = AsyncTest();
-            //var c = AsyncTest();
-            await YieldCore();
-
-            //await b;
-            //await c;
 
 
-            //foreach (var item in Cysharp.Threading.Tasks.Internal.TaskPool.GetCacheSizeInfo())
-            //{
-            //    Console.WriteLine(item);
-            //}
 
-            Console.ReadLine();
         }
 
         static async UniTask YieldCore()

src/UniTask.NetCoreTests/Linq/CreateTest.cs

@@ -0,0 +1,170 @@
+#pragma warning disable CS1998
+#pragma warning disable CS0162
+
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class CreateTest
+    {
+        [Fact]
+        public async Task SyncCreation()
+        {
+            var from = 10;
+            var count = 100;
+
+            var xs = await UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    await writer.YieldAsync(from + i);
+                }
+            }).ToArrayAsync();
+
+            var ys = await Range(from, count).AsUniTaskAsyncEnumerable().ToArrayAsync();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task SyncManually()
+        {
+            var list = new List<int>();
+            var xs = UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
+            {
+                list.Add(100);
+                await writer.YieldAsync(10);
+                
+                list.Add(200);
+                await writer.YieldAsync(20);
+
+                list.Add(300);
+                await writer.YieldAsync(30);
+            
+                list.Add(400);
+            });
+
+            list.Should().BeEmpty();
+            var e = xs.GetAsyncEnumerator();
+
+            list.Should().BeEmpty();
+
+            await e.MoveNextAsync();
+            list.Should().BeEquivalentTo(100);
+            e.Current.Should().Be(10);
+
+            await e.MoveNextAsync();
+            list.Should().BeEquivalentTo(100, 200);
+            e.Current.Should().Be(20);
+
+            await e.MoveNextAsync();
+            list.Should().BeEquivalentTo(100, 200, 300);
+            e.Current.Should().Be(30);
+
+            (await e.MoveNextAsync()).Should().BeFalse();
+            list.Should().BeEquivalentTo(100, 200, 300, 400);
+        }
+
+        [Fact]
+        public async Task SyncExceptionFirst()
+        {
+            var from = 10;
+            var count = 100;
+
+            var xs = UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    throw new UniTaskTestException();
+                    await writer.YieldAsync(from + i);
+                }
+            });
+
+            await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs.ToArrayAsync());
+        }
+
+        [Fact]
+        public async Task SyncException()
+        {
+            var from = 10;
+            var count = 100;
+
+            var xs = UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    await writer.YieldAsync(from + i);
+
+                    if (i == 15)
+                    {
+                        throw new UniTaskTestException();
+                    }
+                }
+            });
+
+            await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs.ToArrayAsync());
+        }
+
+        [Fact]
+        public async Task ASyncManually()
+        {
+            var list = new List<int>();
+            var xs = UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
+            {
+                await UniTask.Yield();
+
+                list.Add(100);
+                await writer.YieldAsync(10);
+
+                await UniTask.Yield();
+
+                list.Add(200);
+                await writer.YieldAsync(20);
+
+                await UniTask.Yield();
+                list.Add(300);
+                await UniTask.Yield();
+                await writer.YieldAsync(30);
+
+                await UniTask.Yield();
+
+                list.Add(400);
+            });
+
+            list.Should().BeEmpty();
+            var e = xs.GetAsyncEnumerator();
+
+            list.Should().BeEmpty();
+
+            await e.MoveNextAsync();
+            list.Should().BeEquivalentTo(100);
+            e.Current.Should().Be(10);
+
+            await e.MoveNextAsync();
+            list.Should().BeEquivalentTo(100, 200);
+            e.Current.Should().Be(20);
+
+            await e.MoveNextAsync();
+            list.Should().BeEquivalentTo(100, 200, 300);
+            e.Current.Should().Be(30);
+
+            (await e.MoveNextAsync()).Should().BeFalse();
+            list.Should().BeEquivalentTo(100, 200, 300, 400);
+        }
+
+        async IAsyncEnumerable<int> Range(int from, int count)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                yield return from + i;
+            }
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/TakeInfinityTest.cs

@@ -43,7 +43,7 @@ namespace NetCoreTests.Linq
         }
 
         [Fact]
-        public async Task TakeUntil()
+        public async Task TakeUntilCanceled()
         {
             var cts = new CancellationTokenSource();
 
@@ -72,7 +72,7 @@ namespace NetCoreTests.Linq
         }
 
         [Fact]
-        public async Task SkipUntil()
+        public async Task SkipUntilCanceled()
         {
             var cts = new CancellationTokenSource();
 
@@ -85,7 +85,7 @@ namespace NetCoreTests.Linq
             await c;
             var foo = await xs;
 
-            foo.Should().BeEquivalentTo(new[] { 30, 40 });
+            foo.Should().BeEquivalentTo(new[] { 20, 30, 40 });
 
             async Task CancelAsync()
             {
@@ -102,5 +102,64 @@ namespace NetCoreTests.Linq
             }
         }
 
+        [Fact]
+        public async Task TakeUntil()
+        {
+            var cts = new AsyncReactiveProperty<int>(0);
+
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.TakeUntil(cts.WaitAsync()).ToArrayAsync();
+
+            var c = CancelAsync();
+
+            await c;
+            var foo = await xs;
+
+            foo.Should().BeEquivalentTo(new[] { 1, 10, 20 });
+
+            async Task CancelAsync()
+            {
+                rp.Value = 10;
+                await Task.Yield();
+                rp.Value = 20;
+                await Task.Yield();
+                cts.Value = 9999;
+                rp.Value = 30;
+                await Task.Yield();
+                rp.Value = 40;
+            }
+        }
+
+        [Fact]
+        public async Task SkipUntil()
+        {
+            var cts = new AsyncReactiveProperty<int>(0);
+
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.SkipUntil(cts.WaitAsync()).ToArrayAsync();
+
+            var c = CancelAsync();
+
+            await c;
+            var foo = await xs;
+
+            foo.Should().BeEquivalentTo(new[] { 20, 30, 40 });
+
+            async Task CancelAsync()
+            {
+                rp.Value = 10;
+                await Task.Yield();
+                rp.Value = 20;
+                await Task.Yield();
+                cts.Value = 9999;
+                rp.Value = 30;
+                await Task.Yield();
+                rp.Value = 40;
+
+                rp.Dispose(); // complete.
+            }
+        }
     }
 }

src/UniTask.NetCoreTests/WithCancellationTest.cs

@@ -0,0 +1,40 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests
+{
+    public class WithCancellationTest
+    {
+        [Fact]
+        public async Task Standard()
+        {
+            CancellationTokenSource cts = new CancellationTokenSource();
+
+            var v = await UniTask.Run(() => 10).WithCancellation(cts.Token);
+
+            v.Should().Be(10);
+        }
+
+        [Fact]
+        public async Task Cancel()
+        {
+            CancellationTokenSource cts = new CancellationTokenSource();
+
+            var t = UniTask.Create(async () =>
+            {
+                await Task.Delay(TimeSpan.FromSeconds(1));
+                return 10;
+            }).WithCancellation(cts.Token);
+
+            cts.Cancel();
+
+            (await Assert.ThrowsAsync<OperationCanceledException>(async () => await t)).CancellationToken.Should().Be(cts.Token);
+        }
+    }
+}

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

@@ -11,6 +11,55 @@ namespace Cysharp.Threading.Tasks
         static readonly Action<object> cancellationTokenCallback = Callback;
         static readonly Action<object> disposeCallback = DisposeCallback;
 
+        public static CancellationToken ToCancellationToken(this UniTask task)
+        {
+            var cts = new CancellationTokenSource();
+            ToCancellationTokenCore(task, cts).Forget();
+            return cts.Token;
+        }
+
+        public static CancellationToken ToCancellationToken(this UniTask task, CancellationToken linkToken)
+        {
+            if (linkToken.IsCancellationRequested)
+            {
+                return linkToken;
+            }
+
+            if (!linkToken.CanBeCanceled)
+            {
+                return ToCancellationToken(task);
+            }
+
+            var cts = new CancellationTokenSource();
+            ToCancellationTokenCore(task, cts).Forget();
+
+            return CancellationTokenSource.CreateLinkedTokenSource(linkToken).Token;
+        }
+
+        public static CancellationToken ToCancellationToken<T>(this UniTask<T> task)
+        {
+            return ToCancellationToken(task.AsUniTask());
+        }
+
+        public static CancellationToken ToCancellationToken<T>(this UniTask<T> task, CancellationToken linkToken)
+        {
+            return ToCancellationToken(task.AsUniTask(), linkToken);
+        }
+
+        static async UniTaskVoid ToCancellationTokenCore(UniTask task, CancellationTokenSource cts)
+        {
+            try
+            {
+                await task;
+            }
+            catch (Exception ex)
+            {
+                UniTaskScheduler.PublishUnobservedTaskException(ex);
+            }
+            cts.Cancel();
+            cts.Dispose();
+        }
+
         public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cancellationToken)
         {
             if (cancellationToken.IsCancellationRequested)

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

@@ -9,15 +9,15 @@ namespace Cysharp.Threading.Tasks
 {
     public static class CancellationTokenSourceExtensions
     {
-        public static void CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
+        public static void CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
         {
-            var delay = UniTask.Delay(millisecondsDelay, ignoreTimeScale, delayTiming, cts.Token);
+            var delay = UniTask.Delay(millisecondsDelay, delayType, delayTiming, cts.Token);
             CancelAfterCore(cts, delay).Forget();
         }
 
-        public static void CancelAfterSlim(this CancellationTokenSource cts, TimeSpan delayTimeSpan, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
+        public static void CancelAfterSlim(this CancellationTokenSource cts, TimeSpan delayTimeSpan, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
         {
-            var delay = UniTask.Delay(delayTimeSpan, ignoreTimeScale, delayTiming, cts.Token);
+            var delay = UniTask.Delay(delayTimeSpan, delayType, delayTiming, cts.Token);
             CancelAfterCore(cts, delay).Forget();
         }
 

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

@@ -1,4 +1,4 @@
-#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#pragma warning disable CS1591
 
 using Cysharp.Threading.Tasks.Internal;
 using System;
@@ -8,6 +8,10 @@ using System.Runtime.CompilerServices;
 
 namespace Cysharp.Threading.Tasks.CompilerServices
 {
+    // #ENABLE_IL2CPP in this file is to avoid bug of IL2CPP VM.
+    // Issue is tracked on https://issuetracker.unity3d.com/issues/il2cpp-incorrect-results-when-calling-a-method-from-outside-class-in-a-struct
+    // but currently it is labeled `Won't Fix`.
+
     internal interface IStateMachineRunner
     {
         Action MoveNext { get; }

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

@@ -44,6 +44,7 @@ namespace Cysharp.Threading.Tasks
 
             IEnumerator innerEnumerator;
             CancellationToken cancellationToken;
+            int initialFrame;
 
             UniTaskCompletionSourceCore<object> core;
 
@@ -66,10 +67,13 @@ namespace Cysharp.Threading.Tasks
 
                 result.innerEnumerator = ConsumeEnumerator(innerEnumerator);
                 result.cancellationToken = cancellationToken;
+                result.initialFrame = -1;
 
                 PlayerLoopHelper.AddAction(timing, result);
 
                 token = result.core.Version;
+
+                result.MoveNext(); // run immediately.
                 return result;
             }
 
@@ -108,6 +112,19 @@ namespace Cysharp.Threading.Tasks
                     return false;
                 }
 
+                if (initialFrame == -1)
+                {
+                    // Time can not touch in threadpool.
+                    if (PlayerLoopHelper.IsMainThread)
+                    {
+                        initialFrame = Time.frameCount;
+                    }
+                }
+                else if (initialFrame == Time.frameCount)
+                {
+                    return true; // already executed in first frame, skip.
+                }
+
                 try
                 {
                     if (innerEnumerator.MoveNext())

src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a5b9231662e24c942b544bd85d4b39cb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -11,24 +11,38 @@ using UnityEngine.ResourceManagement.AsyncOperations;
 
 namespace Cysharp.Threading.Tasks
 {
-    public static class AddressableAsyncExtensions
+    public static class AddressablesAsyncExtensions
     {
         #region AsyncOperationHandle
 
-        public static AsyncOperationHandleAwaiter GetAwaiter(this AsyncOperationHandle handle)
+        public static UniTask.Awaiter GetAwaiter(this AsyncOperationHandle handle)
         {
-            return new AsyncOperationHandleAwaiter(handle);
+            return ToUniTask(handle).GetAwaiter();
         }
 
         public static UniTask WithCancellation(this AsyncOperationHandle handle, CancellationToken cancellationToken)
         {
-            if (handle.IsDone) return UniTask.CompletedTask;
-            return new UniTask(AsyncOperationHandleWithCancellationSource.Create(handle, cancellationToken, out var token), token);
+            return ToUniTask(handle, cancellationToken: cancellationToken);
         }
 
         public static UniTask ToUniTask(this AsyncOperationHandle handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
-            if (handle.IsDone) return UniTask.CompletedTask;
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken);
+
+            if (!handle.IsValid())
+            {
+                throw new Exception("Attempting to use an invalid operation handle");
+            }
+
+            if (handle.IsDone)
+            {
+                if (handle.Status == AsyncOperationStatus.Failed)
+                {
+                    return UniTask.FromException(handle.OperationException);
+                }
+                return UniTask.CompletedTask;
+            }
+
             return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellationToken, out var token), token);
         }
 
@@ -77,29 +91,30 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        sealed class AsyncOperationHandleWithCancellationSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleWithCancellationSource>
+        sealed class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleConfiguredSource>
         {
-            static TaskPool<AsyncOperationHandleWithCancellationSource> pool;
-            public AsyncOperationHandleWithCancellationSource NextNode { get; set; }
+            static TaskPool<AsyncOperationHandleConfiguredSource> pool;
+            public AsyncOperationHandleConfiguredSource NextNode { get; set; }
 
-            static AsyncOperationHandleWithCancellationSource()
+            static AsyncOperationHandleConfiguredSource()
             {
-                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleWithCancellationSource), () => pool.Size);
+                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource), () => pool.Size);
             }
 
             readonly Action<AsyncOperationHandle> continuationAction;
             AsyncOperationHandle handle;
             CancellationToken cancellationToken;
+            IProgress<float> progress;
             bool completed;
 
             UniTaskCompletionSourceCore<AsyncUnit> core;
 
-            AsyncOperationHandleWithCancellationSource()
+            AsyncOperationHandleConfiguredSource()
             {
                 continuationAction = Continuation;
             }
 
-            public static IUniTaskSource Create(AsyncOperationHandle handle, CancellationToken cancellationToken, out short token)
+            public static IUniTaskSource Create(AsyncOperationHandle handle, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
             {
                 if (cancellationToken.IsCancellationRequested)
                 {
@@ -108,16 +123,17 @@ namespace Cysharp.Threading.Tasks
 
                 if (!pool.TryPop(out var result))
                 {
-                    result = new AsyncOperationHandleWithCancellationSource();
+                    result = new AsyncOperationHandleConfiguredSource();
                 }
 
                 result.handle = handle;
+                result.progress = progress;
                 result.cancellationToken = cancellationToken;
                 result.completed = false;
 
                 TaskTracker.TrackActiveTask(result, 3);
 
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
+                PlayerLoopHelper.AddAction(timing, result);
 
                 handle.Completed += result.continuationAction;
 
@@ -136,7 +152,11 @@ namespace Cysharp.Threading.Tasks
                 else
                 {
                     completed = true;
-                    if (handle.Status == AsyncOperationStatus.Failed)
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                    }
+                    else if (handle.Status == AsyncOperationStatus.Failed)
                     {
                         core.TrySetException(handle.OperationException);
                     }
@@ -182,125 +202,18 @@ namespace Cysharp.Threading.Tasks
                     return false;
                 }
 
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                handle = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
-        sealed class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleConfiguredSource>
-        {
-            static TaskPool<AsyncOperationHandleConfiguredSource> pool;
-            public AsyncOperationHandleConfiguredSource NextNode { get; set; }
-
-            static AsyncOperationHandleConfiguredSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource), () => pool.Size);
-            }
-
-            AsyncOperationHandle handle;
-            IProgress<float> progress;
-            CancellationToken cancellationToken;
-
-            UniTaskCompletionSourceCore<AsyncUnit> core;
-
-            AsyncOperationHandleConfiguredSource()
-            {
-
-            }
-
-            public static IUniTaskSource Create(AsyncOperationHandle handle, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AsyncOperationHandleConfiguredSource();
-                }
-
-                result.handle = handle;
-                result.progress = progress;
-                result.cancellationToken = cancellationToken;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(timing, result);
-
-                token = result.core.Version;
-                return result;
-            }
-
-            public void GetResult(short token)
-            {
-                try
-                {
-
-                    core.GetResult(token);
-                }
-                finally
-                {
-                    TryReturn();
-                }
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                if (progress != null)
+                if (progress != null && handle.IsValid())
                 {
                     progress.Report(handle.PercentComplete);
                 }
 
-                if (handle.IsDone)
-                {
-                    if (handle.Status == AsyncOperationStatus.Failed)
-                    {
-                        core.TrySetException(handle.OperationException);
-                    }
-                    else
-                    {
-                        core.TrySetResult(AsyncUnit.Default);
-                    }
-                    return false;
-                }
-
                 return true;
             }
 
             bool TryReturn()
             {
-                core.Reset();
                 TaskTracker.RemoveTracking(this);
+                core.Reset();
                 handle = default;
                 progress = default;
                 cancellationToken = default;
@@ -312,92 +225,61 @@ namespace Cysharp.Threading.Tasks
 
         #region AsyncOperationHandle_T
 
-        public static AsyncOperationHandleAwaiter<T> GetAwaiter<T>(this AsyncOperationHandle<T> handle)
+        public static UniTask<T>.Awaiter GetAwaiter<T>(this AsyncOperationHandle<T> handle)
         {
-            return new AsyncOperationHandleAwaiter<T>(handle);
+            return ToUniTask(handle).GetAwaiter();
         }
 
         public static UniTask<T> WithCancellation<T>(this AsyncOperationHandle<T> handle, CancellationToken cancellationToken)
         {
-            if (handle.IsDone) return UniTask.FromResult(handle.Result);
-            return new UniTask<T>(AsyncOperationHandleWithCancellationSource<T>.Create(handle, cancellationToken, out var token), token);
+            return ToUniTask(handle, cancellationToken: cancellationToken);
         }
 
         public static UniTask<T> ToUniTask<T>(this AsyncOperationHandle<T> handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
-            if (handle.IsDone) return UniTask.FromResult(handle.Result);
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<T>(cancellationToken);
+
+            if (!handle.IsValid())
+            {
+                throw new Exception("Attempting to use an invalid operation handle");
+            }
+
+            if (handle.IsDone)
+            {
+                if (handle.Status == AsyncOperationStatus.Failed)
+                {
+                    return UniTask.FromException<T>(handle.OperationException);
+                }
+                return UniTask.FromResult(handle.Result);
+            }
+
             return new UniTask<T>(AsyncOperationHandleConfiguredSource<T>.Create(handle, timing, progress, cancellationToken, out var token), token);
         }
 
-        public struct AsyncOperationHandleAwaiter<T> : ICriticalNotifyCompletion
+        sealed class AsyncOperationHandleConfiguredSource<T> : IUniTaskSource<T>, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleConfiguredSource<T>>
         {
-            AsyncOperationHandle<T> handle;
-            Action<AsyncOperationHandle> continuationAction;
+            static TaskPool<AsyncOperationHandleConfiguredSource<T>> pool;
+            public AsyncOperationHandleConfiguredSource<T> NextNode { get; set; }
 
-            public AsyncOperationHandleAwaiter(AsyncOperationHandle<T> handle)
+            static AsyncOperationHandleConfiguredSource()
             {
-                this.handle = handle;
-                this.continuationAction = null;
-            }
-
-            public bool IsCompleted => handle.IsDone;
-
-            public T GetResult()
-            {
-                if (continuationAction != null)
-                {
-                    handle.CompletedTypeless -= continuationAction;
-                    continuationAction = null;
-                }
-
-                if (handle.Status == AsyncOperationStatus.Failed)
-                {
-                    var e = handle.OperationException;
-                    handle = default;
-                    ExceptionDispatchInfo.Capture(e).Throw();
-                }
-
-                var result = handle.Result;
-                handle = default;
-                return result;
-            }
-
-            public void OnCompleted(Action continuation)
-            {
-                UnsafeOnCompleted(continuation);
-            }
-
-            public void UnsafeOnCompleted(Action continuation)
-            {
-                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
-                continuationAction = PooledDelegate<AsyncOperationHandle>.Create(continuation);
-                handle.CompletedTypeless += continuationAction;
-            }
-        }
-
-        sealed class AsyncOperationHandleWithCancellationSource<T> : IUniTaskSource<T>, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleWithCancellationSource<T>>
-        {
-            static TaskPool<AsyncOperationHandleWithCancellationSource<T>> pool;
-            public AsyncOperationHandleWithCancellationSource<T> NextNode { get; set; }
-
-            static AsyncOperationHandleWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleWithCancellationSource<T>), () => pool.Size);
+                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource<T>), () => pool.Size);
             }
 
             readonly Action<AsyncOperationHandle<T>> continuationAction;
             AsyncOperationHandle<T> handle;
             CancellationToken cancellationToken;
+            IProgress<float> progress;
             bool completed;
 
             UniTaskCompletionSourceCore<T> core;
 
-            AsyncOperationHandleWithCancellationSource()
+            AsyncOperationHandleConfiguredSource()
             {
                 continuationAction = Continuation;
             }
 
-            public static IUniTaskSource<T> Create(AsyncOperationHandle<T> handle, CancellationToken cancellationToken, out short token)
+            public static IUniTaskSource<T> Create(AsyncOperationHandle<T> handle, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
             {
                 if (cancellationToken.IsCancellationRequested)
                 {
@@ -406,16 +288,17 @@ namespace Cysharp.Threading.Tasks
 
                 if (!pool.TryPop(out var result))
                 {
-                    result = new AsyncOperationHandleWithCancellationSource<T>();
+                    result = new AsyncOperationHandleConfiguredSource<T>();
                 }
 
                 result.handle = handle;
                 result.cancellationToken = cancellationToken;
                 result.completed = false;
+                result.progress = progress;
 
                 TaskTracker.TrackActiveTask(result, 3);
 
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
+                PlayerLoopHelper.AddAction(timing, result);
 
                 handle.Completed += result.continuationAction;
 
@@ -423,7 +306,7 @@ namespace Cysharp.Threading.Tasks
                 return result;
             }
 
-            void Continuation(AsyncOperationHandle<T> _)
+            void Continuation(AsyncOperationHandle<T> argHandle)
             {
                 handle.Completed -= continuationAction;
 
@@ -434,13 +317,17 @@ namespace Cysharp.Threading.Tasks
                 else
                 {
                     completed = true;
-                    if (handle.Status == AsyncOperationStatus.Failed)
+                    if (cancellationToken.IsCancellationRequested)
                     {
-                        core.TrySetException(handle.OperationException);
+                        core.TrySetCanceled(cancellationToken);
+                    }
+                    else if (argHandle.Status == AsyncOperationStatus.Failed)
+                    {
+                        core.TrySetException(argHandle.OperationException);
                     }
                     else
                     {
-                        core.TrySetResult(handle.Result);
+                        core.TrySetResult(argHandle.Result);
                     }
                 }
             }
@@ -485,122 +372,11 @@ namespace Cysharp.Threading.Tasks
                     return false;
                 }
 
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                handle = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
-        sealed class AsyncOperationHandleConfiguredSource<T> : IUniTaskSource<T>, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleConfiguredSource<T>>
-        {
-            static TaskPool<AsyncOperationHandleConfiguredSource<T>> pool;
-            public AsyncOperationHandleConfiguredSource<T> NextNode { get; set; }
-
-            static AsyncOperationHandleConfiguredSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource<T>), () => pool.Size);
-            }
-
-            AsyncOperationHandle<T> handle;
-            IProgress<float> progress;
-            CancellationToken cancellationToken;
-
-            UniTaskCompletionSourceCore<T> core;
-
-            AsyncOperationHandleConfiguredSource()
-            {
-
-            }
-
-            public static IUniTaskSource<T> Create(AsyncOperationHandle<T> handle, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<T>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AsyncOperationHandleConfiguredSource<T>();
-                }
-
-                result.handle = handle;
-                result.progress = progress;
-                result.cancellationToken = cancellationToken;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(timing, result);
-
-                token = result.core.Version;
-                return result;
-            }
-
-            public T GetResult(short token)
-            {
-                try
-                {
-                    return core.GetResult(token);
-                }
-                finally
-                {
-                    TryReturn();
-                }
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                if (progress != null)
+                if (progress != null && handle.IsValid())
                 {
                     progress.Report(handle.PercentComplete);
                 }
 
-                if (handle.IsDone)
-                {
-                    if (handle.Status == AsyncOperationStatus.Failed)
-                    {
-                        core.TrySetException(handle.OperationException);
-                    }
-                    else
-                    {
-                        core.TrySetResult(handle.Result);
-                    }
-                    return false;
-                }
-
                 return true;
             }
 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables/UniTask.Addressables.asmdef

@@ -0,0 +1,22 @@
+{
+    "name": "UniTask.Addressables",
+    "references": [
+        "UniTask",
+        "Unity.ResourceManager"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.addressables",
+            "expression": "",
+            "define": "UNITASK_ADDRESSABLE_SUPPORT"
+        }
+    ],
+    "noEngineReferences": false
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables/UniTask.Addressables.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 593a5b492d29ac6448b1ebf7f035ef33
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 25cb2f742bfeb1d48a4e65d3140b955d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween/UniTask.DOTween.asmdef

@@ -0,0 +1,22 @@
+{
+    "name": "UniTask.DOTween",
+    "references": [
+        "UniTask",
+        "DOTween.Modules"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.demigiant.dotween",
+            "expression": "",
+            "define": "UNITASK_DOTWEEN_SUPPORT"
+        }
+    ],
+    "noEngineReferences": false
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween/UniTask.DOTween.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 029c1c1b674aaae47a6841a0b89ad80e
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f89da606bde9a4e4e94ae1189a029887
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.InputField.cs

@@ -0,0 +1,224 @@
+#if UNITASK_TEXTMESHPRO_SUPPORT
+
+using System;
+using System.Threading;
+using TMPro;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static partial class TextMeshProAsyncExtensions
+    {
+        public static IAsyncValueChangedEventHandler<string> GetAsyncValueChangedEventHandler(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncValueChangedEventHandler<string> GetAsyncValueChangedEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onValueChanged, cancellationToken, false);
+        }
+
+        public static UniTask<string> OnValueChangedAsync(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<string> OnValueChangedAsync(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onValueChanged, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnValueChangedAsAsyncEnumerable(this TMP_InputField inputField)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy());
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnValueChangedAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onValueChanged, cancellationToken);
+        }
+
+        public static IAsyncEndEditEventHandler<string> GetAsyncEndEditEventHandler(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncEndEditEventHandler<string> GetAsyncEndEditEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onEndEdit, cancellationToken, false);
+        }
+
+        public static UniTask<string> OnEndEditAsync(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<string> OnEndEditAsync(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onEndEdit, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnEndEditAsAsyncEnumerable(this TMP_InputField inputField)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy());
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnEndEditAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onEndEdit, cancellationToken);
+        }
+
+        public static IAsyncEndTextSelectionEventHandler<(string, int, int)> GetAsyncEndTextSelectionEventHandler(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncEndTextSelectionEventHandler<(string, int, int)> GetAsyncEndTextSelectionEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), cancellationToken, false);
+        }
+
+        public static UniTask<(string, int, int)> OnEndTextSelectionAsync(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<(string, int, int)> OnEndTextSelectionAsync(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IUniTaskAsyncEnumerable<(string, int, int)> OnEndTextSelectionAsAsyncEnumerable(this TMP_InputField inputField)
+        {
+            return new UnityEventHandlerAsyncEnumerable<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), inputField.GetCancellationTokenOnDestroy());
+        }
+
+        public static IUniTaskAsyncEnumerable<(string, int, int)> OnEndTextSelectionAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new UnityEventHandlerAsyncEnumerable<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), cancellationToken);
+        }
+
+        public static IAsyncTextSelectionEventHandler<(string, int, int)> GetAsyncTextSelectionEventHandler(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncTextSelectionEventHandler<(string, int, int)> GetAsyncTextSelectionEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), cancellationToken, false);
+        }
+
+        public static UniTask<(string, int, int)> OnTextSelectionAsync(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<(string, int, int)> OnTextSelectionAsync(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IUniTaskAsyncEnumerable<(string, int, int)> OnTextSelectionAsAsyncEnumerable(this TMP_InputField inputField)
+        {
+            return new UnityEventHandlerAsyncEnumerable<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), inputField.GetCancellationTokenOnDestroy());
+        }
+
+        public static IUniTaskAsyncEnumerable<(string, int, int)> OnTextSelectionAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new UnityEventHandlerAsyncEnumerable<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), cancellationToken);
+        }
+
+        public static IAsyncDeselectEventHandler<string> GetAsyncDeselectEventHandler(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onDeselect, inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncDeselectEventHandler<string> GetAsyncDeselectEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onDeselect, cancellationToken, false);
+        }
+
+        public static UniTask<string> OnDeselectAsync(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onDeselect, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<string> OnDeselectAsync(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onDeselect, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnDeselectAsAsyncEnumerable(this TMP_InputField inputField)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onDeselect, inputField.GetCancellationTokenOnDestroy());
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnDeselectAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onDeselect, cancellationToken);
+        }
+
+        public static IAsyncSelectEventHandler<string> GetAsyncSelectEventHandler(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onSelect, inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncSelectEventHandler<string> GetAsyncSelectEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onSelect, cancellationToken, false);
+        }
+
+        public static UniTask<string> OnSelectAsync(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onSelect, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<string> OnSelectAsync(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onSelect, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnSelectAsAsyncEnumerable(this TMP_InputField inputField)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onSelect, inputField.GetCancellationTokenOnDestroy());
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnSelectAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onSelect, cancellationToken);
+        }
+
+        public static IAsyncSubmitEventHandler<string> GetAsyncSubmitEventHandler(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onSubmit, inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsyncSubmitEventHandler<string> GetAsyncSubmitEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onSubmit, cancellationToken, false);
+        }
+
+        public static UniTask<string> OnSubmitAsync(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onSubmit, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<string> OnSubmitAsync(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<string>(inputField.onSubmit, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnSubmitAsAsyncEnumerable(this TMP_InputField inputField)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onSubmit, inputField.GetCancellationTokenOnDestroy());
+        }
+
+        public static IUniTaskAsyncEnumerable<string> OnSubmitAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new UnityEventHandlerAsyncEnumerable<string>(inputField.onSubmit, cancellationToken);
+        }
+
+    }
+}
+
+#endif

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.InputField.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 79f4f2475e0b2c44e97ed1dee760627b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.InputField.tt

@@ -0,0 +1,66 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#
+    var handlers = new (string name, string type)[] {
+        ("ValueChanged", "string"),
+        ("EndEdit", "string"),
+        ("EndTextSelection", "(string, int, int)"),
+        ("TextSelection", "(string, int, int)"),
+        ("Deselect", "string"),
+        ("Select", "string"),
+        ("Submit", "string"),
+    };
+
+    Func<string, bool> shouldConvert = x => x.EndsWith("TextSelection");
+    Func<string, string> eventName = x => shouldConvert(x) ? $"new TextSelectionEventConverter(inputField.on{x})" : $"inputField.on{x}";
+#>
+#if UNITASK_TEXTMESHPRO_SUPPORT
+
+using System;
+using System.Threading;
+using TMPro;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static partial class TextMeshProAsyncExtensions
+    {
+<# foreach(var (name, type) in handlers) { #>
+        public static IAsync<#= (name) #>EventHandler<<#= type #>> GetAsync<#= (name) #>EventHandler(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<<#= type #>>(<#= eventName(name) #>, inputField.GetCancellationTokenOnDestroy(), false);
+        }
+
+        public static IAsync<#= (name) #>EventHandler<<#= type #>> GetAsync<#= (name) #>EventHandler(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<<#= type #>>(<#= eventName(name) #>, cancellationToken, false);
+        }
+
+        public static UniTask<<#= type #>> On<#= (name) #>Async(this TMP_InputField inputField)
+        {
+            return new AsyncUnityEventHandler<<#= type #>>(<#= eventName(name) #>, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync();
+        }
+
+        public static UniTask<<#= type #>> On<#= (name) #>Async(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new AsyncUnityEventHandler<<#= type #>>(<#= eventName(name) #>, cancellationToken, true).OnInvokeAsync();
+        }
+
+        public static IUniTaskAsyncEnumerable<<#= type #>> On<#= (name) #>AsAsyncEnumerable(this TMP_InputField inputField)
+        {
+            return new UnityEventHandlerAsyncEnumerable<<#= type #>>(<#= eventName(name) #>, inputField.GetCancellationTokenOnDestroy());
+        }
+
+        public static IUniTaskAsyncEnumerable<<#= type #>> On<#= (name) #>AsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken)
+        {
+            return new UnityEventHandlerAsyncEnumerable<<#= type #>>(<#= eventName(name) #>, cancellationToken);
+        }
+
+<# } #>
+    }
+}
+
+#endif

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.InputField.tt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e9bb9fc551a975d44a7180e022a2debe
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.cs

@@ -0,0 +1,68 @@
+#if UNITASK_TEXTMESHPRO_SUPPORT
+
+using System;
+using System.Threading;
+using TMPro;
+using UnityEngine.Events;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static partial class TextMeshProAsyncExtensions
+    {
+        public static void BindTo(this IUniTaskAsyncEnumerable<string> source, TMP_Text text, bool rebindOnError = true)
+        {
+            BindToCore(source, text, text.GetCancellationTokenOnDestroy(), rebindOnError).Forget();
+        }
+
+        public static void BindTo(this IUniTaskAsyncEnumerable<string> source, TMP_Text text, CancellationToken cancellationToken, bool rebindOnError = true)
+        {
+            BindToCore(source, text, cancellationToken, rebindOnError).Forget();
+        }
+
+        static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable<string> source, TMP_Text text, CancellationToken cancellationToken, bool rebindOnError)
+        {
+            var repeat = false;
+            BIND_AGAIN:
+            var e = source.GetAsyncEnumerator(cancellationToken);
+            try
+            {
+                while (true)
+                {
+                    bool moveNext;
+                    try
+                    {
+                        moveNext = await e.MoveNextAsync();
+                        repeat = false;
+                    }
+                    catch (Exception ex)
+                    {
+                        if (ex is OperationCanceledException) return;
+
+                        if (rebindOnError && !repeat)
+                        {
+                            repeat = true;
+                            goto BIND_AGAIN;
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+
+                    if (!moveNext) return;
+
+                    text.text = e.Current;
+                }
+            }
+            finally
+            {
+                if (e != null)
+                {
+                    await e.DisposeAsync();
+                }
+            }
+        }
+    }
+}
+
+#endif

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b6ba480edafb67d4e91bb10feb64fae5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/UniTask.TextMeshPro.asmdef

@@ -0,0 +1,22 @@
+{
+    "name": "UniTask.TextMeshPro",
+    "references": [
+        "UniTask",
+        "Unity.TextMeshPro"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.textmeshpro",
+            "expression": "",
+            "define": "UNITASK_TEXTMESHPRO_SUPPORT"
+        }
+    ],
+    "noEngineReferences": false
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/UniTask.TextMeshPro.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: dc47925d1a5fa2946bdd37746b2b5d48
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -9,7 +9,7 @@ namespace Cysharp.Threading.Tasks.Internal
     {
         const int MaxArrayLength = 0X7FEFFFFF;
         const int InitialSize = 16;
-        
+
         readonly PlayerLoopTiming timing;
 
         SpinLock gate = new SpinLock();
@@ -173,7 +173,14 @@ namespace Cysharp.Threading.Tasks.Internal
                 var action = actionList[i];
                 actionList[i] = null;
 
-                action();
+                try
+                {
+                    action();
+                }
+                catch (Exception ex)
+                {
+                    UnityEngine.Debug.LogException(ex);
+                }
             }
 
             {

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

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine.Networking;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class UnityWebRequestResultExtensions
+    {
+        public static bool IsError(this UnityWebRequest unityWebRequest)
+        {
+#if UNITY_2020_2_OR_NEWER
+            var result = unityWebRequest.result;
+            return (result == UnityWebRequest.Result.ConnectionError)
+                || (result == UnityWebRequest.Result.DataProcessingError)
+                || (result == UnityWebRequest.Result.ProtocolError);
+#else
+            return unityWebRequest.isHttpError || unityWebRequest.isNetworkError;
+#endif
+        }
+    }
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/UnityWebRequestExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 111ba0e639de1d7428af6c823ead4918
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,35 @@
+using System;
+using System.Diagnostics;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal readonly struct ValueStopwatch
+    {
+        static readonly double TimestampToTicks = TimeSpan.TicksPerSecond / (double)Stopwatch.Frequency;
+
+        readonly long startTimestamp;
+
+        public static ValueStopwatch StartNew() => new ValueStopwatch(Stopwatch.GetTimestamp());
+
+        ValueStopwatch(long startTimestamp)
+        {
+            this.startTimestamp = startTimestamp;
+        }
+
+        public TimeSpan Elapsed => TimeSpan.FromTicks(this.ElapsedTicks);
+
+        public long ElapsedTicks
+        {
+            get
+            {
+                if (startTimestamp == 0)
+                {
+                    throw new InvalidOperationException("Detected invalid initialization(use 'default'), only to create from StartNew().");
+                }
+
+                var delta = Stopwatch.GetTimestamp() - startTimestamp;
+                return (long)(delta * TimestampToTicks);
+            }
+        }
+    }
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ValueStopwatch.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f16fb466974ad034c8732c79c7fd67ea
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Create.cs

@@ -0,0 +1,174 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<T> Create<T>(Func<IAsyncWriter<T>, CancellationToken, UniTask> create)
+        {
+            Error.ThrowArgumentNullException(create, nameof(create));
+            return new Create<T>(create);
+        }
+    }
+
+    public interface IAsyncWriter<T>
+    {
+        UniTask YieldAsync(T value);
+    }
+
+    internal sealed class Create<T> : IUniTaskAsyncEnumerable<T>
+    {
+        readonly Func<IAsyncWriter<T>, CancellationToken, UniTask> create;
+
+        public Create(Func<IAsyncWriter<T>, CancellationToken, UniTask> create)
+        {
+            this.create = create;
+        }
+
+        public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _Create(create, cancellationToken);
+        }
+
+        sealed class _Create : MoveNextSource, IUniTaskAsyncEnumerator<T>
+        {
+            readonly Func<IAsyncWriter<T>, CancellationToken, UniTask> create;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            AsyncWriter writer;
+
+            public _Create(Func<IAsyncWriter<T>, CancellationToken, UniTask> create, CancellationToken cancellationToken)
+            {
+                this.create = create;
+                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
+            }
+
+            public T Current { get; private set; }
+
+            public UniTask DisposeAsync()
+            {
+                TaskTracker.RemoveTracking(this);
+                return default;
+            }
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void MoveNext()
+            {
+                try
+                {
+                    switch (state)
+                    {
+                        case -1: // init
+                            {
+                                writer = new AsyncWriter(this);
+                                RunWriterTask(create(writer, cancellationToken)).Forget();
+                                if (Volatile.Read(ref state) == -2)
+                                {
+                                    return; // complete synchronously
+                                }
+                                state = 0; // wait YieldAsync, it set TrySetResult(true)
+                                return;
+                            }
+                        case 0:
+                            writer.SignalWriter();
+                            return;
+                        default:
+                            goto DONE;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+            }
+
+            async UniTaskVoid RunWriterTask(UniTask task)
+            {
+                try
+                {
+                    await task;
+                    goto DONE;
+                }
+                catch (Exception ex)
+                {
+                    Volatile.Write(ref state, -2);
+                    completionSource.TrySetException(ex);
+                    return;
+                }
+
+                DONE:
+                Volatile.Write(ref state, -2);
+                completionSource.TrySetResult(false);
+            }
+
+            public void SetResult(T value)
+            {
+                Current = value;
+                completionSource.TrySetResult(true);
+            }
+        }
+
+        sealed class AsyncWriter : IUniTaskSource, IAsyncWriter<T>
+        {
+            readonly _Create enumerator;
+
+            UniTaskCompletionSourceCore<AsyncUnit> core;
+
+            public AsyncWriter(_Create enumerator)
+            {
+                this.enumerator = enumerator;
+            }
+
+            public void GetResult(short token)
+            {
+                core.GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public UniTask YieldAsync(T value)
+            {
+                core.Reset();
+                enumerator.SetResult(value);
+                return new UniTask(this, core.Version);
+            }
+
+            public void SignalWriter()
+            {
+                core.TrySetResult(AsyncUnit.Default);
+            }
+        }
+    }
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Create.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0202f723469f93945afa063bfb440d15
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Select.cs

@@ -88,6 +88,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.selector = selector;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TResult Current { get; private set; }
@@ -156,6 +157,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -195,6 +197,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.selector = selector;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TResult Current { get; private set; }
@@ -263,6 +266,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -302,6 +306,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.selector = selector;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TResult Current { get; private set; }
@@ -382,6 +387,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -422,6 +428,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.selector = selector;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TResult Current { get; private set; }
@@ -502,6 +509,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -541,6 +549,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.selector = selector;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TResult Current { get; private set; }
@@ -621,6 +630,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -661,6 +671,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.selector = selector;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TResult Current { get; private set; }
@@ -741,6 +752,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntil.cs

@@ -0,0 +1,187 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<TSource> SkipUntil<TSource>(this IUniTaskAsyncEnumerable<TSource> source, UniTask other)
+        {
+            Error.ThrowArgumentNullException(source, nameof(source));
+
+            return new SkipUntil<TSource>(source, other, null);
+        }
+
+        public static IUniTaskAsyncEnumerable<TSource> SkipUntil<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<CancellationToken, UniTask> other)
+        {
+            Error.ThrowArgumentNullException(source, nameof(source));
+            Error.ThrowArgumentNullException(source, nameof(other));
+
+            return new SkipUntil<TSource>(source, default, other);
+        }
+    }
+
+    internal sealed class SkipUntil<TSource> : IUniTaskAsyncEnumerable<TSource>
+    {
+        readonly IUniTaskAsyncEnumerable<TSource> source;
+        readonly UniTask other;
+        readonly Func<CancellationToken, UniTask> other2;
+
+        public SkipUntil(IUniTaskAsyncEnumerable<TSource> source, UniTask other, Func<CancellationToken, UniTask> other2)
+        {
+            this.source = source;
+            this.other = other;
+            this.other2 = other2;
+        }
+
+        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            if (other2 != null)
+            {
+                return new _SkipUntil(source, this.other2(cancellationToken), cancellationToken);
+            }
+            else
+            {
+                return new _SkipUntil(source, this.other, cancellationToken);
+            }
+        }
+
+        sealed class _SkipUntil : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
+        {
+            static readonly Action<object> CancelDelegate1 = OnCanceled1;
+            static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;
+
+            readonly IUniTaskAsyncEnumerable<TSource> source;
+            CancellationToken cancellationToken1;
+
+            bool completed;
+            CancellationTokenRegistration cancellationTokenRegistration1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            bool continueNext;
+            Exception exception;
+
+            public _SkipUntil(IUniTaskAsyncEnumerable<TSource> source, UniTask other, CancellationToken cancellationToken1)
+            {
+                this.source = source;
+                this.cancellationToken1 = cancellationToken1;
+                if (cancellationToken1.CanBeCanceled)
+                {
+                    this.cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this);
+                }
+
+                TaskTracker.TrackActiveTask(this, 3);
+                RunOther(other).Forget();
+            }
+
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                if (exception != null)
+                {
+                    return UniTask.FromException<bool>(exception);
+                }
+
+                if (cancellationToken1.IsCancellationRequested)
+                {
+                    return UniTask.FromCanceled<bool>(cancellationToken1);
+                }
+
+                if (enumerator == null)
+                {
+                    enumerator = source.GetAsyncEnumerator(cancellationToken1);
+                }
+                completionSource.Reset();
+
+                if (completed)
+                {
+                    SourceMoveNext();
+                }
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void SourceMoveNext()
+            {
+                try
+                {
+                    LOOP:
+                    awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                    if (awaiter.IsCompleted)
+                    {
+                        continueNext = true;
+                        MoveNextCore(this);
+                        if (continueNext)
+                        {
+                            continueNext = false;
+                            goto LOOP;
+                        }
+                    }
+                    else
+                    {
+                        awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    completionSource.TrySetException(ex);
+                }
+            }
+
+            static void MoveNextCore(object state)
+            {
+                var self = (_SkipUntil)state;
+
+                if (self.TryGetResult(self.awaiter, out var result))
+                {
+                    if (result)
+                    {
+                        self.Current = self.enumerator.Current;
+                        self.completionSource.TrySetResult(true);
+                        if (self.continueNext)
+                        {
+                            self.SourceMoveNext();
+                        }
+                    }
+                    else
+                    {
+                        self.completionSource.TrySetResult(false);
+                    }
+                }
+            }
+
+            async UniTaskVoid RunOther(UniTask other)
+            {
+                try
+                {
+                    await other;
+                    completed = true;
+                    SourceMoveNext();
+                }
+                catch (Exception ex)
+                {
+                    exception = ex;
+                    completionSource.TrySetException(ex);
+                }
+            }
+
+            static void OnCanceled1(object state)
+            {
+                var self = (_SkipUntil)state;
+                self.completionSource.TrySetCanceled(self.cancellationToken1);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                TaskTracker.RemoveTracking(this);
+                cancellationTokenRegistration1.Dispose();
+                if (enumerator != null)
+                {
+                    return enumerator.DisposeAsync();
+                }
+                return default;
+            }
+        }
+    }
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntil.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: de932d79c8d9f3841a066d05ff29edc9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntilCanceled.cs

@@ -32,13 +32,17 @@ namespace Cysharp.Threading.Tasks.Linq
 
         sealed class _SkipUntilCanceled : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
         {
+            static readonly Action<object> CancelDelegate1 = OnCanceled1;
+            static readonly Action<object> CancelDelegate2 = OnCanceled2;
             static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;
 
             readonly IUniTaskAsyncEnumerable<TSource> source;
             CancellationToken cancellationToken1;
             CancellationToken cancellationToken2;
+            CancellationTokenRegistration cancellationTokenRegistration1;
+            CancellationTokenRegistration cancellationTokenRegistration2;
 
-            bool isCanceled;
+            int isCanceled;
             IUniTaskAsyncEnumerator<TSource> enumerator;
             UniTask<bool>.Awaiter awaiter;
             bool continueNext;
@@ -48,6 +52,14 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.source = source;
                 this.cancellationToken1 = cancellationToken1;
                 this.cancellationToken2 = cancellationToken2;
+                if (cancellationToken1.CanBeCanceled)
+                {
+                    this.cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this);
+                }
+                if (cancellationToken1 != cancellationToken2 && cancellationToken2.CanBeCanceled)
+                {
+                    this.cancellationTokenRegistration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(CancelDelegate2, this);
+                }
                 TaskTracker.TrackActiveTask(this, 3);
             }
 
@@ -55,15 +67,18 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask<bool> MoveNextAsync()
             {
-                if (cancellationToken1.IsCancellationRequested) isCanceled = true;
-                if (cancellationToken2.IsCancellationRequested) isCanceled = true;
-
                 if (enumerator == null)
                 {
+                    if (cancellationToken1.IsCancellationRequested) isCanceled = 1;
+                    if (cancellationToken2.IsCancellationRequested) isCanceled = 1;
                     enumerator = source.GetAsyncEnumerator(cancellationToken2); // use only AsyncEnumerator provided token.
                 }
                 completionSource.Reset();
-                SourceMoveNext();
+
+                if (isCanceled != 0)
+                {
+                    SourceMoveNext();
+                }
                 return new UniTask<bool>(this, completionSource.Version);
             }
 
@@ -102,25 +117,11 @@ namespace Cysharp.Threading.Tasks.Linq
                 {
                     if (result)
                     {
-                        AGAIN:
-
-                        if (self.isCanceled)
+                        self.Current = self.enumerator.Current;
+                        self.completionSource.TrySetResult(true);
+                        if (self.continueNext)
                         {
-                            self.continueNext = false;
-                            self.Current = self.enumerator.Current;
-                            self.completionSource.TrySetResult(true);
-                        }
-                        else
-                        {
-                            if (self.cancellationToken1.IsCancellationRequested) self.isCanceled = true;
-                            if (self.cancellationToken2.IsCancellationRequested) self.isCanceled = true;
-
-                            if (self.isCanceled) goto AGAIN;
-
-                            if (!self.continueNext)
-                            {
-                                self.SourceMoveNext();
-                            }
+                            self.SourceMoveNext();
                         }
                     }
                     else
@@ -130,9 +131,37 @@ namespace Cysharp.Threading.Tasks.Linq
                 }
             }
 
+            static void OnCanceled1(object state)
+            {
+                var self = (_SkipUntilCanceled)state;
+                if (self.isCanceled == 0)
+                {
+                    if (Interlocked.Increment(ref self.isCanceled) == 1)
+                    {
+                        self.cancellationTokenRegistration2.Dispose();
+                        self.SourceMoveNext();
+                    }
+                }
+            }
+
+            static void OnCanceled2(object state)
+            {
+                var self = (_SkipUntilCanceled)state;
+                if (self.isCanceled == 0)
+                {
+                    if (Interlocked.Increment(ref self.isCanceled) == 1)
+                    {
+                        self.cancellationTokenRegistration2.Dispose();
+                        self.SourceMoveNext();
+                    }
+                }
+            }
+
             public UniTask DisposeAsync()
             {
                 TaskTracker.RemoveTracking(this);
+                cancellationTokenRegistration1.Dispose();
+                cancellationTokenRegistration2.Dispose();
                 if (enumerator != null)
                 {
                     return enumerator.DisposeAsync();

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntil.cs

@@ -0,0 +1,190 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<TSource> TakeUntil<TSource>(this IUniTaskAsyncEnumerable<TSource> source, UniTask other)
+        {
+            Error.ThrowArgumentNullException(source, nameof(source));
+
+            return new TakeUntil<TSource>(source, other, null);
+        }
+
+        public static IUniTaskAsyncEnumerable<TSource> TakeUntil<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<CancellationToken, UniTask> other)
+        {
+            Error.ThrowArgumentNullException(source, nameof(source));
+            Error.ThrowArgumentNullException(source, nameof(other));
+
+            return new TakeUntil<TSource>(source, default, other);
+        }
+    }
+
+    internal sealed class TakeUntil<TSource> : IUniTaskAsyncEnumerable<TSource>
+    {
+        readonly IUniTaskAsyncEnumerable<TSource> source;
+        readonly UniTask other;
+        readonly Func<CancellationToken, UniTask> other2;
+
+        public TakeUntil(IUniTaskAsyncEnumerable<TSource> source, UniTask other, Func<CancellationToken, UniTask> other2)
+        {
+            this.source = source;
+            this.other = other;
+            this.other2 = other2;
+        }
+
+        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            if (other2 != null)
+            {
+                return new _TakeUntil(source, this.other2(cancellationToken), cancellationToken);
+            }
+            else
+            {
+                return new _TakeUntil(source, this.other, cancellationToken);
+            }
+        }
+
+        sealed class _TakeUntil : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
+        {
+            static readonly Action<object> CancelDelegate1 = OnCanceled1;
+            static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;
+
+            readonly IUniTaskAsyncEnumerable<TSource> source;
+            CancellationToken cancellationToken1;
+            CancellationTokenRegistration cancellationTokenRegistration1;
+
+            bool completed;
+            Exception exception;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+
+            public _TakeUntil(IUniTaskAsyncEnumerable<TSource> source, UniTask other, CancellationToken cancellationToken1)
+            {
+                this.source = source;
+                this.cancellationToken1 = cancellationToken1;
+
+                if (cancellationToken1.CanBeCanceled)
+                {
+                    this.cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this);
+                }
+
+                TaskTracker.TrackActiveTask(this, 3);
+
+                RunOther(other).Forget();
+            }
+
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                if (completed)
+                {
+                    return CompletedTasks.False;
+                }
+
+                if (exception != null)
+                {
+                    return UniTask.FromException<bool>(exception);
+                }
+
+                if (cancellationToken1.IsCancellationRequested)
+                {
+                    return UniTask.FromCanceled<bool>(cancellationToken1);
+                }
+
+                if (enumerator == null)
+                {
+                    enumerator = source.GetAsyncEnumerator(cancellationToken1);
+                }
+
+                completionSource.Reset();
+                SourceMoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void SourceMoveNext()
+            {
+                try
+                {
+                    awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                    if (awaiter.IsCompleted)
+                    {
+                        MoveNextCore(this);
+                    }
+                    else
+                    {
+                        awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    completionSource.TrySetException(ex);
+                }
+            }
+
+            static void MoveNextCore(object state)
+            {
+                var self = (_TakeUntil)state;
+
+                if (self.TryGetResult(self.awaiter, out var result))
+                {
+                    if (result)
+                    {
+                        if (self.exception != null)
+                        {
+                            self.completionSource.TrySetException(self.exception);
+                        }
+                        else if (self.cancellationToken1.IsCancellationRequested)
+                        {
+                            self.completionSource.TrySetCanceled(self.cancellationToken1);
+                        }
+                        else
+                        {
+                            self.Current = self.enumerator.Current;
+                            self.completionSource.TrySetResult(true);
+                        }
+                    }
+                    else
+                    {
+                        self.completionSource.TrySetResult(false);
+                    }
+                }
+            }
+
+            async UniTaskVoid RunOther(UniTask other)
+            {
+                try
+                {
+                    await other;
+                    completed = true;
+                    completionSource.TrySetResult(false);
+                }
+                catch (Exception ex)
+                {
+                    exception = ex;
+                    completionSource.TrySetException(ex);
+                }
+            }
+
+            static void OnCanceled1(object state)
+            {
+                var self = (_TakeUntil)state;
+                self.completionSource.TrySetCanceled(self.cancellationToken1);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                TaskTracker.RemoveTracking(this);
+                cancellationTokenRegistration1.Dispose();
+                if (enumerator != null)
+                {
+                    return enumerator.DisposeAsync();
+                }
+                return default;
+            }
+        }
+    }
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntil.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 12bda324162f15349afefc2c152ac07f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Where.cs

@@ -88,6 +88,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.predicate = predicate;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TSource Current { get; private set; }
@@ -165,6 +166,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -204,6 +206,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.predicate = predicate;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TSource Current { get; private set; }
@@ -281,6 +284,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -320,6 +324,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.predicate = predicate;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TSource Current { get; private set; }
@@ -410,6 +415,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -450,6 +456,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.predicate = predicate;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TSource Current { get; private set; }
@@ -540,6 +547,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -579,6 +587,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.predicate = predicate;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TSource Current { get; private set; }
@@ -669,6 +678,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }
@@ -709,6 +719,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 this.predicate = predicate;
                 this.cancellationToken = cancellationToken;
                 this.moveNextAction = MoveNext;
+                TaskTracker.TrackActiveTask(this, 3);
             }
 
             public TSource Current { get; private set; }
@@ -799,6 +810,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
             public UniTask DisposeAsync()
             {
+                TaskTracker.RemoveTracking(this);
                 return enumerator.DisposeAsync();
             }
         }

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

@@ -175,6 +175,32 @@ namespace Cysharp.Threading.Tasks
             return dest;
         }
 
+        static PlayerLoopSystem[] InsertUniTaskSynchronizationContext(PlayerLoopSystem loopSystem)
+        {
+            var loop = new PlayerLoopSystem
+            {
+                type = typeof(UniTaskSynchronizationContext),
+                updateDelegate = UniTaskSynchronizationContext.Run
+            };
+
+            // Remove items from previous initializations.
+            var source = loopSystem.subSystemList
+                .Where(ls => ls.type != typeof(UniTaskSynchronizationContext))
+                .ToArray();
+
+            var dest = new System.Collections.Generic.List<PlayerLoopSystem>(source);
+
+            var index = dest.FindIndex(x => x.type.Name == "ScriptRunDelayedTasks");
+            if (index == -1)
+            {
+                index = dest.FindIndex(x => x.type.Name == "UniTaskLoopRunnerUpdate");
+            }
+
+            dest.Insert(index + 1, loop);
+
+            return dest.ToArray();
+        }
+
         [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
         static void Init()
         {
@@ -246,6 +272,8 @@ namespace Cysharp.Threading.Tasks
                     if (item != null) item.Run();
                 }
             }
+
+            UniTaskSynchronizationContext.Run();
         }
 
 #endif
@@ -293,6 +321,9 @@ namespace Cysharp.Threading.Tasks
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), runners[12] = new PlayerLoopRunner(PlayerLoopTiming.PostLateUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPostLateUpdate), runners[13] = new PlayerLoopRunner(PlayerLoopTiming.LastPostLateUpdate));
 
+            // Insert UniTaskSynchronizationContext to Update loop
+            copyList[4].subSystemList = InsertUniTaskSynchronizationContext(copyList[4]);
+
             playerLoop.subSystemList = copyList;
             PlayerLoop.SetPlayerLoop(playerLoop);
         }
@@ -306,6 +337,56 @@ namespace Cysharp.Threading.Tasks
         {
             yielders[(int)timing].Enqueue(continuation);
         }
+
+        // Diagnostics helper
+
+#if UNITY_2019_3_OR_NEWER
+
+        public static void DumpCurrentPlayerLoop()
+        {
+            var playerLoop = UnityEngine.LowLevel.PlayerLoop.GetCurrentPlayerLoop();
+
+            var sb = new System.Text.StringBuilder();
+            sb.AppendLine($"PlayerLoop List");
+            foreach (var header in playerLoop.subSystemList)
+            {
+                sb.AppendFormat("------{0}------", header.type.Name);
+                sb.AppendLine();
+                foreach (var subSystem in header.subSystemList)
+                {
+                    sb.AppendFormat("{0}", subSystem.type.Name);
+                    sb.AppendLine();
+
+                    if (subSystem.subSystemList != null)
+                    {
+                        UnityEngine.Debug.LogWarning("More Subsystem:" + subSystem.subSystemList.Length);
+                    }
+                }
+            }
+
+            UnityEngine.Debug.Log(sb.ToString());
+        }
+
+        public static bool IsInjectedUniTaskPlayerLoop()
+        {
+            var playerLoop = UnityEngine.LowLevel.PlayerLoop.GetCurrentPlayerLoop();
+
+            foreach (var header in playerLoop.subSystemList)
+            {
+                foreach (var subSystem in header.subSystemList)
+                {
+                    if (subSystem.type == typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+#endif
+
     }
 }
 

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

@@ -1,13 +1,23 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
+using Cysharp.Threading.Tasks.Internal;
 using System;
-using System.IO;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using UnityEngine;
 
 namespace Cysharp.Threading.Tasks
 {
+    public enum DelayType
+    {
+        /// <summary>use Time.deltaTime.</summary>
+        DeltaTime,
+        /// <summary>Ignore timescale, use Time.unscaledDeltaTime.</summary>
+        UnscaledDeltaTime,
+        /// <summary>use Stopwatch.GetTimestamp().</summary>
+        Realtime
+    }
+
     public partial struct UniTask
     {
         public static YieldAwaitable Yield(PlayerLoopTiming timing = PlayerLoopTiming.Update)
@@ -74,26 +84,44 @@ namespace Cysharp.Threading.Tasks
         public static UniTask Delay(int millisecondsDelay, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             var delayTimeSpan = TimeSpan.FromMilliseconds(millisecondsDelay);
-            if (delayTimeSpan < TimeSpan.Zero)
-            {
-                throw new ArgumentOutOfRangeException("Delay does not allow minus millisecondsDelay. millisecondsDelay:" + millisecondsDelay);
-            }
-
-            return (ignoreTimeScale)
-                ? new UniTask(DelayIgnoreTimeScalePromise.Create(delayTimeSpan, delayTiming, cancellationToken, out var token), token)
-                : new UniTask(DelayPromise.Create(delayTimeSpan, delayTiming, cancellationToken, out token), token);
+            return Delay(delayTimeSpan, ignoreTimeScale, delayTiming, cancellationToken);
         }
 
         public static UniTask Delay(TimeSpan delayTimeSpan, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var delayType = ignoreTimeScale ? DelayType.UnscaledDeltaTime : DelayType.DeltaTime;
+            return Delay(delayTimeSpan, delayType, delayTiming, cancellationToken);
+        }
+
+        public static UniTask Delay(int millisecondsDelay, DelayType delayType, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var delayTimeSpan = TimeSpan.FromMilliseconds(millisecondsDelay);
+            return Delay(delayTimeSpan, delayType, delayTiming, cancellationToken);
+        }
+
+        public static UniTask Delay(TimeSpan delayTimeSpan, DelayType delayType, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (delayTimeSpan < TimeSpan.Zero)
             {
                 throw new ArgumentOutOfRangeException("Delay does not allow minus delayTimeSpan. delayTimeSpan:" + delayTimeSpan);
             }
 
-            return (ignoreTimeScale)
-                ? new UniTask(DelayIgnoreTimeScalePromise.Create(delayTimeSpan, delayTiming, cancellationToken, out var token), token)
-                : new UniTask(DelayPromise.Create(delayTimeSpan, delayTiming, cancellationToken, out token), token);
+            switch (delayType)
+            {
+                case DelayType.UnscaledDeltaTime:
+                    {
+                        return new UniTask(DelayIgnoreTimeScalePromise.Create(delayTimeSpan, delayTiming, cancellationToken, out var token), token);
+                    }
+                case DelayType.Realtime:
+                    {
+                        return new UniTask(DelayRealtimePromise.Create(delayTimeSpan, delayTiming, cancellationToken, out var token), token);
+                    }
+                case DelayType.DeltaTime:
+                default:
+                    {
+                        return new UniTask(DelayPromise.Create(delayTimeSpan, delayTiming, cancellationToken, out var token), token);
+                    }
+            }
         }
 
         sealed class YieldPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<YieldPromise>
@@ -404,7 +432,7 @@ namespace Cysharp.Threading.Tasks
             }
 
             int initialFrame;
-            float delayFrameTimeSpan;
+            float delayTimeSpan;
             float elapsed;
             CancellationToken cancellationToken;
 
@@ -414,7 +442,7 @@ namespace Cysharp.Threading.Tasks
             {
             }
 
-            public static IUniTaskSource Create(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            public static IUniTaskSource Create(TimeSpan delayTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
             {
                 if (cancellationToken.IsCancellationRequested)
                 {
@@ -427,7 +455,7 @@ namespace Cysharp.Threading.Tasks
                 }
 
                 result.elapsed = 0.0f;
-                result.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
+                result.delayTimeSpan = (float)delayTimeSpan.TotalSeconds;
                 result.cancellationToken = cancellationToken;
                 result.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1;
 
@@ -483,7 +511,7 @@ namespace Cysharp.Threading.Tasks
                 }
 
                 elapsed += Time.deltaTime;
-                if (elapsed >= delayFrameTimeSpan)
+                if (elapsed >= delayTimeSpan)
                 {
                     core.TrySetResult(null);
                     return false;
@@ -496,7 +524,7 @@ namespace Cysharp.Threading.Tasks
             {
                 TaskTracker.RemoveTracking(this);
                 core.Reset();
-                delayFrameTimeSpan = default;
+                delayTimeSpan = default;
                 elapsed = default;
                 cancellationToken = default;
                 return pool.TryPush(this);
@@ -612,6 +640,104 @@ namespace Cysharp.Threading.Tasks
                 return pool.TryPush(this);
             }
         }
+
+        sealed class DelayRealtimePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<DelayRealtimePromise>
+        {
+            static TaskPool<DelayRealtimePromise> pool;
+            public DelayRealtimePromise NextNode { get; set; }
+
+            static DelayRealtimePromise()
+            {
+                TaskPool.RegisterSizeGetter(typeof(DelayRealtimePromise), () => pool.Size);
+            }
+
+            long delayTimeSpanTicks;
+            ValueStopwatch stopwatch;
+            CancellationToken cancellationToken;
+
+            UniTaskCompletionSourceCore<AsyncUnit> core;
+
+            DelayRealtimePromise()
+            {
+            }
+
+            public static IUniTaskSource Create(TimeSpan delayTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new DelayRealtimePromise();
+                }
+
+                result.stopwatch = ValueStopwatch.StartNew();
+                result.delayTimeSpanTicks = delayTimeSpan.Ticks;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public void GetResult(short token)
+            {
+                try
+                {
+                    core.GetResult(token);
+                }
+                finally
+                {
+                    TryReturn();
+                }
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    core.TrySetCanceled(cancellationToken);
+                    return false;
+                }
+
+                if (stopwatch.ElapsedTicks >= delayTimeSpanTicks)
+                {
+                    core.TrySetResult(AsyncUnit.Default);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                stopwatch = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+        }
     }
 
     public readonly struct YieldAwaitable

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

@@ -3,6 +3,7 @@
 using Cysharp.Threading.Tasks.Internal;
 using System;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 
 namespace Cysharp.Threading.Tasks
@@ -174,18 +175,34 @@ namespace Cysharp.Threading.Tasks
             return new UniTask<T>(new DeferPromise<T>(factory), 0);
         }
 
+        /// <summary>
+        /// Never complete.
+        /// </summary>
+        public static UniTask Never(CancellationToken cancellationToken)
+        {
+            return new UniTask<AsyncUnit>(new NeverPromise<AsyncUnit>(cancellationToken), 0);
+        }
+
+        /// <summary>
+        /// Never complete.
+        /// </summary>
+        public static UniTask<T> Never<T>(CancellationToken cancellationToken)
+        {
+            return new UniTask<T>(new NeverPromise<T>(cancellationToken), 0);
+        }
+
         sealed class ExceptionResultSource : IUniTaskSource
         {
-            readonly Exception exception;
+            readonly ExceptionDispatchInfo exception;
 
             public ExceptionResultSource(Exception exception)
             {
-                this.exception = exception;
+                this.exception = ExceptionDispatchInfo.Capture(exception);
             }
 
             public void GetResult(short token)
             {
-                throw exception;
+                exception.Throw();
             }
 
             public UniTaskStatus GetStatus(short token)
@@ -206,21 +223,22 @@ namespace Cysharp.Threading.Tasks
 
         sealed class ExceptionResultSource<T> : IUniTaskSource<T>
         {
-            readonly Exception exception;
+            readonly ExceptionDispatchInfo exception;
 
             public ExceptionResultSource(Exception exception)
             {
-                this.exception = exception;
+                this.exception = ExceptionDispatchInfo.Capture(exception);
             }
 
             public T GetResult(short token)
             {
-                throw exception;
+                exception.Throw();
+                return default;
             }
 
             void IUniTaskSource.GetResult(short token)
             {
-                throw exception;
+                exception.Throw();
             }
 
             public UniTaskStatus GetStatus(short token)
@@ -382,6 +400,54 @@ namespace Cysharp.Threading.Tasks
                 return task.Status;
             }
         }
+
+        sealed class NeverPromise<T> : IUniTaskSource<T>
+        {
+            static readonly Action<object> cancellationCallback = CancellationCallback;
+
+            CancellationToken cancellationToken;
+            UniTaskCompletionSourceCore<T> core;
+
+            public NeverPromise(CancellationToken cancellationToken)
+            {
+                this.cancellationToken = cancellationToken;
+                if (this.cancellationToken.CanBeCanceled)
+                {
+                    this.cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
+                }
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (NeverPromise<T>)state;
+                self.core.TrySetCanceled(self.cancellationToken);
+            }
+
+            public T GetResult(short token)
+            {
+                return core.GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                core.GetResult(token);
+            }
+        }
     }
 
     internal static class CompletedTasks

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

@@ -1,16 +1,21 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
 using System;
+using System.Threading;
 
 namespace Cysharp.Threading.Tasks
 {
     public partial struct UniTask
     {
         /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
-        public static async UniTask Run(Action action, bool configureAwait = true)
+        public static async UniTask Run(Action action, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             await UniTask.SwitchToThreadPool();
 
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (configureAwait)
             {
                 try
@@ -26,13 +31,19 @@ namespace Cysharp.Threading.Tasks
             {
                 action();
             }
+
+            cancellationToken.ThrowIfCancellationRequested();
         }
 
         /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
-        public static async UniTask Run(Action<object> action, object state, bool configureAwait = true)
+        public static async UniTask Run(Action<object> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             await UniTask.SwitchToThreadPool();
 
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (configureAwait)
             {
                 try
@@ -48,13 +59,19 @@ namespace Cysharp.Threading.Tasks
             {
                 action(state);
             }
+
+            cancellationToken.ThrowIfCancellationRequested();
         }
 
         /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
-        public static async UniTask Run(Func<UniTask> action, bool configureAwait = true)
+        public static async UniTask Run(Func<UniTask> action, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             await UniTask.SwitchToThreadPool();
 
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (configureAwait)
             {
                 try
@@ -70,13 +87,19 @@ namespace Cysharp.Threading.Tasks
             {
                 await action();
             }
+
+            cancellationToken.ThrowIfCancellationRequested();
         }
 
         /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
-        public static async UniTask Run(Func<object, UniTask> action, object state, bool configureAwait = true)
+        public static async UniTask Run(Func<object, UniTask> action, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             await UniTask.SwitchToThreadPool();
 
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (configureAwait)
             {
                 try
@@ -92,12 +115,19 @@ namespace Cysharp.Threading.Tasks
             {
                 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> Run<T>(Func<T> func, bool configureAwait = true)
+        public static async UniTask<T> Run<T>(Func<T> func, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (configureAwait)
             {
                 try
@@ -107,6 +137,7 @@ namespace Cysharp.Threading.Tasks
                 finally
                 {
                     await UniTask.Yield();
+                    cancellationToken.ThrowIfCancellationRequested();
                 }
             }
             else
@@ -116,9 +147,14 @@ namespace Cysharp.Threading.Tasks
         }
 
         /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
-        public static async UniTask<T> Run<T>(Func<UniTask<T>> func, bool configureAwait = true)
+        public static async UniTask<T> Run<T>(Func<UniTask<T>> func, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             await UniTask.SwitchToThreadPool();
+
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (configureAwait)
             {
                 try
@@ -127,20 +163,28 @@ namespace Cysharp.Threading.Tasks
                 }
                 finally
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
                     await UniTask.Yield();
+                    cancellationToken.ThrowIfCancellationRequested();
                 }
             }
             else
             {
-                return await func();
+                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> Run<T>(Func<object, T> func, object state, bool configureAwait = true)
+        public static async UniTask<T> Run<T>(Func<object, T> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             await UniTask.SwitchToThreadPool();
 
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (configureAwait)
             {
                 try
@@ -150,6 +194,7 @@ namespace Cysharp.Threading.Tasks
                 finally
                 {
                     await UniTask.Yield();
+                    cancellationToken.ThrowIfCancellationRequested();
                 }
             }
             else
@@ -159,10 +204,14 @@ namespace Cysharp.Threading.Tasks
         }
 
         /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
-        public static async UniTask<T> Run<T>(Func<object, UniTask<T>> func, object state, bool configureAwait = true)
+        public static async UniTask<T> Run<T>(Func<object, UniTask<T>> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             await UniTask.SwitchToThreadPool();
 
+            cancellationToken.ThrowIfCancellationRequested();
+
             if (configureAwait)
             {
                 try
@@ -171,12 +220,16 @@ namespace Cysharp.Threading.Tasks
                 }
                 finally
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
                     await UniTask.Yield();
+                    cancellationToken.ThrowIfCancellationRequested();
                 }
             }
             else
             {
-                return await func(state);
+                var result = await func(state);
+                cancellationToken.ThrowIfCancellationRequested();
+                return result;
             }
         }
     }

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

@@ -15,33 +15,41 @@ namespace Cysharp.Threading.Tasks
         /// <summary>
         /// If running on mainthread, do nothing. Otherwise, same as UniTask.Yield(PlayerLoopTiming.Update).
         /// </summary>
-        public static SwitchToMainThreadAwaitable SwitchToMainThread()
+        public static SwitchToMainThreadAwaitable SwitchToMainThread(CancellationToken cancellationToken = default)
         {
-            return new SwitchToMainThreadAwaitable(PlayerLoopTiming.Update);
+            return new SwitchToMainThreadAwaitable(PlayerLoopTiming.Update, cancellationToken);
         }
 
         /// <summary>
         /// If running on mainthread, do nothing. Otherwise, same as UniTask.Yield(timing).
         /// </summary>
-        public static SwitchToMainThreadAwaitable SwitchToMainThread(PlayerLoopTiming timing)
+        public static SwitchToMainThreadAwaitable SwitchToMainThread(PlayerLoopTiming timing, CancellationToken cancellationToken = default)
         {
-            return new SwitchToMainThreadAwaitable(timing);
+            return new SwitchToMainThreadAwaitable(timing, cancellationToken);
         }
 
         /// <summary>
         /// Return to mainthread(same as await SwitchToMainThread) after using scope is closed.
         /// </summary>
-        public static ReturnToMainThread ReturnToMainThread()
+        public static ReturnToMainThread ReturnToMainThread(CancellationToken cancellationToken = default)
         {
-            return new ReturnToMainThread(PlayerLoopTiming.Update);
+            return new ReturnToMainThread(PlayerLoopTiming.Update, cancellationToken);
         }
 
         /// <summary>
         /// Return to mainthread(same as await SwitchToMainThread) after using scope is closed.
         /// </summary>
-        public static ReturnToMainThread ReturnToMainThread(PlayerLoopTiming timing)
+        public static ReturnToMainThread ReturnToMainThread(PlayerLoopTiming timing, CancellationToken cancellationToken = default)
         {
-            return new ReturnToMainThread(timing);
+            return new ReturnToMainThread(timing, cancellationToken);
+        }
+
+        /// <summary>
+        /// Queue the action to PlayerLoop.
+        /// </summary>
+        public static void Post(Action action, PlayerLoopTiming timing = PlayerLoopTiming.Update)
+        {
+            PlayerLoopHelper.AddContinuation(timing, action);
         }
 
 #endif
@@ -59,20 +67,20 @@ namespace Cysharp.Threading.Tasks
             return new SwitchToTaskPoolAwaitable();
         }
 
-        public static SwitchToSynchronizationContextAwaitable SwitchToSynchronizationContext(SynchronizationContext synchronizationContext)
+        public static SwitchToSynchronizationContextAwaitable SwitchToSynchronizationContext(SynchronizationContext synchronizationContext, CancellationToken cancellationToken = default)
         {
             Error.ThrowArgumentNullException(synchronizationContext, nameof(synchronizationContext));
-            return new SwitchToSynchronizationContextAwaitable(synchronizationContext);
+            return new SwitchToSynchronizationContextAwaitable(synchronizationContext, cancellationToken);
         }
 
-        public static ReturnToSynchronizationContext ReturnToSynchronizationContext(SynchronizationContext synchronizationContext)
+        public static ReturnToSynchronizationContext ReturnToSynchronizationContext(SynchronizationContext synchronizationContext, CancellationToken cancellationToken = default)
         {
-            return new ReturnToSynchronizationContext(synchronizationContext, false);
+            return new ReturnToSynchronizationContext(synchronizationContext, false, cancellationToken);
         }
 
-        public static ReturnToSynchronizationContext ReturnToCurrentSynchronizationContext(bool dontPostWhenSameContext = true)
+        public static ReturnToSynchronizationContext ReturnToCurrentSynchronizationContext(bool dontPostWhenSameContext = true, CancellationToken cancellationToken = default)
         {
-            return new ReturnToSynchronizationContext(SynchronizationContext.Current, dontPostWhenSameContext);
+            return new ReturnToSynchronizationContext(SynchronizationContext.Current, dontPostWhenSameContext, cancellationToken);
         }
     }
 
@@ -81,21 +89,25 @@ namespace Cysharp.Threading.Tasks
     public struct SwitchToMainThreadAwaitable
     {
         readonly PlayerLoopTiming playerLoopTiming;
+        readonly CancellationToken cancellationToken;
 
-        public SwitchToMainThreadAwaitable(PlayerLoopTiming playerLoopTiming)
+        public SwitchToMainThreadAwaitable(PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken)
         {
             this.playerLoopTiming = playerLoopTiming;
+            this.cancellationToken = cancellationToken;
         }
 
-        public Awaiter GetAwaiter() => new Awaiter(playerLoopTiming);
+        public Awaiter GetAwaiter() => new Awaiter(playerLoopTiming, cancellationToken);
 
         public struct Awaiter : ICriticalNotifyCompletion
         {
             readonly PlayerLoopTiming playerLoopTiming;
+            readonly CancellationToken cancellationToken;
 
-            public Awaiter(PlayerLoopTiming playerLoopTiming)
+            public Awaiter(PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken)
             {
                 this.playerLoopTiming = playerLoopTiming;
+                this.cancellationToken = cancellationToken;
             }
 
             public bool IsCompleted
@@ -114,7 +126,7 @@ namespace Cysharp.Threading.Tasks
                 }
             }
 
-            public void GetResult() { }
+            public void GetResult() { cancellationToken.ThrowIfCancellationRequested(); }
 
             public void OnCompleted(Action continuation)
             {
@@ -131,31 +143,35 @@ namespace Cysharp.Threading.Tasks
     public struct ReturnToMainThread
     {
         readonly PlayerLoopTiming playerLoopTiming;
+        readonly CancellationToken cancellationToken;
 
-        public ReturnToMainThread(PlayerLoopTiming playerLoopTiming)
+        public ReturnToMainThread(PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken)
         {
             this.playerLoopTiming = playerLoopTiming;
+            this.cancellationToken = cancellationToken;
         }
 
         public Awaiter DisposeAsync()
         {
-            return new Awaiter(playerLoopTiming); // run immediate.
+            return new Awaiter(playerLoopTiming, cancellationToken); // run immediate.
         }
 
         public readonly struct Awaiter : ICriticalNotifyCompletion
         {
             readonly PlayerLoopTiming timing;
+            readonly CancellationToken cancellationToken;
 
-            public Awaiter(PlayerLoopTiming timing)
+            public Awaiter(PlayerLoopTiming timing, CancellationToken cancellationToken)
             {
                 this.timing = timing;
+                this.cancellationToken = cancellationToken;
             }
 
             public Awaiter GetAwaiter() => this;
 
             public bool IsCompleted => PlayerLoopHelper.MainThreadId == System.Threading.Thread.CurrentThread.ManagedThreadId;
 
-            public void GetResult() { }
+            public void GetResult() { cancellationToken.ThrowIfCancellationRequested(); }
 
             public void OnCompleted(Action continuation)
             {
@@ -277,26 +293,30 @@ namespace Cysharp.Threading.Tasks
     public struct SwitchToSynchronizationContextAwaitable
     {
         readonly SynchronizationContext synchronizationContext;
+        readonly CancellationToken cancellationToken;
 
-        public SwitchToSynchronizationContextAwaitable(SynchronizationContext synchronizationContext)
+        public SwitchToSynchronizationContextAwaitable(SynchronizationContext synchronizationContext, CancellationToken cancellationToken)
         {
             this.synchronizationContext = synchronizationContext;
+            this.cancellationToken = cancellationToken;
         }
 
-        public Awaiter GetAwaiter() => new Awaiter(synchronizationContext);
+        public Awaiter GetAwaiter() => new Awaiter(synchronizationContext, cancellationToken);
 
         public struct Awaiter : ICriticalNotifyCompletion
         {
             static readonly SendOrPostCallback switchToCallback = Callback;
             readonly SynchronizationContext synchronizationContext;
+            readonly CancellationToken cancellationToken;
 
-            public Awaiter(SynchronizationContext synchronizationContext)
+            public Awaiter(SynchronizationContext synchronizationContext, CancellationToken cancellationToken)
             {
                 this.synchronizationContext = synchronizationContext;
+                this.cancellationToken = cancellationToken;
             }
 
             public bool IsCompleted => false;
-            public void GetResult() { }
+            public void GetResult() { cancellationToken.ThrowIfCancellationRequested(); }
 
             public void OnCompleted(Action continuation)
             {
@@ -320,16 +340,18 @@ namespace Cysharp.Threading.Tasks
     {
         readonly SynchronizationContext syncContext;
         readonly bool dontPostWhenSameContext;
+        readonly CancellationToken cancellationToken;
 
-        public ReturnToSynchronizationContext(SynchronizationContext syncContext, bool dontPostWhenSameContext)
+        public ReturnToSynchronizationContext(SynchronizationContext syncContext, bool dontPostWhenSameContext, CancellationToken cancellationToken)
         {
             this.syncContext = syncContext;
             this.dontPostWhenSameContext = dontPostWhenSameContext;
+            this.cancellationToken = cancellationToken;
         }
 
         public Awaiter DisposeAsync()
         {
-            return new Awaiter(syncContext, dontPostWhenSameContext);
+            return new Awaiter(syncContext, dontPostWhenSameContext, cancellationToken);
         }
 
         public struct Awaiter : ICriticalNotifyCompletion
@@ -338,11 +360,13 @@ namespace Cysharp.Threading.Tasks
 
             readonly SynchronizationContext synchronizationContext;
             readonly bool dontPostWhenSameContext;
+            readonly CancellationToken cancellationToken;
 
-            public Awaiter(SynchronizationContext synchronizationContext, bool dontPostWhenSameContext)
+            public Awaiter(SynchronizationContext synchronizationContext, bool dontPostWhenSameContext, CancellationToken cancellationToken)
             {
                 this.synchronizationContext = synchronizationContext;
                 this.dontPostWhenSameContext = dontPostWhenSameContext;
+                this.cancellationToken = cancellationToken;
             }
 
             public Awaiter GetAwaiter() => this;
@@ -365,7 +389,7 @@ namespace Cysharp.Threading.Tasks
                 }
             }
 
-            public void GetResult() { }
+            public void GetResult() { cancellationToken.ThrowIfCancellationRequested(); }
 
             public void OnCompleted(Action continuation)
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.asmdef

@@ -1,9 +1,6 @@
 {
     "name": "UniTask",
     "references": [
-        "Unity.ResourceManager",
-        "Unity.TextMeshPro",
-        "DOTween.Modules"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],
@@ -14,19 +11,9 @@
     "defineConstraints": [],
     "versionDefines": [
         {
-            "name": "com.unity.addressables",
+            "name": "com.unity.modules.assetbundle",
             "expression": "",
-            "define": "UNITASK_ADDRESSABLE_SUPPORT"
-        },
-        {
-            "name": "com.unity.textmeshpro",
-            "expression": "",
-            "define": "UNITASK_TEXTMESHPRO_SUPPORT"
-        },
-        {
-            "name": "com.demigiant.dotween",
-            "expression": "",
-            "define": "UNITASK_DOTWEEN_SUPPORT"
+            "define": "UNITASK_ASSETBUNDLE_SUPPORT"
         }
     ],
     "noEngineReferences": false

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

@@ -229,7 +229,7 @@ namespace Cysharp.Threading.Tasks
             ValidateToken(token);
             if (completedCount == 0)
             {
-                throw new InvalidOperationException("not yet completed.");
+                throw new InvalidOperationException("Not yet completed, UniTask only allow to use await.");
             }
 
             if (error != null)
@@ -288,7 +288,7 @@ namespace Cysharp.Threading.Tasks
                 // It will cause call OnCompleted multiple time, invalid.
                 if (!ReferenceEquals(oldContinuation, UniTaskCompletionSourceCoreShared.s_sentinel))
                 {
-                    throw new InvalidOperationException();
+                    throw new InvalidOperationException("Already continuation registered, can not await twice or get Status after await.");
                 }
 
                 continuation(state);

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

@@ -189,6 +189,174 @@ namespace Cysharp.Threading.Tasks
             return new AsyncLazy<T>(task);
         }
 
+        /// <summary>
+        /// Ignore task result when cancel raised first.
+        /// </summary>
+        public static UniTask WithCancellation(this UniTask task, CancellationToken cancellationToken)
+        {
+            if (!cancellationToken.CanBeCanceled)
+            {
+                return task;
+            }
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return UniTask.FromCanceled(cancellationToken);
+            }
+
+            if (task.Status.IsCompleted())
+            {
+                return task;
+            }
+
+            return new UniTask(new WithCancellationSource(task, cancellationToken), 0);
+        }
+
+        /// <summary>
+        /// Ignore task result when cancel raised first.
+        /// </summary>
+        public static UniTask<T> WithCancellation<T>(this UniTask<T> task, CancellationToken cancellationToken)
+        {
+            if (!cancellationToken.CanBeCanceled)
+            {
+                return task;
+            }
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return UniTask.FromCanceled<T>(cancellationToken);
+            }
+
+            if (task.Status.IsCompleted())
+            {
+                return task;
+            }
+
+            return new UniTask<T>(new WithCancellationSource<T>(task, cancellationToken), 0);
+        }
+
+        sealed class WithCancellationSource : IUniTaskSource
+        {
+            static readonly Action<object> cancellationCallbackDelegate = CancellationCallback;
+
+            CancellationToken cancellationToken;
+            CancellationTokenRegistration tokenRegistration;
+            UniTaskCompletionSourceCore<AsyncUnit> core;
+
+            public WithCancellationSource(UniTask task, CancellationToken cancellationToken)
+            {
+                this.cancellationToken = cancellationToken;
+                this.tokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallbackDelegate, this);
+                RunTask(task).Forget();
+            }
+
+            async UniTaskVoid RunTask(UniTask task)
+            {
+                try
+                {
+                    await task;
+                    core.TrySetResult(AsyncUnit.Default);
+                }
+                catch (Exception ex)
+                {
+                    core.TrySetException(ex);
+                }
+                finally
+                {
+                    tokenRegistration.Dispose();
+                }
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (WithCancellationSource)state;
+                self.core.TrySetCanceled(self.cancellationToken);
+            }
+
+            public void GetResult(short token)
+            {
+                core.GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+        }
+
+        sealed class WithCancellationSource<T> : IUniTaskSource<T>
+        {
+            static readonly Action<object> cancellationCallbackDelegate = CancellationCallback;
+
+            CancellationToken cancellationToken;
+            CancellationTokenRegistration tokenRegistration;
+            UniTaskCompletionSourceCore<T> core;
+
+            public WithCancellationSource(UniTask<T> task, CancellationToken cancellationToken)
+            {
+                this.cancellationToken = cancellationToken;
+                this.tokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallbackDelegate, this);
+                RunTask(task).Forget();
+            }
+
+            async UniTaskVoid RunTask(UniTask<T> task)
+            {
+                try
+                {
+                    core.TrySetResult(await task);
+                }
+                catch (Exception ex)
+                {
+                    core.TrySetException(ex);
+                }
+                finally
+                {
+                    tokenRegistration.Dispose();
+                }
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (WithCancellationSource<T>)state;
+                self.core.TrySetCanceled(self.cancellationToken);
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                core.GetResult(token);
+            }
+
+            public T GetResult(short token)
+            {
+                return core.GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+        }
+
 #if UNITY_2018_3_OR_NEWER
 
         public static IEnumerator ToCoroutine<T>(this UniTask<T> task, Action<T> resultHandler = null, Action<Exception> exceptionHandler = null)
@@ -201,10 +369,10 @@ namespace Cysharp.Threading.Tasks
             return new ToCoroutineEnumerator(task, exceptionHandler);
         }
 
-        public static async UniTask Timeout(this UniTask task, TimeSpan timeout, bool ignoreTimeScale = true, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
+        public static async UniTask Timeout(this UniTask task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
         {
             var delayCancellationTokenSource = new CancellationTokenSource();
-            var timeoutTask = UniTask.Delay(timeout, ignoreTimeScale, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
+            var timeoutTask = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
 
             int winArgIndex;
             bool taskResultIsCanceled;
@@ -242,10 +410,10 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        public static async UniTask<T> Timeout<T>(this UniTask<T> task, TimeSpan timeout, bool ignoreTimeScale = true, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
+        public static async UniTask<T> Timeout<T>(this UniTask<T> task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
         {
             var delayCancellationTokenSource = new CancellationTokenSource();
-            var timeoutTask = UniTask.Delay(timeout, ignoreTimeScale, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
+            var timeoutTask = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
 
             int winArgIndex;
             (bool IsCanceled, T Result) taskResult;
@@ -288,10 +456,10 @@ namespace Cysharp.Threading.Tasks
         /// <summary>
         /// Timeout with suppress OperationCanceledException. Returns (bool, IsCacneled).
         /// </summary>
-        public static async UniTask<bool> TimeoutWithoutException(this UniTask task, TimeSpan timeout, bool ignoreTimeScale = true, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
+        public static async UniTask<bool> TimeoutWithoutException(this UniTask task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
         {
             var delayCancellationTokenSource = new CancellationTokenSource();
-            var timeoutTask = UniTask.Delay(timeout, ignoreTimeScale, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
+            var timeoutTask = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
 
             int winArgIndex;
             bool taskResultIsCanceled;
@@ -334,10 +502,10 @@ namespace Cysharp.Threading.Tasks
         /// <summary>
         /// Timeout with suppress OperationCanceledException. Returns (bool IsTimeout, T Result).
         /// </summary>
-        public static async UniTask<(bool IsTimeout, T Result)> TimeoutWithoutException<T>(this UniTask<T> task, TimeSpan timeout, bool ignoreTimeScale = true, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
+        public static async UniTask<(bool IsTimeout, T Result)> TimeoutWithoutException<T>(this UniTask<T> task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null)
         {
             var delayCancellationTokenSource = new CancellationTokenSource();
-            var timeoutTask = UniTask.Delay(timeout, ignoreTimeScale, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
+            var timeoutTask = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow();
 
             int winArgIndex;
             (bool IsCanceled, T Result) taskResult;

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

@@ -0,0 +1,158 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public class UniTaskSynchronizationContext : SynchronizationContext
+    {
+        const int MaxArrayLength = 0X7FEFFFFF;
+        const int InitialSize = 16;
+
+        static SpinLock gate = new SpinLock();
+        static bool dequing = false;
+
+        static int actionListCount = 0;
+        static Callback[] actionList = new Callback[InitialSize];
+
+        static int waitingListCount = 0;
+        static Callback[] waitingList = new Callback[InitialSize];
+
+        static int opCount;
+
+        public override void Send(SendOrPostCallback d, object state)
+        {
+            d(state);
+        }
+
+        public override void Post(SendOrPostCallback d, object state)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+
+                if (dequing)
+                {
+                    // Ensure Capacity
+                    if (waitingList.Length == waitingListCount)
+                    {
+                        var newLength = waitingListCount * 2;
+                        if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength;
+
+                        var newArray = new Callback[newLength];
+                        Array.Copy(waitingList, newArray, waitingListCount);
+                        waitingList = newArray;
+                    }
+                    waitingList[waitingListCount] = new Callback(d, state);
+                    waitingListCount++;
+                }
+                else
+                {
+                    // Ensure Capacity
+                    if (actionList.Length == actionListCount)
+                    {
+                        var newLength = actionListCount * 2;
+                        if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength;
+
+                        var newArray = new Callback[newLength];
+                        Array.Copy(actionList, newArray, actionListCount);
+                        actionList = newArray;
+                    }
+                    actionList[actionListCount] = new Callback(d, state);
+                    actionListCount++;
+                }
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        public override void OperationStarted()
+        {
+            Interlocked.Increment(ref opCount);
+        }
+
+        public override void OperationCompleted()
+        {
+            Interlocked.Decrement(ref opCount);
+        }
+
+        public override SynchronizationContext CreateCopy()
+        {
+            return this;
+        }
+
+        // delegate entrypoint.
+        internal static void Run()
+        {
+            {
+                bool lockTaken = false;
+                try
+                {
+                    gate.Enter(ref lockTaken);
+                    if (actionListCount == 0) return;
+                    dequing = true;
+                }
+                finally
+                {
+                    if (lockTaken) gate.Exit(false);
+                }
+            }
+
+            for (int i = 0; i < actionListCount; i++)
+            {
+                var action = actionList[i];
+                actionList[i] = default;
+                action.Invoke();
+            }
+
+            {
+                bool lockTaken = false;
+                try
+                {
+                    gate.Enter(ref lockTaken);
+                    dequing = false;
+
+                    var swapTempActionList = actionList;
+
+                    actionListCount = waitingListCount;
+                    actionList = waitingList;
+
+                    waitingListCount = 0;
+                    waitingList = swapTempActionList;
+                }
+                finally
+                {
+                    if (lockTaken) gate.Exit(false);
+                }
+            }
+        }
+
+        [StructLayout(LayoutKind.Auto)]
+        readonly struct Callback
+        {
+            readonly SendOrPostCallback callback;
+            readonly object state;
+
+            public Callback(SendOrPostCallback callback, object state)
+            {
+                this.callback = callback;
+                this.state = state;
+            }
+
+            public void Invoke()
+            {
+                try
+                {
+                    callback(state);
+                }
+                catch (Exception ex)
+                {
+                    UnityEngine.Debug.LogException(ex);
+                }
+            }
+        }
+    }
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskSynchronizationContext.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: abf3aae9813db2849bce518f8596e920
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,317 @@
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+#if UNITY_2018_4 || UNITY_2019_4_OR_NEWER
+#if UNITASK_ASSETBUNDLE_SUPPORT
+
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static partial class UnityAsyncExtensions
+    {
+        public static AssetBundleRequestAllAssetsAwaiter AwaitForAllAssets(this AssetBundleRequest asyncOperation)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            return new AssetBundleRequestAllAssetsAwaiter(asyncOperation);
+        }
+
+        public static UniTask<UnityEngine.Object[]> AwaitForAllAssets(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object[]>(cancellationToken);
+            if (asyncOperation.isDone) return UniTask.FromResult<UnityEngine.Object[]>(asyncOperation.allAssets);
+            return new UniTask<UnityEngine.Object[]>(AssetBundleRequestAllAssetsWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+        }
+
+        public static UniTask<UnityEngine.Object[]> AwaitForAllAssets(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object[]>(cancellationToken);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.allAssets);
+            return new UniTask<UnityEngine.Object[]>(AssetBundleRequestAllAssetsConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
+        }
+
+        public struct AssetBundleRequestAllAssetsAwaiter : ICriticalNotifyCompletion
+        {
+            AssetBundleRequest asyncOperation;
+            Action<AsyncOperation> continuationAction;
+
+            public AssetBundleRequestAllAssetsAwaiter(AssetBundleRequest asyncOperation)
+            {
+                this.asyncOperation = asyncOperation;
+                this.continuationAction = null;
+            }
+
+            public bool IsCompleted => asyncOperation.isDone;
+
+            public UnityEngine.Object[] GetResult()
+            {
+                if (continuationAction != null)
+                {
+                    asyncOperation.completed -= continuationAction;
+                    continuationAction = null;
+                    var result = asyncOperation.allAssets;
+                    asyncOperation = null;
+                    return result;
+                }
+                else
+                {
+                    var result = asyncOperation.allAssets;
+                    asyncOperation = null;
+                    return result;
+                }
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
+                continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
+                asyncOperation.completed += continuationAction;
+            }
+        }
+
+        sealed class AssetBundleRequestAllAssetsWithCancellationSource : IUniTaskSource<UnityEngine.Object[]>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestAllAssetsWithCancellationSource>
+        {
+            static TaskPool<AssetBundleRequestAllAssetsWithCancellationSource> pool;
+            public AssetBundleRequestAllAssetsWithCancellationSource NextNode { get; set; }
+
+            static AssetBundleRequestAllAssetsWithCancellationSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestAllAssetsWithCancellationSource), () => pool.Size);
+            }
+
+            readonly Action<AsyncOperation> continuationAction;
+            AssetBundleRequest asyncOperation;
+            CancellationToken cancellationToken;
+            bool completed;
+
+            UniTaskCompletionSourceCore<UnityEngine.Object[]> core;
+
+            AssetBundleRequestAllAssetsWithCancellationSource()
+            {
+                continuationAction = Continuation;
+            }
+
+            public static IUniTaskSource<UnityEngine.Object[]> Create(AssetBundleRequest asyncOperation, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<UnityEngine.Object[]>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AssetBundleRequestAllAssetsWithCancellationSource();
+                }
+
+                result.asyncOperation = asyncOperation;
+                result.cancellationToken = cancellationToken;
+                result.completed = false;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
+
+                asyncOperation.completed += result.continuationAction;
+
+                token = result.core.Version;
+                return result;
+            }
+
+            void Continuation(AsyncOperation _)
+            {
+                asyncOperation.completed -= continuationAction;
+
+                if (completed)
+                {
+                    TryReturn();
+                }
+                else
+                {
+                    completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
+                    core.TrySetResult(asyncOperation.allAssets);
+                }
+            }
+
+            public UnityEngine.Object[] GetResult(short token)
+            {
+                return core.GetResult(token);
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (completed)
+                {
+                    TryReturn();
+                    return false;
+                }
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    completed = true;
+                    core.TrySetCanceled(cancellationToken);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                asyncOperation = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+        }
+
+        sealed class AssetBundleRequestAllAssetsConfiguredSource : IUniTaskSource<UnityEngine.Object[]>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestAllAssetsConfiguredSource>
+        {
+            static TaskPool<AssetBundleRequestAllAssetsConfiguredSource> pool;
+            public AssetBundleRequestAllAssetsConfiguredSource NextNode { get; set; }
+
+            static AssetBundleRequestAllAssetsConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestAllAssetsConfiguredSource), () => pool.Size);
+            }
+
+            AssetBundleRequest asyncOperation;
+            IProgress<float> progress;
+            CancellationToken cancellationToken;
+
+            UniTaskCompletionSourceCore<UnityEngine.Object[]> core;
+
+            AssetBundleRequestAllAssetsConfiguredSource()
+            {
+
+            }
+
+            public static IUniTaskSource<UnityEngine.Object[]> Create(AssetBundleRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<UnityEngine.Object[]>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AssetBundleRequestAllAssetsConfiguredSource();
+                }
+
+                result.asyncOperation = asyncOperation;
+                result.progress = progress;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public UnityEngine.Object[] GetResult(short token)
+            {
+                try
+                {
+                    return core.GetResult(token);
+                }
+                finally
+                {
+                    TryReturn();
+                }
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    core.TrySetCanceled(cancellationToken);
+                    return false;
+                }
+
+                if (progress != null)
+                {
+                    progress.Report(asyncOperation.progress);
+                }
+
+                if (asyncOperation.isDone)
+                {
+                    core.TrySetResult(asyncOperation.allAssets);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                asyncOperation = default;
+                progress = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+        }
+    }
+}
+
+#endif
+#endif

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e9147caba40da434da95b39709c13784
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,139 @@
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+using UnityEngine.Rendering;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static partial class UnityAsyncExtensions
+    {
+        #region AsyncGPUReadbackRequest
+
+        public static UniTask<AsyncGPUReadbackRequest>.Awaiter GetAwaiter(this AsyncGPUReadbackRequest asyncOperation)
+        {
+            return ToUniTask(asyncOperation).GetAwaiter();
+        }
+
+        public static UniTask<AsyncGPUReadbackRequest> WithCancellation(this AsyncGPUReadbackRequest asyncOperation, CancellationToken cancellationToken)
+        {
+            return ToUniTask(asyncOperation, cancellationToken: cancellationToken);
+        }
+
+        public static UniTask<AsyncGPUReadbackRequest> ToUniTask(this AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (asyncOperation.done) return UniTask.FromResult(asyncOperation);
+            return new UniTask<AsyncGPUReadbackRequest>(AsyncGPUReadbackRequestAwaiterConfiguredSource.Create(asyncOperation, timing, cancellationToken, out var token), token);
+        }
+
+        sealed class AsyncGPUReadbackRequestAwaiterConfiguredSource : IUniTaskSource<AsyncGPUReadbackRequest>, IPlayerLoopItem, ITaskPoolNode<AsyncGPUReadbackRequestAwaiterConfiguredSource>
+        {
+            static TaskPool<AsyncGPUReadbackRequestAwaiterConfiguredSource> pool;
+            public AsyncGPUReadbackRequestAwaiterConfiguredSource NextNode { get; set; }
+
+            static AsyncGPUReadbackRequestAwaiterConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AsyncGPUReadbackRequestAwaiterConfiguredSource), () => pool.Size);
+            }
+
+            AsyncGPUReadbackRequest asyncOperation;
+            CancellationToken cancellationToken;
+
+            UniTaskCompletionSourceCore<AsyncGPUReadbackRequest> core;
+
+            AsyncGPUReadbackRequestAwaiterConfiguredSource()
+            {
+
+            }
+
+            public static IUniTaskSource<AsyncGPUReadbackRequest> Create(AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<AsyncGPUReadbackRequest>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AsyncGPUReadbackRequestAwaiterConfiguredSource();
+                }
+
+                result.asyncOperation = asyncOperation;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public AsyncGPUReadbackRequest GetResult(short token)
+            {
+                try
+                {
+                    return core.GetResult(token);
+                }
+                finally
+                {
+                    TryReturn();
+                }
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    core.TrySetCanceled(cancellationToken);
+                    return false;
+                }
+
+                if (asyncOperation.hasError)
+                {
+                    core.TrySetException(new Exception("AsyncGPUReadbackRequest.hasError = true"));
+                    return false;
+                }
+
+                if (asyncOperation.done)
+                {
+                    core.TrySetResult(asyncOperation);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                asyncOperation = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 98f5fedb44749ab4688674d79126b46a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -24,6 +24,7 @@ namespace Cysharp.Threading.Tasks
         public static UniTask WithCancellation(this AsyncOperation asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken);
             if (asyncOperation.isDone) return UniTask.CompletedTask;
             return new UniTask(AsyncOperationWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
         }
@@ -31,6 +32,7 @@ namespace Cysharp.Threading.Tasks
         public static UniTask ToUniTask(this AsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken);
             if (asyncOperation.isDone) return UniTask.CompletedTask;
             return new UniTask(AsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
@@ -134,6 +136,12 @@ namespace Cysharp.Threading.Tasks
                 else
                 {
                     completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
                     core.TrySetResult(AsyncUnit.Default);
                 }
             }
@@ -306,6 +314,7 @@ namespace Cysharp.Threading.Tasks
         public static UniTask<UnityEngine.Object> WithCancellation(this ResourceRequest asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
             if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
             return new UniTask<UnityEngine.Object>(ResourceRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
         }
@@ -313,6 +322,7 @@ namespace Cysharp.Threading.Tasks
         public static UniTask<UnityEngine.Object> ToUniTask(this ResourceRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
             if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
             return new UniTask<UnityEngine.Object>(ResourceRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
@@ -420,6 +430,12 @@ namespace Cysharp.Threading.Tasks
                 else
                 {
                     completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
                     core.TrySetResult(asyncOperation.asset);
                 }
             }
@@ -589,6 +605,7 @@ namespace Cysharp.Threading.Tasks
 
         #endregion
 
+#if UNITASK_ASSETBUNDLE_SUPPORT
         #region AssetBundleRequest
 
         public static AssetBundleRequestAwaiter GetAwaiter(this AssetBundleRequest asyncOperation)
@@ -600,6 +617,7 @@ namespace Cysharp.Threading.Tasks
         public static UniTask<UnityEngine.Object> WithCancellation(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
             if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
             return new UniTask<UnityEngine.Object>(AssetBundleRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
         }
@@ -607,6 +625,7 @@ namespace Cysharp.Threading.Tasks
         public static UniTask<UnityEngine.Object> ToUniTask(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
             if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
             return new UniTask<UnityEngine.Object>(AssetBundleRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
@@ -714,6 +733,12 @@ namespace Cysharp.Threading.Tasks
                 else
                 {
                     completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
                     core.TrySetResult(asyncOperation.asset);
                 }
             }
@@ -882,7 +907,9 @@ namespace Cysharp.Threading.Tasks
         }
 
         #endregion
+#endif
 
+#if UNITASK_ASSETBUNDLE_SUPPORT
         #region AssetBundleCreateRequest
 
         public static AssetBundleCreateRequestAwaiter GetAwaiter(this AssetBundleCreateRequest asyncOperation)
@@ -894,6 +921,7 @@ namespace Cysharp.Threading.Tasks
         public static UniTask<AssetBundle> WithCancellation(this AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<AssetBundle>(cancellationToken);
             if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
             return new UniTask<AssetBundle>(AssetBundleCreateRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
         }
@@ -901,6 +929,7 @@ namespace Cysharp.Threading.Tasks
         public static UniTask<AssetBundle> ToUniTask(this AssetBundleCreateRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<AssetBundle>(cancellationToken);
             if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
             return new UniTask<AssetBundle>(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
@@ -1008,6 +1037,12 @@ namespace Cysharp.Threading.Tasks
                 else
                 {
                     completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
                     core.TrySetResult(asyncOperation.assetBundle);
                 }
             }
@@ -1176,6 +1211,7 @@ namespace Cysharp.Threading.Tasks
         }
 
         #endregion
+#endif
 
 #if ENABLE_UNITYWEBREQUEST
         #region UnityWebRequestAsyncOperation
@@ -1189,14 +1225,30 @@ namespace Cysharp.Threading.Tasks
         public static UniTask<UnityWebRequest> WithCancellation(this UnityWebRequestAsyncOperation asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.webRequest);
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityWebRequest>(cancellationToken);
+            if (asyncOperation.isDone)
+            {
+                if (asyncOperation.webRequest.IsError())
+                {
+                    return UniTask.FromException<UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest));
+                }
+                return UniTask.FromResult(asyncOperation.webRequest);
+            }
             return new UniTask<UnityWebRequest>(UnityWebRequestAsyncOperationWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
         }
 
         public static UniTask<UnityWebRequest> ToUniTask(this UnityWebRequestAsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.webRequest);
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityWebRequest>(cancellationToken);
+            if (asyncOperation.isDone)
+            {
+                if (asyncOperation.webRequest.IsError())
+                {
+                    return UniTask.FromException<UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest));
+                }
+                return UniTask.FromResult(asyncOperation.webRequest);
+            }
             return new UniTask<UnityWebRequest>(UnityWebRequestAsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
 
@@ -1221,7 +1273,7 @@ namespace Cysharp.Threading.Tasks
                     continuationAction = null;
                     var result = asyncOperation.webRequest;
                     asyncOperation = null;
-                    if (result.isHttpError || result.isNetworkError)
+                    if (result.IsError())
                     {
                         throw new UnityWebRequestException(result);
                     }
@@ -1231,7 +1283,7 @@ namespace Cysharp.Threading.Tasks
                 {
                     var result = asyncOperation.webRequest;
                     asyncOperation = null;
-                    if (result.isHttpError || result.isNetworkError)
+                    if (result.IsError())
                     {
                         throw new UnityWebRequestException(result);
                     }
@@ -1311,8 +1363,14 @@ namespace Cysharp.Threading.Tasks
                 else
                 {
                     completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
                     var result = asyncOperation.webRequest;
-                    if (result.isHttpError || result.isNetworkError)
+                    if (result.IsError())
                     {
                         core.TrySetException(new UnityWebRequestException(result));
                     }
@@ -1470,7 +1528,7 @@ namespace Cysharp.Threading.Tasks
 
                 if (asyncOperation.isDone)
                 {
-                    if (asyncOperation.webRequest.isHttpError || asyncOperation.webRequest.isNetworkError)
+                    if (asyncOperation.webRequest.IsError())
                     {
                         core.TrySetException(new UnityWebRequestException(asyncOperation.webRequest));
                     }

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

@@ -16,6 +16,8 @@
 
     Func<string, string> ToUniTaskReturnType = x => (x == "void") ? "UniTask" : $"UniTask<{x}>";
     Func<string, string> ToIUniTaskSourceReturnType = x => (x == "void") ? "IUniTaskSource" : $"IUniTaskSource<{x}>";
+    Func<(string typeName, string returnType, string returnField), bool> IsUnityWebRequest = x => x.returnType == "UnityWebRequest";
+    Func<(string typeName, string returnType, string returnField), bool> IsAssetBundleModule = x => x.typeName == "AssetBundleRequest" || x.typeName == "AssetBundleCreateRequest";
     Func<(string typeName, string returnType, string returnField), bool> IsVoid = x => x.returnType == "void";
 #>
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
@@ -34,8 +36,10 @@ namespace Cysharp.Threading.Tasks
     public static partial class UnityAsyncExtensions
     {
 <# foreach(var t in types) { #>
-<# if(t.returnType == "UnityWebRequest") { #>
+<# if(IsUnityWebRequest(t)) { #>
 #if ENABLE_UNITYWEBREQUEST
+<# } else if(IsAssetBundleModule(t)) { #>
+#if UNITASK_ASSETBUNDLE_SUPPORT
 <# } #>
         #region <#= t.typeName #>
 
@@ -48,14 +52,38 @@ namespace Cysharp.Threading.Tasks
         public static <#= ToUniTaskReturnType(t.returnType) #> WithCancellation(this <#= t.typeName #> asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<#= IsVoid(t) ? "" : "<" + t.returnType + ">" #>(cancellationToken);
+<# if(IsUnityWebRequest(t)) { #>
+            if (asyncOperation.isDone)
+            {
+                if (asyncOperation.webRequest.IsError())
+                {
+                    return UniTask.FromException<UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest));
+                }
+                return UniTask.FromResult(asyncOperation.webRequest);
+            }
+<# } else { #>
             if (asyncOperation.isDone) return <#= IsVoid(t) ? "UniTask.CompletedTask" : $"UniTask.FromResult(asyncOperation.{t.returnField})" #>;
+<# } #>
             return new <#= ToUniTaskReturnType(t.returnType) #>(<#= t.typeName #>WithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
         }
 
         public static <#= ToUniTaskReturnType(t.returnType) #> ToUniTask(this <#= t.typeName #> asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<#= IsVoid(t) ? "" : "<" + t.returnType + ">" #>(cancellationToken);
+<# if(IsUnityWebRequest(t)) { #>
+            if (asyncOperation.isDone)
+            {
+                if (asyncOperation.webRequest.IsError())
+                {
+                    return UniTask.FromException<UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest));
+                }
+                return UniTask.FromResult(asyncOperation.webRequest);
+            }
+<# } else { #>
             if (asyncOperation.isDone) return <#= IsVoid(t) ? "UniTask.CompletedTask" : $"UniTask.FromResult(asyncOperation.{t.returnField})" #>;
+<# } #>
             return new <#= ToUniTaskReturnType(t.returnType) #>(<#= t.typeName #>ConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
 
@@ -81,8 +109,8 @@ namespace Cysharp.Threading.Tasks
 <# if (!IsVoid(t)) { #>
                     var result = <#= $"asyncOperation.{t.returnField}" #>;
                     asyncOperation = null;
-<# if(t.returnType == "UnityWebRequest") { #>
-                    if (result.isHttpError || result.isNetworkError)
+<# if(IsUnityWebRequest(t)) { #>
+                    if (result.IsError())
                     {
                         throw new UnityWebRequestException(result);
                     }
@@ -97,8 +125,8 @@ namespace Cysharp.Threading.Tasks
 <# if (!IsVoid(t)) { #>
                     var result = <#= $"asyncOperation.{t.returnField}" #>;
                     asyncOperation = null;
-<# if(t.returnType == "UnityWebRequest") { #>
-                    if (result.isHttpError || result.isNetworkError)
+<# if(IsUnityWebRequest(t)) { #>
+                    if (result.IsError())
                     {
                         throw new UnityWebRequestException(result);
                     }
@@ -182,9 +210,15 @@ namespace Cysharp.Threading.Tasks
                 else
                 {
                     completed = true;
-<# if(t.returnType == "UnityWebRequest") { #>
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
+<# if(IsUnityWebRequest(t)) { #>
                     var result = asyncOperation.webRequest;
-                    if (result.isHttpError || result.isNetworkError)
+                    if (result.IsError())
                     {
                         core.TrySetException(new UnityWebRequestException(result));
                     }
@@ -240,7 +274,7 @@ namespace Cysharp.Threading.Tasks
                 if (cancellationToken.IsCancellationRequested)
                 {
                     completed = true;
-<# if(t.returnType == "UnityWebRequest") { #>
+<# if(IsUnityWebRequest(t)) { #>
                     asyncOperation.webRequest.Abort();
 <# } #>
                     core.TrySetCanceled(cancellationToken);
@@ -347,7 +381,7 @@ namespace Cysharp.Threading.Tasks
             {
                 if (cancellationToken.IsCancellationRequested)
                 {
-<# if(t.returnType == "UnityWebRequest") { #>
+<# if(IsUnityWebRequest(t)) { #>
                     asyncOperation.webRequest.Abort();
 <# } #>
                     core.TrySetCanceled(cancellationToken);
@@ -361,8 +395,8 @@ namespace Cysharp.Threading.Tasks
 
                 if (asyncOperation.isDone)
                 {
-<# if(t.returnType == "UnityWebRequest") { #>
-                    if (asyncOperation.webRequest.isHttpError || asyncOperation.webRequest.isNetworkError)
+<# if(IsUnityWebRequest(t)) { #>
+                    if (asyncOperation.webRequest.IsError())
                     {
                         core.TrySetException(new UnityWebRequestException(asyncOperation.webRequest));
                     }
@@ -391,7 +425,7 @@ namespace Cysharp.Threading.Tasks
         }
 
         #endregion
-<# if(t.returnType == "UnityWebRequest") { #>
+<# if(IsUnityWebRequest(t) || IsAssetBundleModule(t)) { #>
 #endif
 <# } #>
 

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

@@ -296,6 +296,58 @@ namespace Cysharp.Threading.Tasks
         UniTask<T> OnEndEditAsync();
     }
 
+    // for TMP_PRO
+
+    public interface IAsyncEndTextSelectionEventHandler<T> : IDisposable
+    {
+        UniTask<T> OnEndTextSelectionAsync();
+    }
+
+    public interface IAsyncTextSelectionEventHandler<T> : IDisposable
+    {
+        UniTask<T> OnTextSelectionAsync();
+    }
+
+    public interface IAsyncDeselectEventHandler<T> : IDisposable
+    {
+        UniTask<T> OnDeselectAsync();
+    }
+
+    public interface IAsyncSelectEventHandler<T> : IDisposable
+    {
+        UniTask<T> OnSelectAsync();
+    }
+
+    public interface IAsyncSubmitEventHandler<T> : IDisposable
+    {
+        UniTask<T> OnSubmitAsync();
+    }
+
+    internal class TextSelectionEventConverter : UnityEvent<(string, int, int)>, IDisposable
+    {
+        readonly UnityEvent<string, int, int> innerEvent;
+        readonly UnityAction<string, int, int> invokeDelegate;
+
+
+        public TextSelectionEventConverter(UnityEvent<string, int, int> unityEvent)
+        {
+            this.innerEvent = unityEvent;
+            this.invokeDelegate = InvokeCore;
+
+            innerEvent.AddListener(invokeDelegate);
+        }
+
+        void InvokeCore(string item1, int item2, int item3)
+        {
+            innerEvent.Invoke(item1, item2, item3);
+        }
+
+        public void Dispose()
+        {
+            innerEvent.RemoveListener(invokeDelegate);
+        }
+    }
+
     public class AsyncUnityEventHandler : IUniTaskSource, IDisposable, IAsyncClickEventHandler
     {
         static Action<object> cancellationCallback = CancellationCallback;
@@ -402,6 +454,7 @@ namespace Cysharp.Threading.Tasks
     }
 
     public class AsyncUnityEventHandler<T> : IUniTaskSource<T>, IDisposable, IAsyncValueChangedEventHandler<T>, IAsyncEndEditEventHandler<T>
+        , IAsyncEndTextSelectionEventHandler<T>, IAsyncTextSelectionEventHandler<T>, IAsyncDeselectEventHandler<T>, IAsyncSelectEventHandler<T>, IAsyncSubmitEventHandler<T>
     {
         static Action<object> cancellationCallback = CancellationCallback;
 
@@ -464,6 +517,12 @@ namespace Cysharp.Threading.Tasks
                 registration.Dispose();
                 if (unityEvent != null)
                 {
+                    // Dispose inner delegate for TextSelectionEventConverter
+                    if (unityEvent is IDisposable disp)
+                    {
+                        disp.Dispose();
+                    }
+
                     unityEvent.RemoveListener(action);
                 }
 
@@ -481,6 +540,31 @@ namespace Cysharp.Threading.Tasks
             return OnInvokeAsync();
         }
 
+        UniTask<T> IAsyncEndTextSelectionEventHandler<T>.OnEndTextSelectionAsync()
+        {
+            return OnInvokeAsync();
+        }
+
+        UniTask<T> IAsyncTextSelectionEventHandler<T>.OnTextSelectionAsync()
+        {
+            return OnInvokeAsync();
+        }
+
+        UniTask<T> IAsyncDeselectEventHandler<T>.OnDeselectAsync()
+        {
+            return OnInvokeAsync();
+        }
+
+        UniTask<T> IAsyncSelectEventHandler<T>.OnSelectAsync()
+        {
+            return OnInvokeAsync();
+        }
+
+        UniTask<T> IAsyncSubmitEventHandler<T>.OnSubmitAsync()
+        {
+            return OnInvokeAsync();
+        }
+
         T IUniTaskSource<T>.GetResult(short token)
         {
             try
@@ -718,6 +802,10 @@ namespace Cysharp.Threading.Tasks
                     TaskTracker.RemoveTracking(this);
                     registration1.Dispose();
                     registration2.Dispose();
+                    if (unityEvent is IDisposable disp)
+                    {
+                        disp.Dispose();
+                    }
                     unityEvent.RemoveListener(unityAction);
                 }
 

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

@@ -237,65 +237,5 @@ namespace Cysharp.Threading.Tasks
                 }
             }
         }
-
-        // TMP
-
-#if UNITASK_TEXTMESHPRO_SUPPORT
-
-        public static void BindTo(this IUniTaskAsyncEnumerable<string> source, TMPro.TMP_Text text, bool rebindOnError = true)
-        {
-            BindToCore(source, text, text.GetCancellationTokenOnDestroy(), rebindOnError).Forget();
-        }
-
-        public static void BindTo(this IUniTaskAsyncEnumerable<string> source, TMPro.TMP_Text text, CancellationToken cancellationToken, bool rebindOnError = true)
-        {
-            BindToCore(source, text, cancellationToken, rebindOnError).Forget();
-        }
-
-        static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable<string> source, TMPro.TMP_Text text, CancellationToken cancellationToken, bool rebindOnError)
-        {
-            var repeat = false;
-            BIND_AGAIN:
-            var e = source.GetAsyncEnumerator(cancellationToken);
-            try
-            {
-                while (true)
-                {
-                    bool moveNext;
-                    try
-                    {
-                        moveNext = await e.MoveNextAsync();
-                        repeat = false;
-                    }
-                    catch (Exception ex)
-                    {
-                        if (ex is OperationCanceledException) return;
-
-                        if (rebindOnError && !repeat)
-                        {
-                            repeat = true;
-                            goto BIND_AGAIN;
-                        }
-                        else
-                        {
-                            throw;
-                        }
-                    }
-
-                    if (!moveNext) return;
-
-                    text.text = e.Current;
-                }
-            }
-            finally
-            {
-                if (e != null)
-                {
-                    await e.DisposeAsync();
-                }
-            }
-        }
-
-#endif
     }
 }

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

@@ -1,24 +0,0 @@
-#if ENABLE_UNITYWEBREQUEST
-
-using System;
-using UnityEngine.Networking;
-
-namespace Cysharp.Threading.Tasks
-{
-    public class UnityWebRequestException : Exception
-    {
-        public UnityWebRequest UnityWebRequest { get; }
-        public bool IsNetworkError { get; }
-        public bool IsHttpError { get; }
-
-        public UnityWebRequestException(UnityWebRequest unityWebRequest)
-            : base(unityWebRequest.error + Environment.NewLine + unityWebRequest.downloadHandler.text)
-        {
-            this.UnityWebRequest = unityWebRequest;
-            this.IsNetworkError = unityWebRequest.isNetworkError;
-            this.IsHttpError = unityWebRequest.isHttpError;
-        }
-    }
-}
-
-#endif

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

@@ -0,0 +1,64 @@
+#if ENABLE_UNITYWEBREQUEST
+
+using System;
+using UnityEngine.Networking;
+
+namespace Cysharp.Threading.Tasks
+{
+    public class UnityWebRequestException : Exception
+    {
+        public UnityWebRequest UnityWebRequest { get; }
+#if UNITY_2020_2_OR_NEWER
+        public UnityWebRequest.Result Result { get; }
+#else
+        public bool IsNetworkError { get; }
+        public bool IsHttpError { get; }
+#endif
+        public string Error { get; }
+        public string Text { get; }
+        public long ResponseCode { get; }
+
+        string msg;
+
+        public UnityWebRequestException(UnityWebRequest unityWebRequest)
+        {
+            this.UnityWebRequest = unityWebRequest;
+#if UNITY_2020_2_OR_NEWER
+            this.Result = unityWebRequest.result;
+#else
+            this.IsNetworkError = unityWebRequest.isNetworkError;
+            this.IsHttpError = unityWebRequest.isHttpError;
+#endif
+            this.Error = unityWebRequest.error;
+            this.ResponseCode = unityWebRequest.responseCode;
+            if (UnityWebRequest.downloadHandler != null)
+            {
+                if (unityWebRequest.downloadHandler is DownloadHandlerBuffer dhb)
+                {
+                    this.Text = dhb.text;
+                }
+            }
+        }
+
+        public override string Message
+        {
+            get
+            {
+                if (msg == null)
+                {
+                    if (Text != null)
+                    {
+                        msg = Error + Environment.NewLine + Text;
+                    }
+                    else
+                    {
+                        msg = Error;
+                    }
+                }
+                return msg;
+            }
+        }
+    }
+}
+
+#endif

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

@@ -1,3 +1,6 @@
 using System.Runtime.CompilerServices;
 
-[assembly: InternalsVisibleTo("UniTask.Linq")]
+[assembly: InternalsVisibleTo("UniTask.Linq")]
+[assembly: InternalsVisibleTo("UniTask.Addressables")]
+[assembly: InternalsVisibleTo("UniTask.DOTween")]
+[assembly: InternalsVisibleTo("UniTask.TextMeshPro")]

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

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

src/UniTask/Assets/Scenes/ExceptionExamples.cs

@@ -1,28 +1,52 @@
-using System;
-using System.Threading.Tasks;
-using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks;
+using System;
+using System.Collections.Generic;
 using UnityEngine;
-using UnityEngine.Networking;
 
+/*UNniTastWhenAnyTester*/
+
+[ExecuteInEditMode]
 public class ExceptionExamples : MonoBehaviour
 {
-    
-    private void Start()
+    public bool apply = false;
+
+    private async UniTaskVoid Update()
     {
-
-        //TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
-
-        //ThrowFromAsyncVoid();
-        //_ = ThrowFromTask();
-        //_ = ThrowFromUniTask();
-        
-        //ThrowFromNonAsync();
+        if (apply)
+        {
+            apply = false;
+            await LaunchTasksAndDetectWhenAnyDone(5);
+        }
     }
 
-    public static async Task Test()
+    private async UniTask LaunchTasksAndDetectWhenAnyDone(int nbTasks)
     {
-        var webRequest = UnityWebRequest.Get("http");
-        var request = webRequest.SendWebRequest();
-        await request;
+        List<UniTask<int>> sleeptasks = new List<UniTask<int>>();
+        for (int i = 0; i < nbTasks; i++)
+        {
+            sleeptasks.Add(SleepAndReturnTrue(i).ToAsyncLazy().Task);
+        }
+        while (sleeptasks.Count > 0)
+        {
+            Debug.Log(DateTime.Now.ToString() + " waiting for " + sleeptasks.Count + " tasks...");
+            try
+            {
+                (int index, int taskID) = await UniTask.WhenAny(sleeptasks);
+                Debug.Log(DateTime.Now.ToString() + " Sleep task " + taskID + " done");
+                sleeptasks.RemoveAt(index);
+            }
+            catch
+            {
+                throw;
+                //Debug.Log("Error: " + e.Message);
+                //return;
+            }
+        }
+    }
+
+    private async UniTask<int> SleepAndReturnTrue(int taskIndex)
+    {
+        await UniTask.Delay(100);
+        return taskIndex;
     }
 }

src/UniTask/Assets/Scenes/ExceptionExamples.unity

@@ -121,6 +121,149 @@ NavMeshSettings:
     debug:
       m_Flags: 0
   m_NavMeshData: {fileID: 0}
+--- !u!1 &542336983
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 542336986}
+  - component: {fileID: 542336985}
+  - component: {fileID: 542336984}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &542336984
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 542336983}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4f231c4fb786f3946a6b90b886c48677, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_HorizontalAxis: Horizontal
+  m_VerticalAxis: Vertical
+  m_SubmitButton: Submit
+  m_CancelButton: Cancel
+  m_InputActionsPerSecond: 10
+  m_RepeatDelay: 0.5
+  m_ForceModuleActive: 0
+--- !u!114 &542336985
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 542336983}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_FirstSelected: {fileID: 0}
+  m_sendNavigationEvents: 1
+  m_DragThreshold: 10
+--- !u!4 &542336986
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 542336983}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &730559310
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 730559311}
+  - component: {fileID: 730559313}
+  - component: {fileID: 730559312}
+  m_Layer: 5
+  m_Name: Text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &730559311
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 730559310}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1587363385}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &730559312
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 730559310}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 14
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 4
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: Button
+--- !u!222 &730559313
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 730559310}
+  m_CullTransparentMesh: 0
 --- !u!1 &735985614
 GameObject:
   m_ObjectHideFlags: 0
@@ -152,7 +295,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 329ff620b32b4ef4abdc99884242ee67, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  _unobservedExceptionLogType: 0
+  ButtonTest: {fileID: 1587363386}
 --- !u!81 &735985616
 AudioListener:
   m_ObjectHideFlags: 0
@@ -214,7 +357,225 @@ Transform:
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
   m_LocalPosition: {x: 0, y: 0, z: -10}
   m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
+  m_Children:
+  - {fileID: 1323586517}
   m_Father: {fileID: 0}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1323586516
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1323586517}
+  - component: {fileID: 1323586520}
+  - component: {fileID: 1323586519}
+  - component: {fileID: 1323586518}
+  m_Layer: 5
+  m_Name: Canvas
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1323586517
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1323586516}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_Children:
+  - {fileID: 1587363385}
+  m_Father: {fileID: 735985618}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}
+--- !u!114 &1323586518
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1323586516}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &1323586519
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1323586516}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 0
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 3
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!223 &1323586520
+Canvas:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1323586516}
+  m_Enabled: 1
+  serializedVersion: 3
+  m_RenderMode: 0
+  m_Camera: {fileID: 0}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_AdditionalShaderChannelsFlag: 0
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+--- !u!1 &1587363384
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1587363385}
+  - component: {fileID: 1587363388}
+  - component: {fileID: 1587363387}
+  - component: {fileID: 1587363386}
+  m_Layer: 5
+  m_Name: Button
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1587363385
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1587363384}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 730559311}
+  m_Father: {fileID: 1323586517}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 160, y: 30}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1587363386
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1587363384}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_SelectedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_SelectedTrigger: Selected
+    m_DisabledTrigger: Disabled
+  m_Interactable: 1
+  m_TargetGraphic: {fileID: 1587363387}
+  m_OnClick:
+    m_PersistentCalls:
+      m_Calls: []
+--- !u!114 &1587363387
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1587363384}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+  m_UseSpriteMesh: 0
+  m_PixelsPerUnitMultiplier: 1
+--- !u!222 &1587363388
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1587363384}
+  m_CullTransparentMesh: 0

src/UniTask/Assets/Scenes/SandboxMain.cs

@@ -15,6 +15,8 @@ using UnityEngine.LowLevel;
 using UnityEngine.Networking;
 using UnityEngine.UI;
 using UnityEngine.SceneManagement;
+using UnityEngine.Rendering;
+using System.IO;
 
 
 // using DG.Tweening;
@@ -117,6 +119,8 @@ public class AsyncMessageBroker<T> : IDisposable
 
 public class SandboxMain : MonoBehaviour
 {
+    public Camera mycamera;
+
     public Button okButton;
     public Button cancelButton;
 
@@ -129,6 +133,7 @@ public class SandboxMain : MonoBehaviour
     UniTaskCompletionSource ucs;
     async UniTask<int> FooAsync()
     {
+
         // use F10, will crash.
         var loop = int.Parse("9");
         await UniTask.DelayFrame(loop);
@@ -161,6 +166,9 @@ public class SandboxMain : MonoBehaviour
 
 
 
+
+
+
             //setHp = Hp.GetSetter();
         }
 
@@ -178,15 +186,14 @@ public class SandboxMain : MonoBehaviour
     public Button button;
 
 
-    void Start2()
-    {
-
-    }
 
 
 
     async UniTask RunStandardDelayAsync()
     {
+
+
+
         UnityEngine.Debug.Log("DEB");
 
         await UniTask.DelayFrame(30);
@@ -217,6 +224,11 @@ public class SandboxMain : MonoBehaviour
     async UniTaskVoid Update2()
     {
 
+
+
+
+
+
         UnityEngine.Debug.Log("async linq!");
 
         await UniTaskAsyncEnumerable.Range(1, 10)
@@ -435,12 +447,59 @@ public class SandboxMain : MonoBehaviour
     }
 
 
-    void Start()
-    {
-        _ = Foo(); // unhandled.
-        Go();
 
-        UnityEngine.Debug.Log("Start:" + PlayerLoopInfo.CurrentLoopType);
+
+    async void Nanika()
+    {
+        await UniTask.Yield();
+        Debug.Log("Here");
+        throw new Exception();
+    }
+
+
+
+
+
+
+
+    private void Awake()
+    {
+        // PlayerLoopInfo.Inject();
+        PrepareCamera();
+    }
+
+    public IUniTaskAsyncEnumerable<int> MyEveryUpdate()
+    {
+        return UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
+        {
+            var frameCount = 0;
+            await UniTask.Yield();
+            while (!token.IsCancellationRequested)
+            {
+                await writer.YieldAsync(frameCount++); // instead of `yield return`
+                await UniTask.Yield();
+            }
+        });
+    }
+
+    async void RunStandardTaskAsync()
+    {
+        Debug.Log("Wait 3 seconds");
+        await Task.Delay(TimeSpan.FromSeconds(3));
+
+        Debug.Log("Current SyncContext:" + SynchronizationContext.Current.GetType().FullName);
+    }
+
+
+    async UniTaskVoid Start()
+    {
+        RunStandardTaskAsync();
+
+        UnityEngine.Debug.Log("UniTaskPlayerLoop ready? " + PlayerLoopHelper.IsInjectedUniTaskPlayerLoop());
+
+        //var url =  "http://google.com/404";
+        //var webRequestAsyncOperation = UnityWebRequest.Get(url).SendWebRequest();
+        //await webRequestAsyncOperation.ToUniTask();
 
         //PlayerLoopInfo.Inject();
 
@@ -458,7 +517,11 @@ public class SandboxMain : MonoBehaviour
         //var cts = new CancellationTokenSource();
 
 
+        // UniTask.Post(
 
+        // CancellationToken.
+
+        //UniTask.Delay(TimeSpan.FromSeconds(3)).
 
 
         //okButton.onClick.AddListener(UniTask.UnityAction(async () =>
@@ -643,7 +706,9 @@ public class SandboxMain : MonoBehaviour
 
         //StartCoroutine(Coroutine());
 
-        //await UniTask.Delay(TimeSpan.FromSeconds(1));
+        // PlayerLoopInfo.Inject();
+        await UniTask.Delay(TimeSpan.FromSeconds(1));
+        PlayerLoopInfo.DumpPlayerLoop("current", PlayerLoop.GetCurrentPlayerLoop());
 
 
         // _ = ReturnToMainThreadTest();
@@ -950,9 +1015,76 @@ public class SandboxMain : MonoBehaviour
         // e.SetObserved();
         // or other custom write code.
         UnityEngine.Debug.LogError("Unobserved:" + e.Exception.ToString());
+    }
+
+
+    // GPU Screenshot Sample
+
+    void PrepareCamera()
+    {
+        //Debug.Log("Support AsyncGPUReadback:" + SystemInfo.supportsAsyncGPUReadback);
+
+        //var width = 480;
+        //var height = 240;
+        //var depth = 24;
+
+        //mycamera.targetTexture = new RenderTexture(width, height, depth, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default)
+        //{
+        //    antiAliasing = 8
+        //};
+        //mycamera.enabled = true;
+
+        //myRenderTexture = new RenderTexture(width, height, depth, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default)
+        //{
+        //    antiAliasing = 8
+        //};
+    }
+
+    RenderTexture myRenderTexture;
+
+    async UniTask ShootAsync()
+    {
+        var rt = mycamera.targetTexture;
+
+
+
+        var req = await AsyncGPUReadback.Request(rt, 0);
+
+        Debug.Log("GPU Readback done?:" + req.done);
+
+        var rawByteArray = req.GetData<byte>().ToArray();
+        var graphicsFormat = rt.graphicsFormat;
+        var width = (uint)rt.width;
+        var height = (uint)rt.height;
+
+        Debug.Log("BytesSize:" + rawByteArray.Length);
+
+
+        var imageBytes = ImageConversion.EncodeArrayToPNG(rawByteArray, graphicsFormat, width, height);
+
+
+        File.WriteAllBytes("my_screenshot.png", imageBytes); // test
+
+
+
+
+
+
+
     }
 }
 
+
+public class SyncContextInjecter
+{
+    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+    public static void Inject()
+    {
+        SynchronizationContext.SetSynchronizationContext(new UniTaskSynchronizationContext());
+    }
+}
+
+
 public class PlayerLoopInfo
 {
     // [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
@@ -987,7 +1119,7 @@ public class PlayerLoopInfo
 
     public static Type CurrentLoopType { get; private set; }
 
-    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+    // [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
     public static void Inject()
     {
         var system = PlayerLoop.GetCurrentPlayerLoop();

src/UniTask/Assets/Scenes/SandboxMain.unity

@@ -239,6 +239,80 @@ CanvasRenderer:
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 16537670}
   m_CullTransparentMesh: 0
+--- !u!1 &518730348
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 518730350}
+  - component: {fileID: 518730349}
+  m_Layer: 0
+  m_Name: Camera
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!20 &518730349
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 518730348}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &518730350
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 518730348}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 488, y: 418, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &519420028
 GameObject:
   m_ObjectHideFlags: 0
@@ -278,9 +352,11 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: f0bc6c75abb2e0b47a25aa49bfd488ed, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
+  camera: {fileID: 518730349}
   okButton: {fileID: 16537672}
   cancelButton: {fileID: 628393011}
   text: {fileID: 2101290655}
+  button: {fileID: 0}
 --- !u!20 &519420031
 Camera:
   m_ObjectHideFlags: 0
@@ -597,7 +673,7 @@ Transform:
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 1
+  m_RootOrder: 2
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1556045504
 GameObject:
@@ -693,7 +769,7 @@ RectTransform:
   - {fileID: 628393010}
   - {fileID: 2101290654}
   m_Father: {fileID: 0}
-  m_RootOrder: 2
+  m_RootOrder: 3
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 0}
   m_AnchorMax: {x: 0, y: 0}

src/UniTask/Assets/TempAsm.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 56fb2352cb532934f82d1590ce377e5c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/TempAsm/FooMonoBehaviour.cs

@@ -0,0 +1,27 @@
+using Cysharp.Threading.Tasks;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Networking;
+
+public class FooMonoBehaviour : MonoBehaviour
+{
+    // Start is called before the first frame update
+    void Start()
+    {
+
+    }
+
+    private async UniTask Download(UnityWebRequest req, string filePath)
+    {
+        var foo = req.SendWebRequest();
+
+
+        
+
+        var aaa = await foo;
+        Debug.Log(aaa);
+
+        //File.WriteAllText(filePath, req.downloadHandler.text ?? string.Empty);
+    }
+}

src/UniTask/Assets/TempAsm/FooMonoBehaviour.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: de703bd72a8720b47b7c3d993786aaae
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/TempAsm/TempAsm.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "TempAsm",
+    "references": [
+        "UniTask",
+        ""
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

src/UniTask/Assets/TempAsm/TempAsm.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d076e9cb44bf59e41ab73add08e510cf
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Tests/CoroutineToUniTaskTest.cs

@@ -0,0 +1,126 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine.UI;
+using UnityEngine.Scripting;
+using Cysharp.Threading.Tasks;
+using Unity.Collections;
+using System.Threading;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+using FluentAssertions;
+
+namespace Cysharp.Threading.TasksTests
+{
+    public class CoroutineToUniTaskTest
+    {
+        [UnityTest]
+        public IEnumerator EarlyUpdate() => UniTask.ToCoroutine(async () =>
+        {
+            await UniTask.Yield(PlayerLoopTiming.EarlyUpdate);
+
+            var l = new List<(int, int)>();
+            var currentFrame = Time.frameCount;
+            var t = Worker(l).ToUniTask();
+
+            l.Count.Should().Be(1);
+            l[0].Should().Be((0, currentFrame));
+
+            await t;
+
+            l[1].Should().Be((1, Time.frameCount));
+            l[1].Item2.Should().NotBe(currentFrame);
+        });
+
+        [UnityTest]
+        public IEnumerator LateUpdate() => UniTask.ToCoroutine(async () =>
+        {
+            await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+
+            var l = new List<(int, int)>();
+            var currentFrame = Time.frameCount;
+            var t = Worker(l).ToUniTask();
+
+            l.Count.Should().Be(1);
+            l[0].Should().Be((0, currentFrame));
+
+            await t;
+
+            l[1].Should().Be((1, Time.frameCount));
+            l[1].Item2.Should().NotBe(currentFrame);
+        });
+
+        //[UnityTest]
+        //public IEnumerator TestCoroutine()
+        //{
+        //    yield return UniTask.Yield(PlayerLoopTiming.EarlyUpdate).ToUniTask().ToCoroutine();
+
+        //    var nanika = (UnityEngine.MonoBehaviour)GameObject.FindObjectOfType(typeof(UnityEngine.MonoBehaviour));
+
+        //    var l = new List<(int, int)>();
+        //    var currentFrame = Time.frameCount;
+        //    var t = nanika.StartCoroutine(Worker(l));
+
+        //    l.Count.Should().Be(1);
+        //    l[0].Should().Be((0, currentFrame));
+
+        //    yield return t;
+
+        //    l[1].Should().Be((1, Time.frameCount));
+        //    l[1].Item2.Should().NotBe(currentFrame);
+        //}
+
+        //[UnityTest]
+        //public IEnumerator TestCoroutine2()
+        //{
+        //    yield return UniTask.Yield(PlayerLoopTiming.PostLateUpdate).ToUniTask().ToCoroutine();
+
+        //    var nanika = (UnityEngine.MonoBehaviour)GameObject.FindObjectOfType(typeof(UnityEngine.MonoBehaviour));
+
+        //    var l = new List<(int, int)>();
+        //    var currentFrame = Time.frameCount;
+        //    var t = nanika.StartCoroutine(Worker(l));
+
+        //    l.Count.Should().Be(1);
+        //    l[0].Should().Be((0, currentFrame));
+
+        //    yield return t;
+
+        //    l[1].Should().Be((1, Time.frameCount));
+        //    l[1].Item2.Should().NotBe(currentFrame);
+        //}
+
+        IEnumerator Worker(List<(int, int)> l)
+        {
+            l.Add((0, Time.frameCount));
+            yield return null;
+            l.Add((1, Time.frameCount));
+        }
+
+        public async UniTask Foo()
+        {
+            var tasks = new List<UniTask>();
+            var t = Bar<int>();
+            tasks.Add(t);
+
+            t = Bar<int>();
+            tasks.Add(t);
+
+            await UniTask.WhenAll(tasks);
+        }
+
+        public async UniTask<T> Bar<T>()
+        {
+            await UniTask.Yield();
+            return default(T);
+        }
+    }
+}
+
+#endif

src/UniTask/Assets/Tests/CoroutineToUniTaskTest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 43ffb719370515746932af3732ce073e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Tests/DelayTest.cs

@@ -16,164 +16,164 @@ namespace Cysharp.Threading.TasksTests
 {
     public class DelayTest
     {
-        //[UnityTest]
-        //public IEnumerator DelayFrame() => UniTask.ToCoroutine(async () =>
-        //{
-        //    for (int i = 1; i < 5; i++)
-        //    {
-        //        await UniTask.Yield(PlayerLoopTiming.PreUpdate);
-        //        var frameCount = Time.frameCount;
-        //        await UniTask.DelayFrame(i);
-        //        Time.frameCount.Should().Be(frameCount + i);
-        //    }
+        [UnityTest]
+        public IEnumerator DelayFrame() => UniTask.ToCoroutine(async () =>
+        {
+            for (int i = 1; i < 5; i++)
+            {
+                await UniTask.Yield(PlayerLoopTiming.PreUpdate);
+                var frameCount = Time.frameCount;
+                await UniTask.DelayFrame(i);
+                Time.frameCount.Should().Be(frameCount + i);
+            }
 
-        //    for (int i = 1; i < 5; i++)
-        //    {
-        //        await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
-        //        var frameCount = Time.frameCount;
-        //        await UniTask.DelayFrame(i);
-        //        Time.frameCount.Should().Be(frameCount + i);
-        //    }
-        //});
+            for (int i = 1; i < 5; i++)
+            {
+                await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+                var frameCount = Time.frameCount;
+                await UniTask.DelayFrame(i);
+                Time.frameCount.Should().Be(frameCount + i);
+            }
+        });
 
-        //[UnityTest]
-        //public IEnumerator DelayFrameZero() => UniTask.ToCoroutine(async () =>
-        //{
-        //    {
-        //        await UniTask.Yield(PlayerLoopTiming.PreUpdate);
-        //        var frameCount = Time.frameCount;
-        //        await UniTask.DelayFrame(0);
-        //        Time.frameCount.Should().Be(frameCount); // same frame
-        //    }
-        //    {
-        //        await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
-        //        var frameCount = Time.frameCount;
-        //        await UniTask.DelayFrame(0);
-        //        Time.frameCount.Should().Be(frameCount + 1); // next frame
-        //    }
-        //});
+        [UnityTest]
+        public IEnumerator DelayFrameZero() => UniTask.ToCoroutine(async () =>
+        {
+            {
+                await UniTask.Yield(PlayerLoopTiming.PreUpdate);
+                var frameCount = Time.frameCount;
+                await UniTask.DelayFrame(0);
+                Time.frameCount.Should().Be(frameCount); // same frame
+            }
+            {
+                await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+                var frameCount = Time.frameCount;
+                await UniTask.DelayFrame(0);
+                Time.frameCount.Should().Be(frameCount + 1); // next frame
+            }
+        });
 
 
 
-        //[UnityTest]
-        //public IEnumerator TimerFramePre() => UniTask.ToCoroutine(async () =>
-        //{
-        //    await UniTask.Yield(PlayerLoopTiming.PreUpdate);
+        [UnityTest]
+        public IEnumerator TimerFramePre() => UniTask.ToCoroutine(async () =>
+        {
+            await UniTask.Yield(PlayerLoopTiming.PreUpdate);
 
-        //    var initialFrame = Time.frameCount;
-        //    var xs = await UniTaskAsyncEnumerable.TimerFrame(2, 3).Take(5).Select(_ => Time.frameCount).ToArrayAsync();
+            var initialFrame = Time.frameCount;
+            var xs = await UniTaskAsyncEnumerable.TimerFrame(2, 3).Take(5).Select(_ => Time.frameCount).ToArrayAsync();
 
-        //    xs[0].Should().Be(initialFrame + 2);
-        //    xs[1].Should().Be(initialFrame + 2 + (3 * 1));
-        //    xs[2].Should().Be(initialFrame + 2 + (3 * 2));
-        //    xs[3].Should().Be(initialFrame + 2 + (3 * 3));
-        //    xs[4].Should().Be(initialFrame + 2 + (3 * 4));
-        //});
+            xs[0].Should().Be(initialFrame + 2);
+            xs[1].Should().Be(initialFrame + 2 + (3 * 1));
+            xs[2].Should().Be(initialFrame + 2 + (3 * 2));
+            xs[3].Should().Be(initialFrame + 2 + (3 * 3));
+            xs[4].Should().Be(initialFrame + 2 + (3 * 4));
+        });
 
 
-        //[UnityTest]
-        //public IEnumerator TimerFramePost() => UniTask.ToCoroutine(async () =>
-        //{
-        //    await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+        [UnityTest]
+        public IEnumerator TimerFramePost() => UniTask.ToCoroutine(async () =>
+        {
+            await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
 
-        //    var initialFrame = Time.frameCount;
-        //    var xs = await UniTaskAsyncEnumerable.TimerFrame(2, 3).Take(5).Select(_ => Time.frameCount).ToArrayAsync();
+            var initialFrame = Time.frameCount;
+            var xs = await UniTaskAsyncEnumerable.TimerFrame(2, 3).Take(5).Select(_ => Time.frameCount).ToArrayAsync();
 
-        //    xs[0].Should().Be(initialFrame + 2);
-        //    xs[1].Should().Be(initialFrame + 2 + (3 * 1));
-        //    xs[2].Should().Be(initialFrame + 2 + (3 * 2));
-        //    xs[3].Should().Be(initialFrame + 2 + (3 * 3));
-        //    xs[4].Should().Be(initialFrame + 2 + (3 * 4));
-        //});
+            xs[0].Should().Be(initialFrame + 2);
+            xs[1].Should().Be(initialFrame + 2 + (3 * 1));
+            xs[2].Should().Be(initialFrame + 2 + (3 * 2));
+            xs[3].Should().Be(initialFrame + 2 + (3 * 3));
+            xs[4].Should().Be(initialFrame + 2 + (3 * 4));
+        });
 
 
-        //[UnityTest]
-        //public IEnumerator TimerFrameTest() => UniTask.ToCoroutine(async () =>
-        //{
-        //    await UniTask.Yield(PlayerLoopTiming.PreUpdate);
+        [UnityTest]
+        public IEnumerator TimerFrameTest() => UniTask.ToCoroutine(async () =>
+        {
+            await UniTask.Yield(PlayerLoopTiming.PreUpdate);
 
-        //    var initialFrame = Time.frameCount;
-        //    var xs = await UniTaskAsyncEnumerable.TimerFrame(0, 0).Take(5).Select(_ => Time.frameCount).ToArrayAsync();
+            var initialFrame = Time.frameCount;
+            var xs = await UniTaskAsyncEnumerable.TimerFrame(0, 0).Take(5).Select(_ => Time.frameCount).ToArrayAsync();
 
-        //    xs[0].Should().Be(initialFrame);
-        //    xs[1].Should().Be(initialFrame + 1);
-        //    xs[2].Should().Be(initialFrame + 2);
-        //    xs[3].Should().Be(initialFrame + 3);
-        //    xs[4].Should().Be(initialFrame + 4);
-        //});
+            xs[0].Should().Be(initialFrame);
+            xs[1].Should().Be(initialFrame + 1);
+            xs[2].Should().Be(initialFrame + 2);
+            xs[3].Should().Be(initialFrame + 3);
+            xs[4].Should().Be(initialFrame + 4);
+        });
 
 
-        //[UnityTest]
-        //public IEnumerator TimerFrameSinglePre() => UniTask.ToCoroutine(async () =>
-        //{
-        //    {
-        //        await UniTask.Yield(PlayerLoopTiming.PreUpdate);
-        //        var initialFrame = Time.frameCount;
-        //        var xs = await UniTaskAsyncEnumerable.TimerFrame(0).Select(_ => Time.frameCount).ToArrayAsync();
-        //        xs[0].Should().Be(initialFrame);
+        [UnityTest]
+        public IEnumerator TimerFrameSinglePre() => UniTask.ToCoroutine(async () =>
+        {
+            {
+                await UniTask.Yield(PlayerLoopTiming.PreUpdate);
+                var initialFrame = Time.frameCount;
+                var xs = await UniTaskAsyncEnumerable.TimerFrame(0).Select(_ => Time.frameCount).ToArrayAsync();
+                xs[0].Should().Be(initialFrame);
 
-        //    }
-        //    {
-        //        await UniTask.Yield(PlayerLoopTiming.PreUpdate);
-        //        var initialFrame = Time.frameCount;
+            }
+            {
+                await UniTask.Yield(PlayerLoopTiming.PreUpdate);
+                var initialFrame = Time.frameCount;
 
-        //        var xs = await UniTaskAsyncEnumerable.TimerFrame(1).Select(_ =>
-        //        {
-        //            var t = Time.frameCount;
+                var xs = await UniTaskAsyncEnumerable.TimerFrame(1).Select(_ =>
+                {
+                    var t = Time.frameCount;
 
-        //            return t;
-        //        }).ToArrayAsync();
+                    return t;
+                }).ToArrayAsync();
 
-        //        xs[0].Should().Be(initialFrame + 1);
-        //    }
-        //    {
-        //        await UniTask.Yield(PlayerLoopTiming.PreUpdate);
-        //        var initialFrame = Time.frameCount;
-        //        var xs = await UniTaskAsyncEnumerable.TimerFrame(2).Select(_ => Time.frameCount).ToArrayAsync();
-        //        xs[0].Should().Be(initialFrame + 2);
-        //    }
-        //});
+                xs[0].Should().Be(initialFrame + 1);
+            }
+            {
+                await UniTask.Yield(PlayerLoopTiming.PreUpdate);
+                var initialFrame = Time.frameCount;
+                var xs = await UniTaskAsyncEnumerable.TimerFrame(2).Select(_ => Time.frameCount).ToArrayAsync();
+                xs[0].Should().Be(initialFrame + 2);
+            }
+        });
 
 
-        //[UnityTest]
-        //public IEnumerator TimerFrameSinglePost() => UniTask.ToCoroutine(async () =>
-        //{
-        //    {
-        //        //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
-        //        //var initialFrame = Time.frameCount;
-        //        //var xs = await UniTaskAsyncEnumerable.TimerFrame(0).Select(_ => Time.frameCount).ToArrayAsync();
-        //        //xs[0].Should().Be(initialFrame);
-        //    }
-        //    {
-        //        //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
-        //        var initialFrame = Time.frameCount;
-        //        var xs = await UniTaskAsyncEnumerable.TimerFrame(1).Select(_ => Time.frameCount).ToArrayAsync();
-        //        xs[0].Should().Be(initialFrame + 1);
-        //    }
-        //    {
-        //        //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
-        //        var initialFrame = Time.frameCount;
-        //        var xs = await UniTaskAsyncEnumerable.TimerFrame(2).Select(_ => Time.frameCount).ToArrayAsync();
-        //        xs[0].Should().Be(initialFrame + 2);
-        //    }
-        //});
+        [UnityTest]
+        public IEnumerator TimerFrameSinglePost() => UniTask.ToCoroutine(async () =>
+        {
+            {
+                //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+                //var initialFrame = Time.frameCount;
+                //var xs = await UniTaskAsyncEnumerable.TimerFrame(0).Select(_ => Time.frameCount).ToArrayAsync();
+                //xs[0].Should().Be(initialFrame);
+            }
+            {
+                //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+                var initialFrame = Time.frameCount;
+                var xs = await UniTaskAsyncEnumerable.TimerFrame(1).Select(_ => Time.frameCount).ToArrayAsync();
+                xs[0].Should().Be(initialFrame + 1);
+            }
+            {
+                //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+                var initialFrame = Time.frameCount;
+                var xs = await UniTaskAsyncEnumerable.TimerFrame(2).Select(_ => Time.frameCount).ToArrayAsync();
+                xs[0].Should().Be(initialFrame + 2);
+            }
+        });
 
 
 
-        //[UnityTest]
-        //public IEnumerator Timer() => UniTask.ToCoroutine(async () =>
-        //{
-        //    await UniTask.Yield(PlayerLoopTiming.PreUpdate);
+        [UnityTest]
+        public IEnumerator Timer() => UniTask.ToCoroutine(async () =>
+        {
+            await UniTask.Yield(PlayerLoopTiming.PreUpdate);
 
-        //    {
-        //        var initialSeconds = Time.realtimeSinceStartup;
-        //        var xs = await UniTaskAsyncEnumerable.Timer(TimeSpan.FromSeconds(2)).Select(_ => Time.realtimeSinceStartup).ToArrayAsync();
+            {
+                var initialSeconds = Time.realtimeSinceStartup;
+                var xs = await UniTaskAsyncEnumerable.Timer(TimeSpan.FromSeconds(2)).Select(_ => Time.realtimeSinceStartup).ToArrayAsync();
 
-        //        Mathf.Approximately(initialSeconds, xs[0]).Should().BeFalse();
-        //        Debug.Log("Init:" + initialSeconds);
-        //        Debug.Log("After:" + xs[0]);
-        //    }
-        //});
+                Mathf.Approximately(initialSeconds, xs[0]).Should().BeFalse();
+                Debug.Log("Init:" + initialSeconds);
+                Debug.Log("After:" + xs[0]);
+            }
+        });
 
 
         [UnityTest]
@@ -181,17 +181,24 @@ namespace Cysharp.Threading.TasksTests
         {
             await UniTask.Run(async () =>
             {
-                Debug.Log("Go Delay?");
-
                 await UniTask.Delay(TimeSpan.FromSeconds(2));
-
-                Debug.Log("OK?");
             });
         });
 
+        [UnityTest]
+        public IEnumerator DelayRealtime() => UniTask.ToCoroutine(async () =>
+        {
+            var now = DateTimeOffset.UtcNow;
 
+            await UniTask.Delay(TimeSpan.FromSeconds(2), DelayType.Realtime);
+
+            var elapsed = DateTimeOffset.UtcNow - now;
+
+            var okay1 = TimeSpan.FromSeconds(1.80) <= elapsed;
+            var okay2 = elapsed <= TimeSpan.FromSeconds(2.20);
+
+            okay1.Should().Be(true);
+            okay2.Should().Be(true);
+        });
     }
-
-
-
-}
+}

src/UniTask/ProjectSettings/ProjectVersion.txt

@@ -1,2 +1,2 @@
-m_EditorVersion: 2019.3.9f1
-m_EditorVersionWithRevision: 2019.3.9f1 (e6e740a1c473)
+m_EditorVersion: 2019.4.5f1
+m_EditorVersionWithRevision: 2019.4.5f1 (81610f64359c)