CI more

Merge pull request #61 from Cysharp/unitask2
UniTask2
2026-05-15 03:20:16 +00:00 · 2020-06-04 15:24:09 +09:00 · 2020-06-04 15:17:19 +09:00 · 2020-06-04 15:14:40 +09:00 · 2020-06-04 15:11:51 +09:00 · 2020-06-04 14:58:11 +09:00
122 changed files with 21921 additions and 1647 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -1,114 +0,0 @@
-version: 2.1
-executors:
-  unity:
-    # https://hub.docker.com/r/gableroux/unity3d/tags
-    parameters:
-      version: {type: string}
-    docker:
-      - image: gableroux/unity3d:<< parameters.version >>
-  go:
-    docker:
-      - image: circleci/golang      
-commands:
-  unity_activate:
-    parameters:
-      unity_version: {type: string}
-      unity_license: {type: string}
-    steps:
-      # get activation file, if fail to activate unity, use this key and activate from https://license.unity3d.com/manual
-      - run: apt update && apt install libunwind8 -y
-      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -logFile -createManualActivationFile || exit 0
-      - run: cat Unity_v<< parameters.unity_version >>.alf
-      # get from UNITY_LICENSE envvar(base64 encoded(cat foo.ulf | base64 )), this file is generated from above manual activation
-      - run: echo << parameters.unity_license >> | base64 -di  >> .circleci/Unity.ulf
-      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .circleci/Unity.ulf || exit 0
-jobs:
-  build-and-test:
-    parameters:
-      unity_version: {type: string}
-      unity_license: {type: string}
-    executor:
-      name: unity
-      version: << parameters.unity_version >>
-    steps:
-      - checkout
-      - unity_activate:
-          unity_version: << parameters.unity_version >>
-          unity_license: << parameters.unity_license >>
-      - run:
-          name: Build Linux(Mono)
-          command: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend Mono2x /BuildTarget StandaloneLinux64
-          working_directory: .
-      # TODO:check unity version and packages...
-      # - run: ./bin/UnitTest/StandaloneLinux64_Mono2x/test
-  build-and-create-package:
-    parameters:
-      unity_version: {type: string}
-      unity_license: {type: string}
-    executor:
-      name: unity
-      version: << parameters.unity_version >>
-    steps:
-      - checkout
-      - unity_activate:
-          unity_version: << parameters.unity_version >>
-          unity_license: << parameters.unity_license >>
-      - run:
-          name: Export unitypackage
-          command: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
-          working_directory: .
-      - store_artifacts:
-          path: ./UniRx.Async.unitypackage
-          destination: /UniRx.Async.unitypackage
-  # upload to github by ghr
-  upload-github:
-    executor: go
-    steps:
-      - attach_workspace:
-          at: .
-      - run: go get github.com/tcnksm/ghr
-      - run: ghr -t ${GITHUB_TOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} ${CIRCLE_TAG} .
-      - store_artifacts:
-          path: UniRx.Async.unitypackage
-          destination: UniRx.Async.unitypackage          
-workflows:
-  version: 2
-  build-unity:
-    jobs:
-      # does not exists yet.
-      # - build-and-test:
-      #     unity_version: 2019.3.0a2
-      #     unity_license: ${UNITY_LICENSE_2019_3}
-      # - build-and-test:
-      #     unity_version: 2019.2.0b2
-      #     unity_license: ${UNITY_LICENSE_2019_2}
-      - build-and-test:
-          unity_version: 2019.1.2f1
-          unity_license: ${UNITY_LICENSE_2019_1}
-          filters:
-            tags:
-              only: /.*/
-      # test asmdef will not found.
-      # - build-and-test:
-      #     unity_version: 2018.4.0f1
-      #     unity_license: ${UNITY_LICENSE_2018_4}
-      # # UniTask minimum support version is 2018.3(C# 7.x)
-      # - build-and-test:
-      #     unity_version: 2018.3.12f1
-      #     unity_license: ${UNITY_LICENSE_2018_3}
-      - build-and-create-package:
-          unity_version: 2019.1.2f1
-          unity_license: ${UNITY_LICENSE_2019_1}
-          filters:
-            tags:
-              only: /^\d\.\d\.\d.*/
-            branches:
-              ignore: /.*/
-      - upload-github:
-          requires:
-            - build-and-create-package
-          filters:
-            tags:
-              only: /^\d\.\d\.\d.*/
-            branches:
-              ignore: /.*/
--- a/.github/workflows/build-debug.yml
+++ b/.github/workflows/build-debug.yml
@@ -0,0 +1,73 @@
+name: Build-Debug
+
+on:
+  push:
+    branches:
+      - "**"
+    tags:
+      - "!*" # not a tag push
+  pull_request:
+    types:
+      - opened
+      - synchronize
+
+jobs:
+  build-dotnet:
+    runs-on: ubuntu-latest
+    env:
+      DOTNET_CLI_TELEMETRY_OPTOUT: 1
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+      NUGET_XMLDOC_MODE: skip
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 3.1.101
+      - run: dotnet test -c Debug ./src/UniTask.NetCoreTests/UniTask.NetCoreTests.csproj
+
+  build-unity:
+    strategy:
+      matrix:
+        unity: ['2019.3.9f1', '2020.1.0b5']
+        include:
+          - unity: 2019.3.9f1
+            license: UNITY_2019_3
+          - unity: 2020.1.0b5
+            license: UNITY_2020_1
+    runs-on: ubuntu-latest
+    container:
+      # with linux-il2cpp. image from https://hub.docker.com/r/gableroux/unity3d/tags
+      image: gableroux/unity3d:${{ matrix.unity }}-linux-il2cpp
+    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] }}
+      - name: Activate Unity, always returns a success. But if a subsequent run fails, the activation may have failed(if succeeded, shows `Next license update check is after` and not shows other message(like GUID != GUID). If fails not). In that case, upload the artifact's .alf file to https://license.unity3d.com/manual to get the .ulf file and set it to secrets.
+        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
+
+      # Execute scripts: RuntimeUnitTestToolkit
+      - name: Build UnitTest(Linux64, mono)
+        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend mono /BuildTarget StandaloneLinux64
+        working-directory: src/UniTask
+      - name: Execute UnitTest
+        run: ./src/UniTask/bin/UnitTest/StandaloneLinux64_Mono2x/test
+
+      # Execute scripts: Export Package
+      - name: Export unitypackage
+        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+        working-directory: src/UniTask
+
+      # Store artifacts.      
+      - uses: actions/upload-artifact@v2
+        with:
+          name: UniTask.unitypackage.zip
+          path: ./src/UniTask/*.unitypackage
--- a/.github/workflows/build-release.yml
+++ b/.github/workflows/build-release.yml
@@ -0,0 +1,105 @@
+name: Build-Release
+
+on:
+  push:
+    tags:
+      - "[0-9]+.[0-9]+.[0-9]+*"
+
+jobs:
+  build-dotnet:
+    runs-on: ubuntu-latest
+    env:
+      DOTNET_CLI_TELEMETRY_OPTOUT: 1
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+      NUGET_XMLDOC_MODE: skip
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 3.1.101
+      # set release tag(*.*.*) to env.GIT_TAG
+      - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+
+      # build and pack
+      - run: dotnet build -c Release -p:Version=${{ env.GIT_TAG }}
+      - run: dotnet test -c Release --no-build
+      - run: dotnet pack ./src/UniTask.NetCore/UniTask.NetCore.csproj -c Release --no-build -p:Version=${{ env.GIT_TAG }}
+
+      # Store artifacts.
+      - uses: actions/upload-artifact@v1
+        with:
+          name: nuget
+          path: ./src/UniTask.NetCore/bin/Release/UniTask.${{ env.GIT_TAG }}.nupkg
+
+  build-unity:
+    strategy:
+      matrix:
+        unity: ['2019.3.9f1']
+        include:
+          - unity: 2019.3.9f1
+            license: UNITY_2019_3
+    runs-on: ubuntu-latest
+    container:
+      # with linux-il2cpp. image from https://hub.docker.com/r/gableroux/unity3d/tags
+      image: gableroux/unity3d:${{ matrix.unity }}-linux-il2cpp
+    steps:
+      - run: apt update && apt install git -y
+      - uses: actions/checkout@v2
+      - run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
+        env:
+          UNITY_LICENSE: ${{ secrets[matrix.license] }}
+      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
+
+      # set release tag(*.*.*) to env.GIT_TAG
+      - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+
+      # Execute scripts: Export Package
+      - name: Export unitypackage
+        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+        working-directory: src/UniTask
+
+      # Store artifacts.      
+      - uses: actions/upload-artifact@v2
+        with:
+          name: UniTask.unitypackage.zip
+          path: ./src/UniTask/*.unitypackage
+
+  create-release:
+    needs: [build-dotnet, build-unity]
+    runs-on: ubuntu-latest
+    env:
+      DOTNET_CLI_TELEMETRY_OPTOUT: 1
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+      NUGET_XMLDOC_MODE: skip
+    steps:
+    # setup dotnet for nuget push
+    - uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: 3.1.101
+    # set release tag(*.*.*) to env.GIT_TAG
+    - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+
+    # Create Releases
+    - uses: actions/create-release@v1
+      id: create_release
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ github.ref }}
+        release_name: Ver.${{ github.ref }}
+
+    # Download(All) Artifacts to current directory
+    - uses: actions/download-artifact@v2-preview
+
+    # Upload to NuGet
+    - run: dotnet nuget push "./nuget/*.nupkg" -s https://www.nuget.org/api/v2/package -k ${{ secrets.NUGET_KEY }}
+
+    # Upload to Releases(unitypackage)
+    - uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./UniTask.${{ env.GIT_TAG }}.unitypackage/UniTask.${{ env.GIT_TAG }}.unitypackage
+        asset_name: UniTask.${{ env.GIT_TAG }}.unitypackage
+        asset_content_type: application/octet-stream
--- a/.github/workflows/toc.yml
+++ b/.github/workflows/toc.yml
@@ -0,0 +1,15 @@
+name: TOC Generator
+
+on:
+  push:
+    paths:
+      - 'README.md'
+
+jobs:
+  generateTOC:
+    name: TOC Generator
+    runs-on: ubuntu-latest
+    steps:
+      - uses: technote-space/toc-generator@v2.4.0
+        with:
+          TOC_TITLE: "## Table of Contents"
--- a/.gitignore
+++ b/.gitignore
@@ -157,3 +157,5 @@ src/UniTask/UniTask.Tests.csproj
 src/UniTask/UniTask.Tests.Editor.csproj

 src/UniTask/UniTask.*.unitypackage
+
+src/UniTask/UniTask.Linq.csproj
--- a/README.md
+++ b/README.md
@@ -1,28 +1,63 @@
-# UniTask
+UniTask
+===
+[![GitHub Actions](https://github.com/Cysharp/UniTask/workflows/Build-Debug/badge.svg)](https://github.com/Cysharp/UniTask/actions) [![Releases](https://img.shields.io/github/release/Cysharp/UniTask.svg)](https://github.com/Cysharp/UniTask/releases)

-[![CircleCI](https://circleci.com/gh/Cysharp/UniTask.svg?style=svg)](https://circleci.com/gh/Cysharp/UniTask)
+Provides an efficient async/await integration to Unity. 

-Provides an efficient async/await integration to Unity.
+* Struct based `UniTask<T>` and custom AsyncMethodBuilder to achive zero allocation
+* All Unity AsyncOperations and Coroutine to awaitable
+* PlayerLoop based task(`UniTask.Yield`, `UniTask.Delay`, `UniTask.DelayFrame`, etc...) that enable to replace all coroutine operation
+* MonoBehaviour Message Events and uGUI Events as awaitable/async-enumerable
+* Completely run on Unity's PlayerLoop so don't use thread and run on WebGL, wasm, etc.
+* Asynchronous LINQ, with Channel and AsyncReactiveProperty
+* TaskTracker window to prevent memory leak
+* Highly compatible behaviour with Task/ValueTask/IValueTaskSource

-> UniTask was included in UniRx before v7 but now completely separated, it no dependent each other.
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+## Table of Contents
+
+- [Getting started](#getting-started)
+- [Basics of UniTask and AsyncOperation](#basics-of-unitask-and-asyncoperation)
+- [Cancellation and Exception handling](#cancellation-and-exception-handling)
+- [Progress](#progress)
+- [PlayerLoop](#playerloop)
+- [async void vs async UniTaskVoid](#async-void-vs-async-unitaskvoid)
+- [UniTaskTracker](#unitasktracker)
+- [External Assets](#external-assets)
+- [AsyncEnumerable and Async LINQ](#asyncenumerable-and-async-linq)
+- [Awaitable Events](#awaitable-events)
+- [Channel](#channel)
+- [For Unit Testing](#for-unit-testing)
+- [API References](#api-references)
+- [UPM Package](#upm-package)
+  - [Install via git URL](#install-via-git-url)
+  - [Install via OpenUPM](#install-via-openupm)
+- [.NET Core](#net-core)
+- [License](#license)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->

 Getting started
 ---
-Install package(`UniRx.Async.unitypackage`) is available in [UniTask/releases](https://github.com/Cysharp/UniTask/releases) page.
+Install via [UPM package](#upm-package) or asset package(`UniTask.*.*.*.unitypackage`) available in [UniTask/releases](https://github.com/Cysharp/UniTask/releases) page.

 ```csharp
 // extension awaiter/methods can be used by this namespace
-using UniRx.Async;
+using Cysharp.Threading.Tasks;

 // You can return type as struct UniTask<T>(or UniTask), it is unity specialized lightweight alternative of Task<T>
-// no(or less) allocation and fast excution for zero overhead async/await integrate with Unity
+// zero allocation and fast excution for zero overhead async/await integrate with Unity
 async UniTask<string> DemoAsync()
 {
    // You can await Unity's AsyncObject
    var asset = await Resources.LoadAsync<TextAsset>("foo");
    
-    // .ConfigureAwait accepts progress callback
-    await SceneManager.LoadSceneAsync("scene2").ConfigureAwait(Progress.Create<float>(x => Debug.Log(x)));
+    // .WithCancellation enables Cancel, GetCancellationTokenOnDestroy synchornizes with lifetime of GameObject
+    var asset2 = await Resources.LoadAsync<TextAsset>("foo").WithCancellation(this.GetCancellationTokenOnDestroy());
+
+    // .ToUniTask accepts progress callback(and all options), Progress.Create is a lightweight alternative of IProgress<T>
+    await SceneManager.LoadSceneAsync("scene2").ToUniTask(Progress.Create<float>(x => Debug.Log(x)));
    
    // await frame-based operation like coroutine
    await UniTask.DelayFrame(100); 
@@ -31,11 +66,14 @@ async UniTask<string> DemoAsync()
    await UniTask.Delay(TimeSpan.FromSeconds(10), ignoreTimeScale: false);
    
    // replacement of WaitForEndOfFrame(or other timing like yield return null, yield return WaitForFixedUpdate)
-    await UniTask.Yield(PlayerLoopTiming.PostLateUpdate);
+    await UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate);
    
    // replacement of yield return WaitUntil
    await UniTask.WaitUntil(() => isActive == false);

+    // special helper of WaitUntil
+    await UniTask.WaitUntilValueChanged(this, x => x.isActive);
+
    // You can await IEnumerator coroutine
    await FooCoroutineEnumerator();

@@ -58,6 +96,9 @@ async UniTask<string> DemoAsync()

    // concurrent async-wait and get result easily by tuple syntax
    var (google, bing, yahoo) = await UniTask.WhenAll(task1, task2, task3);
+
+    // shorthand of WhenAll, tuple can await directly
+    var (google2, bing2, yahoo2) = await (task1, task2, task3);
    
    // You can handle timeout easily
    await GetTextAsync(UnityWebRequest.Get("http://unity.com")).Timeout(TimeSpan.FromMilliseconds(300));
@@ -67,47 +108,36 @@ async UniTask<string> DemoAsync()
 }
 ```

-`UniTask<T>`
+Basics of UniTask and AsyncOperation
 ---
-UniTask feature rely on C# 7.0([task-like custom async method builder feature](https://github.com/dotnet/roslyn/blob/master/docs/features/task-types.md)) so required  Unity version is after `Unity 2018.3`.
+UniTask feature rely on C# 7.0([task-like custom async method builder feature](https://github.com/dotnet/roslyn/blob/master/docs/features/task-types.md)) so required Unity version is after `Unity 2018.3`, officialy lower support version is `Unity 2018.4.13f1`.

-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 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.
+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.

-> More details, please see this slide: [Deep Dive async/await in Unity with UniTask(EN)
-](https://www.slideshare.net/neuecc/deep-dive-asyncawait-in-unity-with-unitasken)
+You can await `AsyncOperation`, `ResourceRequest`, `AssetBundleRequest`, `AssetBundleCreateRequest`, `UnityWebRequestAsyncOperation`, `IEnumerator` and others when `using Cysharp.Threading.Tasks;`.

-You can await `AsyncOperation`, `ResourceRequest`, `UnityWebRequestAsyncOperation`, `IEnumerator` and others when using `UniRx.Async`.
-
-`UniTask.Delay`, `UniTask.Yield`, `UniTask.Timeout` that is frame-based timer operators(no uses thread so works on WebGL publish) driven by custom PlayerLoop(Unity 2018 experimental feature). In default, UniTask initialize automatically when application begin, but it is override all. If you want to append PlayerLoop, please call `PlayerLoopHelper.Initialize(ref yourCustomizedPlayerLoop)` manually.
-
-> Before Unity 2019.3, Unity does not have `PlayerLooop.GetCurrentPlayerLoop` so you can't use with Unity ECS package in default. If you want to use with ECS and before Unity 2019.3, you can use this hack below.
+UniTask provides three pattern of extension methods.

 ```csharp
-// Get ECS Loop.
-var playerLoop = ScriptBehaviourUpdateOrder.CurrentPlayerLoop;
-
-// Setup UniTask's PlayerLoop.
-PlayerLoopHelper.Initialize(ref playerLoop);
+* await asyncOperation;
+* .WithCancellation(CancellationToken);
+* .ToUniTask(IProgress, PlayerLoopTiming, CancellationToken);
 ```

-`UniTask.WhenAll`, `UniTask.WhenAny` is like Task.WhenAll/WhenAny but return type is more useful.
+`WithCancellation` is a simple version of `ToUniTask`, both returns `UniTask`. Details of cancellation, see: [Cancellation and Exception handling](#cancellation-and-exception-handling) section.

-`UniTask.ctor(Func<UniTask>)` is like the embeded [`AsyncLazy<T>`](https://blogs.msdn.microsoft.com/pfxteam/2011/01/15/asynclazyt/)
+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 readonly UniTask<Sprite> Front;
-    public readonly UniTask<Sprite> Background;
-    public readonly UniTask<Sprite> Effect;
-
    public SceneAssets()
    {
-        // ctor(Func) overload is AsyncLazy, initialized once when await.
-        // and after it, await returns zero-allocation value immediately.
-        Front = new UniTask<Sprite>(() => LoadAsSprite("foo"));
-        Background = new UniTask<Sprite>(() => LoadAsSprite("bar"));
-        Effect = new UniTask<Sprite>(() => LoadAsSprite("baz"));
+        // parallel load.
+        var (a, b, c) = await UniTask.WhenAll(
+            LoadAsSprite("foo"),
+            LoadAsSprite("bar"),
+            LoadAsSprite("baz"));
    }

    async UniTask<Sprite> LoadAsSprite(string path)
@@ -133,13 +163,32 @@ public UniTask<int> WrapByUniTaskCompletionSource()
 }
 ```

-You can convert Task -> UniTask: `AsUniTask`, `UniTask` -> `UniTask<AsyncUnit>`: `AsAsyncUnitUniTask`(this is useful to use WhenAll/WhenAny), `UniTask<T>` -> `UniTask`: `AsUniTask`.
+You can convert Task -> UniTask: `AsUniTask`, `UniTask` -> `UniTask<AsyncUnit>`: `AsAsyncUnitUniTask`, `UniTask<T>` -> `UniTask`: `AsUniTask`. `UniTask<T>` -> `UniTask`'s conversion cost is free.

-If you want to convert async to coroutine, you can use `UniTask.ToCoroutine`, this is useful to use only allow coroutine system.
+If you want to convert async to coroutine, you can use `.ToCoroutine()`, this is useful to use only allow coroutine system.
+
+UniTask can not await twice. This is a similar constraint to the [ValueTask/IValueTaskSource](https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.valuetask-1?view=netcore-3.1) introduced in .NET Standard 2.1.
+
+> The following operations should never be performed on a ValueTask<TResult> instance:
+>
+> * Awaiting the instance multiple times.
+> * Calling AsTask multiple times.
+> * Using .Result or .GetAwaiter().GetResult() when the operation hasn't yet completed, or using them multiple times.
+> * Using more than one of these techniques to consume the instance.
+>
+> If you do any of the above, the results are undefined.
+
+```csharp
+var task = UniTask.DelayFrame(10);
+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.

 Cancellation and Exception handling
 ---
-Some UniTask factory methods have `CancellationToken cancellation = default(CancellationToken)` parameter. Andalso some async operation for unity have `ConfigureAwait(..., CancellationToken cancellation = default(CancellationToken))` extension methods. 
+Some UniTask factory methods have `CancellationToken cancellationToken = default` parameter. Andalso some async operation for unity have `WithCancellation(CancellationToken)` and `ToUniTask(..., CancellationToken cancellation = default)` extension methods. 

 You can pass `CancellationToken` to parameter by standard [`CancellationTokenSource`](https://docs.microsoft.com/en-us/dotnet/api/system.threading.cancellationtokensource).

@@ -151,7 +200,7 @@ cancelButton.onClick.AddListener(() =>
    cts.Cancel();
 });

-await UnityWebRequest.Get("http://google.co.jp").SendWebRequest().ConfigureAwait(cancellation: cts.Token);
+await UnityWebRequest.Get("http://google.co.jp").SendWebRequest().WithCancellation(cts.Token);

 await UniTask.DelayFrame(1000, cancellationToken: cts.Token);
 ```
@@ -165,7 +214,7 @@ await UniTask.DelayFrame(1000, cancellationToken: this.GetCancellationTokenOnDes

 When detect cancellation, all methods throws `OperationCanceledException` and propagate to upstream. `OperationCanceledException` is special exception, if not handled this exception, finally it is propagated to `UniTaskScheduler.UnobservedTaskException`.

-Default behaviour of received unhandled exception is write log as warning. Log level can change by `UniTaskScheduler.UnobservedExceptionWriteLogType`. If you want to change custom beavhiour, set action to `UniTaskScheduler.UnobservedTaskException.`
+Default behaviour of received unhandled exception is write log as exception. Log level can change by `UniTaskScheduler.UnobservedExceptionWriteLogType`. If you want to change custom beavhiour, set action to `UniTaskScheduler.UnobservedTaskException.`

 If you want to cancel behaviour in async UniTask method, throws `OperationCanceledException` manually.

@@ -204,23 +253,23 @@ if (isCanceled)
 }
 ```

-Note: Only suppress throws if you call it directly into the most source method.
+Note: Only suppress throws if you call it directly into the most source method. Otherwise, the return value will be converted, but the entire pipeline will not be suppressed throws.

 Progress
 ---
-Some async operation for unity have `ConfigureAwait(IProgress<float> progress = null, ...)` extension methods. 
+Some async operation for unity have `ToUniTask(IProgress<float> progress = null, ...)` extension methods. 

 ```csharp
 var progress = Progress.Create<float>(x => Debug.Log(x));

 var request = await UnityWebRequest.Get("http://google.co.jp")
    .SendWebRequest()
-    .ConfigureAwait(progress: progress);
+    .ToUniTask(progress: progress);
 ```

-Should not use `new System.Progress<T>`, because it allocate every times. Use `UniRx.Async.Progress` instead. Progress factory has two methods, `Create` and `CreateOnlyValueChanged`. `CreateOnlyValueChanged` calls only when progress value changed. Should not use `new System.Progress<T>`, it allocate every times.
+You should not use standard `new System.Progress<T>`, because it causes allocation every times. Use `Cysharp.Threading.Tasks.Progress` instead. This progress factory has two methods, `Create` and `CreateOnlyValueChanged`. `CreateOnlyValueChanged` calls only when progress value changed.

-Implements interface is more better.
+Implements IProgress interface to caller is more better, there is no allocation of lambda.

 ```csharp
 public class Foo : MonoBehaviour, IProgress<float>
@@ -234,16 +283,125 @@ public class Foo : MonoBehaviour, IProgress<float>
    {
        var request = await UnityWebRequest.Get("http://google.co.jp")
            .SendWebRequest()
-            .ConfigureAwait(progress: this); // pass this
+            .ToUniTask(progress: this); // pass this
    }
 }
 ```

+PlayerLoop
+---
+UniTask is run on custom [PlayerLoop](https://docs.unity3d.com/ScriptReference/LowLevel.PlayerLoop.html). UniTask's playerloop based method(such as `Delay`, `DelayFrame`, `asyncOperation.ToUniTask`, etc...) accepts this `PlayerLoopTiming`.
+
+```csharp
+public enum PlayerLoopTiming
+{
+    Initialization = 0,
+    LastInitialization = 1,
+
+    EarlyUpdate = 2,
+    LastEarlyUpdate = 3,
+
+    FixedUpdate = 4,
+    LastFixedUpdate = 5,
+
+    PreUpdate = 6,
+    LastPreUpdate = 7,
+
+    Update = 8,
+    LastUpdate = 9,
+
+    PreLateUpdate = 10,
+    LastPreLateUpdate = 11,
+
+    PostLateUpdate = 12,
+    LastPostLateUpdate = 13
+}
+```
+
+It indicates when to run, you can check [PlayerLoopList.md](https://gist.github.com/neuecc/bc3a1cfd4d74501ad057e49efcd7bdae) to Unity's default playerloop and injected UniTask's custom loop.
+
+`PlayerLoopTiming.Update` is similar as `yield return null` in coroutine, but it is called before Update(Update is called on `ScriptRunBehaviourUpdate`, yield return null is called on `ScriptRunDelayedDynamicFrameRate`). If change timing to `PlayerLoopTiming.LastUpdate`, called after these Unity's update methods.
+
+`PlayerLoopTiming.FixedUpdate` is similar as `WaitForFixedUpdate`, `PlayerLoopTiming.LastPostLateUpdate` is similar as `WaitForEndOfFrame` in coroutine.
+
+In default, UniTask's PlayerLoop is initialized at `[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]`.
+
+The order in which methods are called in BeforeSceneLoad is indeterminate, so if you want to use UniTask in other BeforeSceneLoad methods, you should try to initialize it before this.
+
+```csharp
+// AfterAssembliesLoaded is called before BeforeSceneLoad
+[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
+public static void InitUniTaskLoop()
+{
+    var loop = PlayerLoop.GetCurrentPlayerLoop();
+    Cysharp.Threading.Tasks.PlayerLoopHelper.Initialize(ref loop);
+}
+```
+
+If you import Unity's `Entities` package, that reset custom player loop to default at `BeforeSceneLoad` and inject ECS's loop. When Unity call ECS's inject method after UniTask's initialize method, UniTask will no longer work.
+
+To solve this issue, you can re-initialize UniTask PlayerLoop after ECS initialized.
+
+```csharp
+// Get ECS Loop.
+var playerLoop = ScriptBehaviourUpdateOrder.CurrentPlayerLoop;
+
+// Setup UniTask's PlayerLoop.
+PlayerLoopHelper.Initialize(ref playerLoop);
+```
+
+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()`.
+
+```csharp
+public async UniTaskVoid FireAndForgetMethod()
+{
+    // do anything...
+    await UniTask.Yield();
+}
+
+public void Caller()
+{
+    FireAndForgetMethod().Forget();
+}
+```
+
+Also UniTask have `Forget` method, it is similar with UniTaskVoid and same effects with it. However still UniTaskVoid is more efficient if completely do not use await。
+
+```csharp
+public async UniTask DoAsync()
+{
+    // do anything...
+    await UniTask.Yield();
+}
+
+public void Caller()
+{
+    DoAsync().Forget();
+}
+```
+
+Using async lambda in register event, it is used `async void`. To avoid it, you can use `UniTask.Action` or `UniTask.UnityAction` that creates delegate via `async UniTaskVoid` lambda.
+
+```csharp
+Action actEvent;
+UnityAction unityEvent; // especially used in uGUI
+
+// Bad: async void
+actEvent += async () => { };
+unityEvent += async () => { };
+
+// Ok: create Action delegate by lambda
+actEvent += UniTask.Action(async () => { await UniTask.Yield(); });
+unityEvent += UniTask.UnityAction(async () => { await UniTask.Yield(); });
+```
+
 UniTaskTracker
 ---
 useful for check(leak) UniTasks. You can open tracker window in `Window -> UniTask Tracker`.

-![](https://user-images.githubusercontent.com/46207/50421527-abf1cf80-0883-11e9-928a-ffcd47b8c454.png)
+![image](https://user-images.githubusercontent.com/46207/83527073-4434bf00-a522-11ea-86e9-3b3975b26266.png)

 * Enable AutoReload(Toggle) - Reload automatically.
 * Reload - Reload view.
@@ -253,38 +411,89 @@ useful for check(leak) UniTasks. You can open tracker window in `Window -> UniTa

 For debug use, enable tracking and capture stacktrace is useful but it it decline performance. Recommended usage is enable both to find task leak, and when done, finally disable both.

-Reusable Promises
+External Assets
 ---
-Some UniTask factory can reuse to reduce allocation. The list is `Yield`, `Delay`, `DelayFrame`, `WaitUntil`, `WaitWhile`, `WaitUntilValueChanged`.
+In default, UniTask supports DOTween and Addressable(`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.

 ```csharp
-var reusePromise = UniTask.DelayFrame(10);
+// sequential
+await transform.DOMoveX(2, 10);
+await transform.DOMoveZ(5, 20);

-for (int i = 0; i < 10; i++)
+// parallel with cancellation
+var ct = this.GetCancellationTokenOnDestroy();
+
+await UniTask.WhenAll(
+    transform.DOMoveX(10, 3).WithCancellation(ct),
+    transform.DOScale(10, 3).WithCancellation(ct));
+```
+
+AsyncEnumerable and Async LINQ
+---
+Unity 2020.2.0a12 supports C# 8.0 so you can use `await foreach`. This is the new Update notation in async era.
+
+```csharp
+// Unity 2020.2.0a12, C# 8.0
+await foreach (var _ in UniTaskAsyncEnumerable.EveryUpdate(token))
 {
-    await reusePromise;
+    Debug.Log("Update() " + Time.frameCount);
 }
 ```

-awaitable Events
---
-Unity events can await like `OnClickAsync`, `OnCollisionEnterAsync`. It can use by `UniRx.Async.Triggers`.
+In a C# 7.3 environment, you can use the `ForEachAsync` method to work in almost the same way.

 ```csharp
-using UniRx.Async.Triggers;
-
-async UniTask TripleClick(CancellationToken token)
+// C# 7.3(Unity 2018.3~)
+await UniTaskAsyncEnumerable.EveryUpdate(token).ForEachAsync(_ =>
 {
-    await button.OnClickAsync(token);
-    await button.OnClickAsync(token);
-    await button.OnClickAsync(token);
+    Debug.Log("Update() " + Time.frameCount);
+});
+```
+
+UniTaskAsyncEnumerable implements asynchronous LINQ, similar to LINQ in `IEnumerable<T>` or Rx in `IObservable<T>`. All standard LINQ query operators can be applied to asynchronous streams. For example, the following code shows how to apply a Where filter to a button-click asynchronous stream that runs once every two clicks.
+
+```csharp
+await okButton.OnClickAsAsyncEnumerable().Where((x, i) => i % 2 == 0).ForEachAsync(_ =>
+{
+});
+```
+
+Async LINQ is enabled when `using Cysharp.Threading.Tasks.Linq;`, and `UniTaskAsyncEnumerable` is defined in `UniTask.Linq` asmdef.
+
+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`.
+
+The method with Func as an argument has three additional overloads, `***Await`, `***AwaitWithCancellation`.
+
+```csharp
+Select(Func<T, TR> selector)
+SelectAwait(Func<T, UniTask<TR>> selector)
+SelectAwaitWithCancellation(Func<T, CancellationToken, UniTask<TR>> selector)
+```
+
+If you want to use the `async` method inside the func, use the `***Await` or `***AwaitWithCancellation`.
+
+Awaitable Events
+---
+All uGUI component implements `***AsAsyncEnumerable` to convert asynchronous streams of events.
+
+```csharp
+async UniTask TripleClick()
+{
+    // In default, used button.GetCancellationTokenOnDestroy to manage lieftime of async
+    await button.OnClickAsync();
+    await button.OnClickAsync();
+    await button.OnClickAsync();
    Debug.Log("Three times clicked");
 }

 // more efficient way
-async UniTask TripleClick(CancellationToken token)
+async UniTask TripleClick()
 {
-    using (var handler = button.GetAsyncClickEventHandler(token))
+    using (var handler = button.GetAsyncClickEventHandler())
    {
        await handler.OnClickAsync();
        await handler.OnClickAsync();
@@ -292,11 +501,126 @@ async UniTask TripleClick(CancellationToken token)
        Debug.Log("Three times clicked");
    }
 }
+
+// use async LINQ
+async UniTask TripleClick(CancellationToken token)
+{
+    await button.OnClickAsAsyncEnumerable().Take(3).Last();
+    Debug.Log("Three times clicked");
+}
+
+// use async LINQ2
+async UniTask TripleClick(CancellationToken token)
+{
+    await button.OnClickAsAsyncEnumerable().Take(3).ForEachAsync(_ =>
+    {
+        Debug.Log("Every clicked");
+    });
+    Debug.Log("Three times clicked, complete.");
+}
 ```

-async void vs async UniTask/UniTaskVoid
+All MonoBehaviour message events can convert async-streams by `AsyncTriggers` that can enable by `using Cysharp.Threading.Tasks.Triggers;`.
+
+```csharp
+using Cysharp.Threading.Tasks.Triggers;
+
+async UniTaskVoid MonitorCollision()
+{
+    await gameObject.OnCollisionEnterAsync();
+    Debug.Log("Collision Enter");
+    /* do anything */
+
+    await gameObject.OnCollisionExitAsync();
+    Debug.Log("Collision Exit");
+}
+```
+
+Similar as uGUI event, AsyncTrigger can get by `GetAsync***Trigger` and trigger it self is UniTaskAsyncEnumerable.
+
+```csharp
+// use await multiple times, get AsyncTriggerHandler is more efficient.
+using(var trigger = this.GetOnCollisionEnterAsyncHandler())
+{
+    await OnCollisionEnterAsync();
+    await OnCollisionEnterAsync();
+    await OnCollisionEnterAsync();
+}
+
+// every moves.
+await this.GetAsyncMoveTrigger().ForEachAsync(axisEventData =>
+{
+});
+```
+
+`AsyncReactiveProperty`, `AsyncReadOnlyReactiveProperty` is UniTask version of UniTask's ReactiveProperty.
+
+`BindTo` extension method of `IUniTaskAsyncEnumerable<T>` for binding asynchronous stream values to Unity components(Text/Selectable/TMP/Text).
+
+A pull-type asynchronous stream does not get the next values until the asynchronous processing in the sequence is complete. This could spill data from push-type events such as buttons.
+
+```csharp
+// can not get click event during 3 seconds complete.
+await button.OnClickAsAsyncEnumerable().ForEachAwaitAsync()
+{
+    await UniTask.Delay(TimeSpan.FromSeconds(3));
+}
+```
+
+It is useful(prevent double-click) but not useful in sometimes.
+
+Using `Queue()` method, which will also queue events during asynchronous processing.
+
+```csharp
+// queued message in asynchronous processing
+await button.OnClickAsAsyncEnumerable().Queue().ForEachAwaitAsync()
+{
+    await UniTask.Delay(TimeSpan.FromSeconds(3));
+}
+```
+
+Channel
 ---
-`async void` is standard C# system so does not run on UniTask systems. It is better not to use. `async UniTaskVoid` is lightweight version of `async UniTask` because it does not have awaitable completion. If you don't require to await it(fire and forget), use `UniTaskVoid` is better. Unfortunately to dismiss warning, require to using with `Forget()`.
+`Channel` is same as [System.Threading.Tasks.Channels](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.channels?view=netcore-3.1) that is similar as GoLang Channel.
+
+Currently only supports multiple-producer, single-consumer unbounded channel. It can create by `Channel.CreateSingleConsumerUnbounded<T>()`.
+
+For producer(`.Writer`), `TryWrite` to push value and `TryComplete` to complete channel. For consumer(`.Reader`), `TryRead`, `WaitToReadAsync`, `ReadAsync`, `Completion` and `ReadAllAsync` to read queued messages.
+
+`ReadAllAsync` returns `IUniTaskAsyncEnumerable<T>` so query LINQ operators. Reader only allows single-consumer but use `.Publish()` query operator to enable multicast message. For example, make pub/sub utility.
+
+```csharp
+public class AsyncMessageBroker<T> : IDisposable
+{
+    Channel<T> channel;
+
+    IConnectableUniTaskAsyncEnumerable<T> multicastSource;
+    IDisposable connection;
+
+    public AsyncMessageBroker()
+    {
+        channel = Channel.CreateSingleConsumerUnbounded<T>();
+        multicastSource = channel.Reader.ReadAllAsync().Publish();
+        connection = multicastSource.Connect(); // Publish returns IConnectableUniTaskAsyncEnumerable.
+    }
+
+    public void Publish(T value)
+    {
+        channel.Writer.TryWrite(value);
+    }
+
+    public IUniTaskAsyncEnumerable<T> Subscribe()
+    {
+        return multicastSource;
+    }
+
+    public void Dispose()
+    {
+        channel.Writer.TryComplete();
+        connection.Dispose();
+    }
+}
+```

 For Unit Testing
 ---
@@ -323,36 +647,70 @@ public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () =>
 });
 ```

-Method List
+UniTask itself's unit test is written by Unity Test Runner and [Cysharp/RuntimeUnitTestToolkit](https://github.com/Cysharp/RuntimeUnitTestToolkit) to check on CI and IL2CPP working.
+
+API References
 ---
-```csharp
-UniTask.WaitUntil
-UniTask.WaitWhile
-UniTask.WaitUntilValueChanged
-UniTask.SwitchToThreadPool
-UniTask.SwitchToTaskPool
-UniTask.SwitchToMainThread
-UniTask.SwitchToSynchronizationContext
-UniTask.Yield
-UniTask.Run
-UniTask.Lazy
-UniTask.Void
-UniTask.ConfigureAwait
-UniTask.DelayFrame
-UniTask.Delay(..., bool ignoreTimeScale = false, ...) parameter
-```
+UniTask's API References is hosted at [cysharp.github.io/UniTask](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.html) by [DocFX](https://dotnet.github.io/docfx/) and [Cysharp/DocfXTemplate](https://github.com/Cysharp/DocfxTemplate).
+
+For example, UniTask's factory methods can see at [UniTask#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.UniTask.html#methods-1). UniTaskAsyncEnumerable's factory/extension methods can see at [UniTaskAsyncEnumerable#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.Linq.UniTaskAsyncEnumerable.html#methods-1).

 UPM Package
 ---
-After Unity 2019.3.4f1, Unity 2020.1a21, that support path query parameter of git package. You can add `https://github.com/Cysharp/UniTask.git?path=Assets/UniRx.Async` to Package Manager
+### Install via git URL
+
+After Unity 2019.3.4f1, Unity 2020.1a21, that support path query parameter of git package. You can add `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask` to Package Manager

 ![image](https://user-images.githubusercontent.com/46207/79450714-3aadd100-8020-11ea-8aae-b8d87fc4d7be.png)

-![image](https://user-images.githubusercontent.com/46207/79450774-56b17280-8020-11ea-91eb-21e1f51eb60c.png)
+![image](https://user-images.githubusercontent.com/46207/83702872-e0f17c80-a648-11ea-8183-7469dcd4f810.png)

-or add `"com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=Assets/UniRx.Async"` to `Packages/manifest.json`.
+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 `#1.3.0`. For example `https://github.com/Cysharp/UniTask.git?path=Assets/UniRx.Async#1.3.1`.
+If you want to set a target version, UniTask is using `*.*.*` release tag so you can specify a version like `#2.0.13`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.0.13`.
+
+### Install via OpenUPM
+
+The package is available on the [openupm registry](https://openupm.com). It's recommended to install it via [openupm-cli](https://github.com/openupm/openupm-cli).
+
+```
+openupm add com.cysharp.unitask
+```
+
+.NET Core
+---
+For .NET Core, use NuGet.
+
+> PM> Install-Package [UniTask](https://www.nuget.org/packages/UniTask)
+
+UniTask of .NET Core version is a subset of Unity UniTask, removed PlayerLoop dependent methods.
+
+It runs at higher performance than the standard Task/ValueTask, but you should be careful to ignore the ExecutionContext/SynchronizationContext when using it. `AysncLocal` also does not work because it ignores ExecutionContext.
+
+If you use UniTask internally, but provide ValueTask as an external API, you can write like the following(Inspired by [PooledAwait](https://github.com/mgravell/PooledAwait)).
+
+```csharp
+public class ZeroAllocAsyncAwaitInDotNetCore
+{
+    public ValueTask<int> DoAsync(int x, int y)
+    {
+        return Core(this, x, y);
+
+        static async UniTask<int> Core(ZeroAllocAsyncAwaitInDotNetCore self, int x, int y)
+        {
+            // do anything...
+            await Task.Delay(TimeSpan.FromSeconds(x + y));
+            await UniTask.Yield();
+
+            return 10;
+        }
+    }
+}
+```
+
+.NET Core version is intended to allow users to use UniTask as an interface when sharing code with Unity (such as [Cysharp/MagicOnion](https://github.com/Cysharp/MagicOnion/)). .NET Core version of UniTask enables smooth code sharing.
+
+Utility methods such as WhenAll which is equivalent to UniTask are provided as [Cysharp/ValueTaskSupplement](https://github.com/Cysharp/ValueTaskSupplement).

 License
 ---
--- a/src/UniTask.NetCore/Icon.png
+++ b/src/UniTask.NetCore/Icon.png
--- a/src/UniTask.NetCore/NetCore/UniTask.AsValueTask.cs
+++ b/src/UniTask.NetCore/NetCore/UniTask.AsValueTask.cs
@@ -1,123 +1,30 @@
 #pragma warning disable 0649

-using System;
-using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
-using System.Threading.Tasks.Sources;

 namespace Cysharp.Threading.Tasks
 {
    public static class UniTaskValueTaskExtensions
    {
-        public static ValueTask AsValueTask(this UniTask task)
+        public static ValueTask AsValueTask(this in UniTask task)
        {
-            ref var core = ref Unsafe.As<UniTask, UniTaskToValueTask>(ref task);
-            if (core.source == null)
-            {
-                return default;
-            }
-            
-            return new ValueTask(new UniTaskValueTaskSource(core.source), core.token);
+            return task;
        }

-        public static ValueTask<T> AsValueTask<T>(this UniTask<T> task)
+        public static ValueTask<T> AsValueTask<T>(this in UniTask<T> task)
        {
-            ref var core = ref Unsafe.As<UniTask<T>, UniTaskToValueTask<T>>(ref task);
-            if (core.source == null)
-            {
-                return new ValueTask<T>(core.result);
-            }
-
-            return new ValueTask<T>(new UniTaskValueTaskSource<T>(core.source), core.token);
+            return task;
        }

-        struct UniTaskToValueTask
+        public static UniTask<T> AsUniTask<T>(this ValueTask<T> task, bool useCurrentSynchronizationContext = true)
        {
-            public IUniTaskSource source;
-            public short token;
+            // NOTE: get _obj and _token directly for low overhead conversion but not yet implemented.
+            return task.AsTask().AsUniTask(useCurrentSynchronizationContext);
        }

-        class UniTaskValueTaskSource : IValueTaskSource
+        public static UniTask AsUniTask(this ValueTask task, bool useCurrentSynchronizationContext = true)
        {
-            readonly IUniTaskSource source;
-
-            public UniTaskValueTaskSource(IUniTaskSource source)
-            {
-                this.source = source;
-            }
-
-            public void GetResult(short token)
-            {
-                source.GetResult(token);
-            }
-
-            public ValueTaskSourceStatus GetStatus(short token)
-            {
-                var status = source.GetStatus(token);
-                switch (status)
-                {
-                    case UniTaskStatus.Pending:
-                        return ValueTaskSourceStatus.Pending;
-                    case UniTaskStatus.Succeeded:
-                        return ValueTaskSourceStatus.Succeeded;
-                    case UniTaskStatus.Faulted:
-                        return ValueTaskSourceStatus.Faulted;
-                    case UniTaskStatus.Canceled:
-                        return ValueTaskSourceStatus.Canceled;
-                    default:
-                        return (ValueTaskSourceStatus)status;
-                }
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
-            {
-                source.OnCompleted(continuation, state, token);
-            }
-        }
-
-        struct UniTaskToValueTask<T>
-        {
-            public IUniTaskSource<T> source;
-            public T result;
-            public short token;
-        }
-
-        class UniTaskValueTaskSource<T> : IValueTaskSource<T>
-        {
-            readonly IUniTaskSource<T> source;
-
-            public UniTaskValueTaskSource(IUniTaskSource<T> source)
-            {
-                this.source = source;
-            }
-
-            public T GetResult(short token)
-            {
-                return source.GetResult(token);
-            }
-
-            public ValueTaskSourceStatus GetStatus(short token)
-            {
-                var status = source.GetStatus(token);
-                switch (status)
-                {
-                    case UniTaskStatus.Pending:
-                        return ValueTaskSourceStatus.Pending;
-                    case UniTaskStatus.Succeeded:
-                        return ValueTaskSourceStatus.Succeeded;
-                    case UniTaskStatus.Faulted:
-                        return ValueTaskSourceStatus.Faulted;
-                    case UniTaskStatus.Canceled:
-                        return ValueTaskSourceStatus.Canceled;
-                    default:
-                        return (ValueTaskSourceStatus)status;
-                }
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
-            {
-                source.OnCompleted(continuation, state, token);
-            }
+            return task.AsTask().AsUniTask(useCurrentSynchronizationContext);
        }
    }
 }
--- a/src/UniTask.NetCore/NetCore/UniTask.Delay.cs
+++ b/src/UniTask.NetCore/NetCore/UniTask.Delay.cs
@@ -0,0 +1,39 @@
+//using Cysharp.Threading.Tasks.Internal;
+//using System;
+//using System.Collections.Concurrent;
+//using System.Runtime.CompilerServices;
+//using System.Threading;
+
+//namespace Cysharp.Threading.Tasks
+//{
+//    public partial struct UniTask
+//    {
+//        public static UniTask Delay()
+//        {
+//            return default;
+//        }
+
+//        sealed class DelayPromise : IUniTaskSource
+//        {
+//            public void GetResult(short token)
+//            {
+//                throw new NotImplementedException();
+//            }
+
+//            public UniTaskStatus GetStatus(short token)
+//            {
+//                throw new NotImplementedException();
+//            }
+
+//            public void OnCompleted(Action<object> continuation, object state, short token)
+//            {
+//                throw new NotImplementedException();
+//            }
+
+//            public UniTaskStatus UnsafeGetStatus()
+//            {
+//                throw new NotImplementedException();
+//            }
+//        }
+//    }
+//}
--- a/src/UniTask.NetCore/NetCore/UniTask.Yield.cs
+++ b/src/UniTask.NetCore/NetCore/UniTask.Yield.cs
@@ -1,4 +1,6 @@
-using System;
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using System.Threading;

@@ -41,7 +43,11 @@ namespace Cysharp.Threading.Tasks
                    }
                    else
                    {
+#if NETCOREAPP3_1
+                        ThreadPool.UnsafeQueueUserWorkItem(ThreadPoolWorkItem.Create(continuation), false);
+#else
                        ThreadPool.UnsafeQueueUserWorkItem(WaitCallbackDelegate, continuation);
+#endif
                    }
                }

@@ -50,6 +56,47 @@ namespace Cysharp.Threading.Tasks
                    ((Action)state).Invoke();
                }
            }
+
+#if NETCOREAPP3_1
+
+            sealed class ThreadPoolWorkItem : IThreadPoolWorkItem, ITaskPoolNode<ThreadPoolWorkItem>
+            {
+                static TaskPool<ThreadPoolWorkItem> pool;
+                public ThreadPoolWorkItem NextNode { get; set; }
+
+                static ThreadPoolWorkItem()
+                {
+                    TaskPool.RegisterSizeGetter(typeof(ThreadPoolWorkItem), () => pool.Size);
+                }
+
+                Action continuation;
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                public static ThreadPoolWorkItem Create(Action continuation)
+                {
+                    if (!pool.TryPop(out var item))
+                    {
+                        item = new ThreadPoolWorkItem();
+                    }
+
+                    item.continuation = continuation;
+                    return item;
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                public void Execute()
+                {
+                    var call = continuation;
+                    continuation = null;
+                    if (call != null)
+                    {
+                        pool.TryPush(this);
+                        call.Invoke();
+                    }
+                }
+            }
+
+#endif
        }
    }
 }
--- a/src/UniTask.NetCore/UniTask.NetCore.csproj
+++ b/src/UniTask.NetCore/UniTask.NetCore.csproj
@@ -1,11 +1,30 @@
 <Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFramework>netstandard2.0</TargetFramework>
+        <TargetFrameworks>netcoreapp3.1;netstandard2.1</TargetFrameworks>
        <AssemblyName>UniTask</AssemblyName>
+        <LangVersion>8.0</LangVersion>
        <RootNamespace>Cysharp.Threading.Tasks</RootNamespace>
+
+        <!-- NuGet Packaging -->
+        <Id>UniTask</Id>
+        <PackageVersion>$(Version)</PackageVersion>
+        <Company>Cysharp</Company>
+        <Authors>Cysharp</Authors>
+        <Copyright>© Cysharp, Inc.</Copyright>
+        <PackageTags>task;async</PackageTags>
+        <Description>Provides an efficient async/await integration to Unity and .NET Core.</Description>
+        <PackageProjectUrl>https://github.com/Cysharp/UniTask</PackageProjectUrl>
+        <RepositoryUrl>$(PackageProjectUrl)</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+        <PackageIcon>Icon.png</PackageIcon>
    </PropertyGroup>

+    <ItemGroup>
+        <None Include="Icon.png" Pack="true" PackagePath="/" />
+    </ItemGroup>
+
    <ItemGroup>
        <Compile Include="..\UniTask\Assets\Plugins\UniTask\Runtime\**\*.cs"
                 Exclude="
--- a/src/UniTask.NetCoreSandbox/AllocationCheck.cs
+++ b/src/UniTask.NetCoreSandbox/AllocationCheck.cs
@@ -0,0 +1,258 @@
+using BenchmarkDotNet.Attributes;
+using System.Linq;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Running;
+using Cysharp.Threading.Tasks;
+using PooledAwait;
+using System;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
+using System.Threading;
+using System.Runtime.CompilerServices;
+using Cysharp.Threading.Tasks.CompilerServices;
+using System.Collections.Concurrent;
+
+[Config(typeof(BenchmarkConfig))]
+public class AllocationCheck
+{
+    // note: all the benchmarks use Task/Task<T> for the public API, because BenchmarkDotNet
+    // doesn't work reliably with more exotic task-types (even just ValueTask fails); instead,
+    // we'll obscure the cost of the outer awaitable by doing a relatively large number of
+    // iterations, so that we're only really measuring the inner loop
+    private const int InnerOps = 1000;
+
+    [Benchmark(OperationsPerInvoke = InnerOps)]
+    public async Task ViaUniTask()
+    {
+        for (int i = 0; i < InnerOps; i++)
+        {
+            var a = Core();
+            var b = Core();
+            var c = Core();
+            await a;
+            await b;
+            await c;
+        }
+
+        static async UniTask Core()
+        {
+            await new TestAwaiter(false, UniTaskStatus.Succeeded);
+            await new TestAwaiter(false, UniTaskStatus.Succeeded);
+            await new TestAwaiter(false, UniTaskStatus.Succeeded);
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps)]
+    public async Task<int> ViaUniTaskT()
+    {
+        var sum = 0;
+        for (int i = 0; i < InnerOps; i++)
+        {
+            var a = Core();
+            var b = Core();
+            var c = Core();
+            sum += await a;
+            sum += await b;
+            sum += await c;
+        }
+        return sum;
+
+        static async UniTask<int> Core()
+        {
+            var a = await new TestAwaiter<int>(false, UniTaskStatus.Succeeded, 10);
+            var b = await new TestAwaiter<int>(false, UniTaskStatus.Succeeded, 10);
+            var c = await new TestAwaiter<int>(false, UniTaskStatus.Succeeded, 10);
+            return 10;
+        }
+    }
+
+    //[Benchmark(OperationsPerInvoke = InnerOps)]
+    //[Benchmark]
+    public void ViaUniTaskVoid()
+    {
+        for (int i = 0; i < InnerOps; i++)
+        {
+            Core().Forget();
+            Core().Forget();
+            Core().Forget();
+        }
+
+        static async UniTaskVoid Core()
+        {
+            await new TestAwaiter(false, UniTaskStatus.Succeeded);
+            await new TestAwaiter(false, UniTaskStatus.Succeeded);
+            await new TestAwaiter(false, UniTaskStatus.Succeeded);
+        }
+    }
+
+    struct Foo : IAsyncStateMachine
+    {
+        public AsyncUniTaskVoidMethodBuilder builder;
+        public TestAwaiter awaiter;
+        public TestAwaiter awaiterawaiter;
+
+        public int state;
+
+        public void MoveNext()
+        {
+            switch (state)
+            {
+                case -1:
+                    awaiterawaiter = awaiter.GetAwaiter();
+                    if (awaiterawaiter.IsCompleted)
+                    {
+                        goto case 0;
+                    }
+                    else
+                    {
+                        state = 0;
+                        builder.AwaitUnsafeOnCompleted(ref awaiterawaiter, ref this);
+                        return;
+                    }
+
+                case 0:
+                default:
+                    goto END;
+            }
+
+            END:
+            builder.SetResult();
+        }
+
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+
+        }
+    }
+}
+
+public class TaskTestException : Exception
+{
+
+}
+
+public struct TestAwaiter : ICriticalNotifyCompletion
+{
+    readonly UniTaskStatus status;
+    readonly bool isCompleted;
+
+    public TestAwaiter(bool isCompleted, UniTaskStatus status)
+    {
+        this.isCompleted = isCompleted;
+        this.status = status;
+    }
+
+    public TestAwaiter GetAwaiter() => this;
+
+    public bool IsCompleted => isCompleted;
+
+    public void GetResult()
+    {
+        switch (status)
+        {
+            case UniTaskStatus.Faulted:
+                throw new TaskTestException();
+            case UniTaskStatus.Canceled:
+                throw new OperationCanceledException();
+            case UniTaskStatus.Pending:
+            case UniTaskStatus.Succeeded:
+            default:
+                break;
+        }
+    }
+
+    public void OnCompleted(Action continuation)
+    {
+        ThreadPool.UnsafeQueueUserWorkItem(ThreadPoolWorkItem.Create(continuation), false);
+    }
+
+    public void UnsafeOnCompleted(Action continuation)
+    {
+        ThreadPool.UnsafeQueueUserWorkItem(ThreadPoolWorkItem.Create(continuation), false);
+    }
+
+
+}
+
+public struct TestAwaiter<T> : ICriticalNotifyCompletion
+{
+    readonly UniTaskStatus status;
+    readonly bool isCompleted;
+    readonly T value;
+
+    public TestAwaiter(bool isCompleted, UniTaskStatus status, T value)
+    {
+        this.isCompleted = isCompleted;
+        this.status = status;
+        this.value = value;
+    }
+
+    public TestAwaiter<T> GetAwaiter() => this;
+
+    public bool IsCompleted => isCompleted;
+
+    public T GetResult()
+    {
+        switch (status)
+        {
+            case UniTaskStatus.Faulted:
+                throw new TaskTestException();
+            case UniTaskStatus.Canceled:
+                throw new OperationCanceledException();
+            case UniTaskStatus.Pending:
+            case UniTaskStatus.Succeeded:
+            default:
+                return value;
+        }
+    }
+
+    public void OnCompleted(Action continuation)
+    {
+        ThreadPool.UnsafeQueueUserWorkItem(ThreadPoolWorkItem.Create(continuation), false);
+    }
+
+    public void UnsafeOnCompleted(Action continuation)
+    {
+        ThreadPool.UnsafeQueueUserWorkItem(ThreadPoolWorkItem.Create(continuation), false);
+    }
+}
+
+public sealed class ThreadPoolWorkItem : IThreadPoolWorkItem
+{
+    public static readonly ConcurrentQueue<ThreadPoolWorkItem> pool = new ConcurrentQueue<ThreadPoolWorkItem>();
+
+    public static void CreatePoolItems(int count)
+    {
+        for (int i = 0; i < count; i++)
+        {
+            pool.Enqueue(new ThreadPoolWorkItem());
+        }
+    }
+
+    Action continuation;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ThreadPoolWorkItem Create(Action continuation)
+    {
+        if (!pool.TryDequeue(out var item))
+        {
+            item = new ThreadPoolWorkItem();
+        }
+
+        item.continuation = continuation;
+        return item;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Execute()
+    {
+        var call = continuation;
+        continuation = null;
+        pool.Enqueue(this);
+
+        call.Invoke();
+    }
+}
--- a/src/UniTask.NetCoreSandbox/Benchmark.cs
+++ b/src/UniTask.NetCoreSandbox/Benchmark.cs
@@ -0,0 +1,283 @@
+using BenchmarkDotNet.Attributes;
+using System.Linq;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Running;
+using Cysharp.Threading.Tasks;
+using PooledAwait;
+using System;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
+using System.Threading;
+using System.Runtime.CompilerServices;
+using Cysharp.Threading.Tasks.CompilerServices;
+
+//class Program
+//{
+//    static void Main(string[] args)
+//    {
+//        var switcher = new BenchmarkSwitcher(new[]
+//        {
+//            typeof(StandardBenchmark)
+//        });
+
+//#if DEBUG
+//        var b = new StandardBenchmark();
+
+//#else
+//        switcher.Run(args);
+//#endif
+//    }
+//}
+
+public class BenchmarkConfig : ManualConfig
+{
+    public BenchmarkConfig()
+    {
+        AddDiagnoser(MemoryDiagnoser.Default);
+        AddJob(Job.ShortRun.WithLaunchCount(1).WithIterationCount(1).WithWarmupCount(1)/*.RunOncePerIteration()*/);
+    }
+}
+
+// borrowed from PooledAwait
+
+[Config(typeof(BenchmarkConfig))]
+[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+[CategoriesColumn]
+public class ComparisonBenchmarks
+{
+    // note: all the benchmarks use Task/Task<T> for the public API, because BenchmarkDotNet
+    // doesn't work reliably with more exotic task-types (even just ValueTask fails); instead,
+    // we'll obscure the cost of the outer awaitable by doing a relatively large number of
+    // iterations, so that we're only really measuring the inner loop
+    private const int InnerOps = 1000;
+
+    public bool ConfigureAwait { get; set; } = false;
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = ".NET")]
+    [BenchmarkCategory("Task<T>")]
+    public async Task<int> ViaTaskT()
+    {
+        int sum = 0;
+        for (int i = 0; i < InnerOps; i++)
+            sum += await Inner(1, 2).ConfigureAwait(ConfigureAwait);
+        return sum;
+
+        static async Task<int> Inner(int x, int y)
+        {
+            int i = x;
+            await Task.Yield();
+            i *= y;
+            await Task.Yield();
+            return 5 * i;
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = ".NET")]
+    [BenchmarkCategory("Task")]
+    public async Task ViaTask()
+    {
+        for (int i = 0; i < InnerOps; i++)
+            await Inner().ConfigureAwait(ConfigureAwait);
+
+        static async Task Inner()
+        {
+            await Task.Yield();
+            await Task.Yield();
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = ".NET")]
+    [BenchmarkCategory("ValueTask<T>")]
+    public async Task<int> ViaValueTaskT()
+    {
+        int sum = 0;
+        for (int i = 0; i < InnerOps; i++)
+            sum += await Inner(1, 2).ConfigureAwait(ConfigureAwait);
+        return sum;
+
+        static async ValueTask<int> Inner(int x, int y)
+        {
+            int i = x;
+            await Task.Yield();
+            i *= y;
+            await Task.Yield();
+            return 5 * i;
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = ".NET")]
+    [BenchmarkCategory("ValueTask")]
+    public async Task ViaValueTask()
+    {
+        for (int i = 0; i < InnerOps; i++)
+            await Inner().ConfigureAwait(ConfigureAwait);
+
+        static async ValueTask Inner()
+        {
+            await Task.Yield();
+            await Task.Yield();
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = "Pooled")]
+    [BenchmarkCategory("ValueTask<T>")]
+    public async Task<int> ViaPooledValueTaskT()
+    {
+        int sum = 0;
+        for (int i = 0; i < InnerOps; i++)
+            sum += await Inner(1, 2).ConfigureAwait(ConfigureAwait);
+        return sum;
+
+        static async PooledValueTask<int> Inner(int x, int y)
+        {
+            int i = x;
+            await Task.Yield();
+            i *= y;
+            await Task.Yield();
+            return 5 * i;
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = "Pooled")]
+    [BenchmarkCategory("ValueTask")]
+    public async Task ViaPooledValueTask()
+    {
+        for (int i = 0; i < InnerOps; i++)
+            await Inner().ConfigureAwait(ConfigureAwait);
+
+        static async PooledValueTask Inner()
+        {
+            await Task.Yield();
+            await Task.Yield();
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = "Pooled")]
+    [BenchmarkCategory("Task<T>")]
+    public async Task<int> ViaPooledTaskT()
+    {
+        int sum = 0;
+        for (int i = 0; i < InnerOps; i++)
+            sum += await Inner(1, 2).ConfigureAwait(ConfigureAwait);
+        return sum;
+
+        static async PooledTask<int> Inner(int x, int y)
+        {
+            int i = x;
+            await Task.Yield();
+            i *= y;
+            await Task.Yield();
+            return 5 * i;
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = "Pooled")]
+    [BenchmarkCategory("Task")]
+    public async Task ViaPooledTask()
+    {
+        for (int i = 0; i < InnerOps; i++)
+            await Inner().ConfigureAwait(ConfigureAwait);
+
+        static async PooledTask Inner()
+        {
+            await Task.Yield();
+            await Task.Yield();
+        }
+    }
+
+    // ---
+
+    //[Benchmark(OperationsPerInvoke = InnerOps, Description = "UniTaskVoid")]
+    //[BenchmarkCategory("UniTask")]
+    //public async Task ViaUniTaskVoid()
+    //{
+    //    for (int i = 0; i < InnerOps; i++)
+    //    {
+    //        await Inner();
+    //    }
+
+    //    static async UniTaskVoid Inner()
+    //    {
+    //        await UniTask.Yield();
+    //        await UniTask.Yield();
+    //    }
+    //}
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = "UniTask")]
+    [BenchmarkCategory("UniTask")]
+    public async Task ViaUniTask()
+    {
+        for (int i = 0; i < InnerOps; i++)
+        {
+            await Inner();
+        }
+
+        static async UniTask Inner()
+        {
+            await UniTask.Yield();
+            await UniTask.Yield();
+        }
+    }
+
+    [Benchmark(OperationsPerInvoke = InnerOps, Description = "UniTaskT")]
+    [BenchmarkCategory("UniTask")]
+    public async Task<int> ViaUniTaskT()
+    {
+        var sum = 0;
+        for (int i = 0; i < InnerOps; i++)
+        {
+            sum += await Inner(1, 2);
+        }
+        return sum;
+
+        static async UniTask<int> Inner(int x, int y)
+        {
+            int i = x;
+            await UniTask.Yield();
+            i *= y;
+            await UniTask.Yield();
+            return 5 * i;
+        }
+    }
+}
+
+public struct MyAwaiter : ICriticalNotifyCompletion
+{
+    public MyAwaiter GetAwaiter() => this;
+
+    public bool IsCompleted => false;
+
+    public void GetResult()
+    {
+    }
+
+    public void OnCompleted(Action continuation)
+    {
+        continuation();
+    }
+
+    public void UnsafeOnCompleted(Action continuation)
+    {
+        continuation();
+    }
+}
+
+public struct MyTestStateMachine : IAsyncStateMachine
+{
+    public void MoveNext()
+    {
+        //throw new NotImplementedException();
+
+
+
+
+    }
+
+    public void SetStateMachine(IAsyncStateMachine stateMachine)
+    {
+        //throw new NotImplementedException();
+    }
+}
--- a/src/UniTask.NetCoreSandbox/Program.cs
+++ b/src/UniTask.NetCoreSandbox/Program.cs
@@ -15,12 +15,132 @@ using System.Reactive.Concurrency;

 namespace NetCoreSandbox
 {
+    public class MySyncContext : SynchronizationContext
+    {
+        public MySyncContext()
+        {
+        }
+
+        public override void Post(SendOrPostCallback d, object state)
+        {
+            Console.WriteLine("Called SyncContext Post!");
+            base.Post(d, state);
+        }
+    }
+
    public class Text
    {

        public string text { get; set; }
    }

+    public class ZeroAllocAsyncAwaitInDotNetCore
+    {
+        public ValueTask<int> NanikaAsync(int x, int y)
+        {
+            return Core(this, x, y);
+
+            static async UniTask<int> Core(ZeroAllocAsyncAwaitInDotNetCore self, int x, int y)
+            {
+                // nanika suru...
+                await Task.Delay(TimeSpan.FromSeconds(x + y));
+
+                return 10;
+            }
+        }
+    }
+
+
+    public class TaskTestException : Exception
+    {
+
+    }
+
+
+    public struct TestAwaiter : ICriticalNotifyCompletion
+    {
+        readonly UniTaskStatus status;
+        readonly bool isCompleted;
+
+        public TestAwaiter(bool isCompleted, UniTaskStatus status)
+        {
+            this.isCompleted = isCompleted;
+            this.status = status;
+        }
+
+        public TestAwaiter GetAwaiter() => this;
+
+        public bool IsCompleted => isCompleted;
+
+        public void GetResult()
+        {
+            switch (status)
+            {
+                case UniTaskStatus.Faulted:
+                    throw new TaskTestException();
+                case UniTaskStatus.Canceled:
+                    throw new OperationCanceledException();
+                case UniTaskStatus.Pending:
+                case UniTaskStatus.Succeeded:
+                default:
+                    break;
+            }
+        }
+
+        public void OnCompleted(Action continuation)
+        {
+            ThreadPool.QueueUserWorkItem(_ => continuation(), null);
+        }
+
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            ThreadPool.UnsafeQueueUserWorkItem(_ => continuation(), null);
+        }
+    }
+    public struct TestAwaiter<T> : ICriticalNotifyCompletion
+    {
+        readonly UniTaskStatus status;
+        readonly bool isCompleted;
+        readonly T value;
+
+        public TestAwaiter(bool isCompleted, UniTaskStatus status, T value)
+        {
+            this.isCompleted = isCompleted;
+            this.status = status;
+            this.value = value;
+        }
+
+        public TestAwaiter<T> GetAwaiter() => this;
+
+        public bool IsCompleted => isCompleted;
+
+        public T GetResult()
+        {
+            switch (status)
+            {
+                case UniTaskStatus.Faulted:
+                    throw new TaskTestException();
+                case UniTaskStatus.Canceled:
+                    throw new OperationCanceledException();
+                case UniTaskStatus.Pending:
+                case UniTaskStatus.Succeeded:
+                default:
+                    return value;
+            }
+        }
+
+        public void OnCompleted(Action continuation)
+        {
+            ThreadPool.QueueUserWorkItem(_ => continuation(), null);
+        }
+
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            ThreadPool.UnsafeQueueUserWorkItem(_ => continuation(), null);
+        }
+    }
+
+
    public static partial class UnityUIComponentExtensions
    {
        public static void BindTo(this IUniTaskAsyncEnumerable<string> source, Text text)
@@ -86,35 +206,140 @@ namespace NetCoreSandbox
            await Task.Delay(10, cancellationToken);
        }

-        static async Task Main(string[] args)
+        public class MyDisposable : IDisposable
        {
-            await foreach (var item in UniTaskAsyncEnumerable.Range(1, 10)
-                .SelectAwait(x => UniTask.Run(() => x))
-                .TakeLast(6)
-
-                
-
-                )
+            public void Dispose()
            {

-                
-
-                Console.WriteLine(item);
            }
+        }

-// AsyncEnumerable.Range(1,10).FirstAsync(
-            // AsyncEnumerable.Range(1, 10).GroupBy(x=>x).Select(x=>x.first
-
-
-            // AsyncEnumerable.Range(1,10).WithCancellation(CancellationToken.None).WithCancellation
-
-
-            //Enumerable.Range(1,10).ToHashSet(
+        static void Test()
+        {
+            var disp = new MyDisposable();

+            using var _ = new MyDisposable();

+            Console.WriteLine("tako");
        }


+        static async UniTask FooBarAsync()
+        {
+            await using (UniTask.ReturnToCurrentSynchronizationContext())
+            {
+                await UniTask.SwitchToThreadPool();
+
+
+
+
+            }
+        }
+
+
+
+
+        static async UniTask Aaa()
+        {
+            await FooBarAsync();
+
+            Console.WriteLine("FooBarAsync End");
+        }
+
+        static async UniTask WhereSelect()
+        {
+            await foreach (var item in UniTaskAsyncEnumerable.Range(1, 10)
+                .SelectAwait(async x =>
+                {
+                    await UniTask.Yield();
+                    return x;
+                })
+                .Where(x => x % 2 == 0))
+            {
+                Console.WriteLine(item);
+            }
+        }
+
+
+        static async Task Main(string[] args)
+        {
+#if !DEBUG
+         
+            
+
+
+            //await new AllocationCheck().ViaUniTaskVoid();
+            //Console.ReadLine();
+            BenchmarkDotNet.Running.BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+
+            //await new ComparisonBenchmarks().ViaUniTaskT();
+            return;
+#endif
+            // await new AllocationCheck().ViaUniTaskVoid();
+
+            // AsyncTest().Forget();
+            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++)
+            {
+                ////    list.Add(AsyncTest());
+                await YieldCore();
+            }
+            //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()
+        {
+            await UniTask.Yield();
+        }
+
+#pragma warning disable CS1998
+
+
+        static async UniTask<int> AsyncTest()
+        {
+            // empty 
+            await new TestAwaiter(false, UniTaskStatus.Succeeded);
+            await new TestAwaiter(true, UniTaskStatus.Succeeded);
+            await new TestAwaiter(false, UniTaskStatus.Succeeded);
+            return 10;
+        }
+
+
+
+#pragma warning restore CS1998

        void Foo()
        {
--- a/src/UniTask.NetCoreSandbox/QueueCheck.cs
+++ b/src/UniTask.NetCoreSandbox/QueueCheck.cs
@@ -0,0 +1,396 @@
+using BenchmarkDotNet.Attributes;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+[Config(typeof(BenchmarkConfig))]
+public class QueueCheck
+{
+    Node node1 = new Node();
+    Node node2 = new Node();
+    Queue<Node> q1 = new Queue<Node>();
+    Stack<Node> s1 = new Stack<Node>();
+    ConcurrentQueue<Node> cq = new ConcurrentQueue<Node>();
+    ConcurrentStack<Node> cs = new ConcurrentStack<Node>();
+    static TaskPool<Node> pool;
+    static TaskPoolEqualNull<Node> poolEqualNull;
+    static TaskPoolClass<Node> poolClass = new TaskPoolClass<Node>();
+    static TaskPoolWithoutSize<Node> poolWithoutSize;
+    static TaskPoolWithoutLock<Node> poolWithoutLock;
+
+    [Benchmark]
+    public void Queue()
+    {
+        q1.Enqueue(node1);
+        q1.Enqueue(node1);
+        q1.TryDequeue(out _);
+        q1.TryDequeue(out _);
+    }
+
+    [Benchmark]
+    public void QueueLock()
+    {
+        lock (q1) { q1.Enqueue(node1); }
+        lock (q1) { q1.Enqueue(node1); }
+        lock (q1) { q1.TryDequeue(out _); }
+        lock (q1) { q1.TryDequeue(out _); }
+    }
+
+    [Benchmark]
+    public void Stack()
+    {
+        s1.Push(node1);
+        s1.Push(node2);
+        s1.TryPop(out _);
+        s1.TryPop(out _);
+    }
+
+    [Benchmark]
+    public void StackLock()
+    {
+        lock (s1) { s1.Push(node1); }
+        lock (s1) { s1.Push(node2); }
+        lock (s1) { s1.TryPop(out _); }
+        lock (s1) { s1.TryPop(out _); }
+    }
+
+    [Benchmark]
+    public void ConcurrentQueue()
+    {
+        cq.Enqueue(node1);
+        cq.Enqueue(node1);
+        cq.TryDequeue(out _);
+        cq.TryDequeue(out _);
+    }
+
+    [Benchmark]
+    public void ConcurrentStack()
+    {
+        cs.Push(node1);
+        cs.Push(node2);
+        cs.TryPop(out _);
+        cs.TryPop(out _);
+    }
+
+    [Benchmark]
+    public void TaskPool()
+    {
+        pool.TryPush(node1);
+        pool.TryPush(node2);
+        pool.TryPop(out _);
+        pool.TryPop(out _);
+    }
+
+    [Benchmark]
+    public void TaskPoolEqualNull()
+    {
+        poolEqualNull.TryPush(node1);
+        poolEqualNull.TryPush(node2);
+        poolEqualNull.TryPop(out _);
+        poolEqualNull.TryPop(out _);
+    }
+
+    [Benchmark]
+    public void TaskPoolClass()
+    {
+        poolClass.TryPush(node1);
+        poolClass.TryPush(node2);
+        poolClass.TryPop(out _);
+        poolClass.TryPop(out _);
+    }
+
+    [Benchmark]
+    public void TaskPoolWithoutSize()
+    {
+        poolWithoutSize.TryPush(node1);
+        poolWithoutSize.TryPush(node2);
+        poolWithoutSize.TryPop(out _);
+        poolWithoutSize.TryPop(out _);
+    }
+
+    [Benchmark]
+    public void TaskPoolWithoutLock()
+    {
+        poolWithoutLock.TryPush(node1);
+        poolWithoutLock.TryPush(node2);
+        poolWithoutLock.TryPop(out _);
+        poolWithoutLock.TryPop(out _);
+    }
+}
+
+public sealed class Node : ITaskPoolNode<Node>
+{
+    public Node NextNode { get; set; }
+}
+
+public interface ITaskPoolNode<T>
+{
+    T NextNode { get; set; }
+}
+
+// mutable struct, don't mark readonly.
+[StructLayout(LayoutKind.Auto)]
+public struct TaskPoolWithoutLock<T>
+    where T : class, ITaskPoolNode<T>
+{
+    int size;
+    T root;
+
+    public int Size => size;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPop(out T result)
+    {
+        //if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            var v = root;
+            if (!(v is null))
+            {
+                root = v.NextNode;
+                v.NextNode = null;
+                size--;
+                result = v;
+                //      Volatile.Write(ref gate, 0);
+                return true;
+            }
+
+            //Volatile.Write(ref gate, 0);
+        }
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPush(T item)
+    {
+        //if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            //if (size < TaskPool.MaxPoolSize)
+            {
+                item.NextNode = root;
+                root = item;
+                size++;
+                //      Volatile.Write(ref gate, 0);
+                return true;
+            }
+            //else
+            {
+                //  Volatile.Write(ref gate, 0);
+            }
+        }
+        //return false;
+    }
+}
+
+[StructLayout(LayoutKind.Auto)]
+public struct TaskPool<T>
+    where T : class, ITaskPoolNode<T>
+{
+    int gate;
+    int size;
+    T root;
+
+    public int Size => size;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPop(out T result)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            var v = root;
+            if (!(v is null))
+            {
+                root = v.NextNode;
+                v.NextNode = null;
+                size--;
+                result = v;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+
+            Volatile.Write(ref gate, 0);
+        }
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPush(T item)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            //if (size < TaskPool.MaxPoolSize)
+            {
+                item.NextNode = root;
+                root = item;
+                size++;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+            //else
+            {
+                //  Volatile.Write(ref gate, 0);
+            }
+        }
+        return false;
+    }
+}
+
+[StructLayout(LayoutKind.Auto)]
+public struct TaskPoolEqualNull<T>
+    where T : class, ITaskPoolNode<T>
+{
+    int gate;
+    int size;
+    T root;
+
+    public int Size => size;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPop(out T result)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            var v = root;
+            if (v != null)
+            {
+                root = v.NextNode;
+                v.NextNode = null;
+                size--;
+                result = v;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+
+            Volatile.Write(ref gate, 0);
+        }
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPush(T item)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            //if (size < TaskPool.MaxPoolSize)
+            {
+                item.NextNode = root;
+                root = item;
+                size++;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+            //else
+            {
+                //  Volatile.Write(ref gate, 0);
+            }
+        }
+        return false;
+    }
+}
+
+public class TaskPoolClass<T>
+    where T : class, ITaskPoolNode<T>
+{
+    int gate;
+    int size;
+    T root;
+
+    public int Size => size;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPop(out T result)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            var v = root;
+            if (!(v is null))
+            {
+                root = v.NextNode;
+                v.NextNode = null;
+                size--;
+                result = v;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+
+            Volatile.Write(ref gate, 0);
+        }
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPush(T item)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            //if (size < TaskPool.MaxPoolSize)
+            {
+                item.NextNode = root;
+                root = item;
+                size++;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+            //else
+            {
+                //  Volatile.Write(ref gate, 0);
+            }
+        }
+        return false;
+    }
+}
+
+[StructLayout(LayoutKind.Auto)]
+public struct TaskPoolWithoutSize<T>
+    where T : class, ITaskPoolNode<T>
+{
+    int gate;
+    T root;
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPop(out T result)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            var v = root;
+            if (!(v is null))
+            {
+                root = v.NextNode;
+                v.NextNode = null;
+                result = v;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+
+            Volatile.Write(ref gate, 0);
+        }
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPush(T item)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            //if (size < TaskPool.MaxPoolSize)
+            {
+                item.NextNode = root;
+                root = item;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+            //else
+            {
+                //  Volatile.Write(ref gate, 0);
+            }
+        }
+        return false;
+    }
+}
--- a/src/UniTask.NetCoreSandbox/UniTask.NetCoreSandbox.csproj
+++ b/src/UniTask.NetCoreSandbox/UniTask.NetCoreSandbox.csproj
@@ -7,6 +7,8 @@
  </PropertyGroup>

  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+    <PackageReference Include="PooledAwait" Version="1.0.49" />
    <PackageReference Include="System.Interactive.Async" Version="4.1.1" />
    <PackageReference Include="System.Reactive" Version="4.4.1" />
  </ItemGroup>
--- a/src/UniTask.NetCoreTests/AsyncReactivePropertyTest.cs
+++ b/src/UniTask.NetCoreTests/AsyncReactivePropertyTest.cs
@@ -0,0 +1,118 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using Cysharp.Threading.Tasks.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests
+{
+    public class AsyncReactivePropertyTest
+    {
+        [Fact]
+        public async Task Iteration()
+        {
+            var rp = new AsyncReactiveProperty<int>(99);
+
+            var f = await rp.FirstAsync();
+            f.Should().Be(99);
+
+            var array = rp.Take(5).ToArrayAsync();
+
+            rp.Value = 100;
+            rp.Value = 100;
+            rp.Value = 100;
+            rp.Value = 131;
+
+            var ar = await array;
+
+            ar.Should().BeEquivalentTo(new[] { 99, 100, 100, 100, 131 });
+        }
+
+        [Fact]
+        public async Task WithoutCurrent()
+        {
+            var rp = new AsyncReactiveProperty<int>(99);
+
+            var array = rp.WithoutCurrent().Take(5).ToArrayAsync();
+
+            rp.Value = 100;
+            rp.Value = 100;
+            rp.Value = 100;
+            rp.Value = 131;
+            rp.Value = 191;
+
+            var ar = await array;
+
+            ar.Should().BeEquivalentTo(new[] { 100, 100, 100, 131, 191 });
+        }
+
+        //[Fact]
+        //public async Task StateIteration()
+        //{
+        //    var rp = new ReadOnlyAsyncReactiveProperty<int>(99);
+        //    var setter = rp.GetSetter();
+
+        //    var f = await rp.FirstAsync();
+        //    f.Should().Be(99);
+
+        //    var array = rp.Take(5).ToArrayAsync();
+
+        //    setter(100);
+        //    setter(100);
+        //    setter(100);
+        //    setter(131);
+
+        //    var ar = await array;
+
+        //    ar.Should().BeEquivalentTo(new[] { 99, 100, 100, 100, 131 });
+        //}
+
+        //[Fact]
+        //public async Task StateWithoutCurrent()
+        //{
+        //    var rp = new ReadOnlyAsyncReactiveProperty<int>(99);
+        //    var setter = rp.GetSetter();
+
+        //    var array = rp.WithoutCurrent().Take(5).ToArrayAsync();
+        //    setter(100);
+        //    setter(100);
+        //    setter(100);
+        //    setter(131);
+        //    setter(191);
+
+        //    var ar = await array;
+
+        //    ar.Should().BeEquivalentTo(new[] { 100, 100, 100, 131, 191 });
+        //}
+
+
+
+        [Fact]
+        public void StateFromEnumeration()
+        {
+            var rp = new AsyncReactiveProperty<int>(10);
+
+            var state = rp.ToReadOnlyAsyncReactiveProperty(CancellationToken.None);
+
+            rp.Value = 10;
+            state.Value.Should().Be(10);
+
+            rp.Value = 20;
+            state.Value.Should().Be(20);
+
+            state.Dispose();
+
+            rp.Value = 30;
+            state.Value.Should().Be(20);
+        }
+
+    }
+
+
+}
--- a/src/UniTask.NetCoreTests/CancellationTokenTest.cs
+++ b/src/UniTask.NetCoreTests/CancellationTokenTest.cs
@@ -0,0 +1,51 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using Cysharp.Threading.Tasks.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests
+{
+    public class CancellationTokenTest
+    {
+        [Fact]
+        public async Task WaitUntilCanceled()
+        {
+            var cts = new CancellationTokenSource();
+
+            cts.CancelAfter(TimeSpan.FromSeconds(1.5));
+
+            var now = DateTime.UtcNow;
+
+            await cts.Token.WaitUntilCanceled();
+
+            var elapsed = DateTime.UtcNow - now;
+
+            elapsed.Should().BeGreaterThan(TimeSpan.FromSeconds(1));
+        }
+
+        [Fact]
+        public void AlreadyCanceled()
+        {
+            var cts = new CancellationTokenSource();
+
+            cts.Cancel();
+
+            cts.Token.WaitUntilCanceled().GetAwaiter().IsCompleted.Should().BeTrue();
+        }
+
+        [Fact]
+        public void None()
+        {
+            CancellationToken.None.WaitUntilCanceled().GetAwaiter().IsCompleted.Should().BeTrue();
+        }
+    }
+
+
+}
--- a/src/UniTask.NetCoreTests/ChannelTest.cs
+++ b/src/UniTask.NetCoreTests/ChannelTest.cs
@@ -0,0 +1,370 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using Cysharp.Threading.Tasks.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests
+{
+    public class ChannelTest
+    {
+        (System.Threading.Channels.Channel<int>, Cysharp.Threading.Tasks.Channel<int>) CreateChannel()
+        {
+            var reference = System.Threading.Channels.Channel.CreateUnbounded<int>(new UnboundedChannelOptions
+            {
+                AllowSynchronousContinuations = true,
+                SingleReader = true,
+                SingleWriter = false
+            });
+
+            var channel = Cysharp.Threading.Tasks.Channel.CreateSingleConsumerUnbounded<int>();
+
+            return (reference, channel);
+        }
+
+        [Fact]
+        public async Task SingleWriteSingleRead()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                var t1 = reference.Reader.WaitToReadAsync();
+                var t2 = channel.Reader.WaitToReadAsync();
+
+                t1.IsCompleted.Should().BeFalse();
+                t2.Status.IsCompleted().Should().BeFalse();
+
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+
+                (await t1).Should().BeTrue();
+                (await t2).Should().BeTrue();
+
+                reference.Reader.TryRead(out var refitem).Should().BeTrue();
+                channel.Reader.TryRead(out var chanitem).Should().BeTrue();
+                refitem.Should().Be(item);
+                chanitem.Should().Be(item);
+            }
+        }
+
+        [Fact]
+        public async Task MultiWrite()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                var t1 = reference.Reader.WaitToReadAsync();
+                var t2 = channel.Reader.WaitToReadAsync();
+
+                t1.IsCompleted.Should().BeFalse();
+                t2.Status.IsCompleted().Should().BeFalse();
+
+                foreach (var i in Enumerable.Range(1, 3))
+                {
+                    reference.Writer.TryWrite(item * i);
+                    channel.Writer.TryWrite(item * i);
+                }
+
+                (await t1).Should().BeTrue();
+                (await t2).Should().BeTrue();
+
+                foreach (var i in Enumerable.Range(1, 3))
+                {
+                    (await reference.Reader.WaitToReadAsync()).Should().BeTrue();
+                    (await channel.Reader.WaitToReadAsync()).Should().BeTrue();
+
+                    reference.Reader.TryRead(out var refitem).Should().BeTrue();
+                    channel.Reader.TryRead(out var chanitem).Should().BeTrue();
+                    refitem.Should().Be(item * i);
+                    chanitem.Should().Be(item * i);
+                }
+            }
+        }
+
+        [Fact]
+        public async Task CompleteOnEmpty()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+                reference.Reader.TryRead(out var refitem);
+                channel.Reader.TryRead(out var chanitem);
+            }
+
+            // Empty.
+
+            var completion1 = reference.Reader.Completion;
+            var wait1 = reference.Reader.WaitToReadAsync();
+
+            var completion2 = channel.Reader.Completion;
+            var wait2 = channel.Reader.WaitToReadAsync();
+
+            reference.Writer.TryComplete();
+            channel.Writer.TryComplete();
+
+            completion1.Status.Should().Be(TaskStatus.RanToCompletion);
+            completion2.Status.Should().Be(UniTaskStatus.Succeeded);
+
+            (await wait1).Should().BeFalse();
+            (await wait2).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task CompleteErrorOnEmpty()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+                reference.Reader.TryRead(out var refitem);
+                channel.Reader.TryRead(out var chanitem);
+            }
+
+            // Empty.
+
+            var completion1 = reference.Reader.Completion;
+            var wait1 = reference.Reader.WaitToReadAsync();
+
+            var completion2 = channel.Reader.Completion;
+            var wait2 = channel.Reader.WaitToReadAsync();
+
+            var ex = new Exception();
+            reference.Writer.TryComplete(ex);
+            channel.Writer.TryComplete(ex);
+
+            completion1.Status.Should().Be(TaskStatus.Faulted);
+            completion2.Status.Should().Be(UniTaskStatus.Faulted);
+
+            (await Assert.ThrowsAsync<Exception>(async () => await wait1)).Should().Be(ex);
+            (await Assert.ThrowsAsync<Exception>(async () => await wait2)).Should().Be(ex);
+        }
+
+        [Fact]
+        public async Task CompleteWithRest()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+            }
+
+            // Three Item2.
+
+            var completion1 = reference.Reader.Completion;
+            var wait1 = reference.Reader.WaitToReadAsync();
+
+            var completion2 = channel.Reader.Completion;
+            var wait2 = channel.Reader.WaitToReadAsync();
+
+            reference.Writer.TryComplete();
+            channel.Writer.TryComplete();
+
+            // completion1.Status.Should().Be(TaskStatus.WaitingForActivation);
+            completion2.Status.Should().Be(UniTaskStatus.Pending);
+
+            (await wait1).Should().BeTrue();
+            (await wait2).Should().BeTrue();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Reader.TryRead(out var i1).Should().BeTrue();
+                channel.Reader.TryRead(out var i2).Should().BeTrue();
+                i1.Should().Be(item);
+                i2.Should().Be(item);
+            }
+
+            (await reference.Reader.WaitToReadAsync()).Should().BeFalse();
+            (await channel.Reader.WaitToReadAsync()).Should().BeFalse();
+
+            completion1.Status.Should().Be(TaskStatus.RanToCompletion);
+            completion2.Status.Should().Be(UniTaskStatus.Succeeded);
+        }
+
+
+        [Fact]
+        public async Task CompleteErrorWithRest()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+            }
+
+            // Three Item2.
+
+            var completion1 = reference.Reader.Completion;
+            var wait1 = reference.Reader.WaitToReadAsync();
+
+            var completion2 = channel.Reader.Completion;
+            var wait2 = channel.Reader.WaitToReadAsync();
+
+            var ex = new Exception();
+            reference.Writer.TryComplete(ex);
+            channel.Writer.TryComplete(ex);
+
+            // completion1.Status.Should().Be(TaskStatus.WaitingForActivation);
+            completion2.Status.Should().Be(UniTaskStatus.Pending);
+
+            (await wait1).Should().BeTrue();
+            (await wait2).Should().BeTrue();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Reader.TryRead(out var i1).Should().BeTrue();
+                channel.Reader.TryRead(out var i2).Should().BeTrue();
+                i1.Should().Be(item);
+                i2.Should().Be(item);
+            }
+
+            wait1 = reference.Reader.WaitToReadAsync();
+            wait2 = channel.Reader.WaitToReadAsync();
+
+            (await Assert.ThrowsAsync<Exception>(async () => await wait1)).Should().Be(ex);
+            (await Assert.ThrowsAsync<Exception>(async () => await wait2)).Should().Be(ex);
+
+            completion1.Status.Should().Be(TaskStatus.Faulted);
+            completion2.Status.Should().Be(UniTaskStatus.Faulted);
+        }
+
+        [Fact]
+        public async Task Cancellation()
+        {
+            var (reference, channel) = CreateChannel();
+
+            var cts = new CancellationTokenSource();
+
+            var wait1 = reference.Reader.WaitToReadAsync(cts.Token);
+            var wait2 = channel.Reader.WaitToReadAsync(cts.Token);
+
+            cts.Cancel();
+
+            (await Assert.ThrowsAsync<OperationCanceledException>(async () => await wait1)).CancellationToken.Should().Be(cts.Token);
+            (await Assert.ThrowsAsync<OperationCanceledException>(async () => await wait2)).CancellationToken.Should().Be(cts.Token);
+        }
+
+        [Fact]
+        public async Task AsyncEnumerator()
+        {
+            var (reference, channel) = CreateChannel();
+
+            var ta1 = reference.Reader.ReadAllAsync().ToArrayAsync();
+            var ta2 = channel.Reader.ReadAllAsync().ToArrayAsync();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+            }
+
+            reference.Writer.TryComplete();
+            channel.Writer.TryComplete();
+
+            (await ta1).Should().BeEquivalentTo(new[] { 10, 20, 30 });
+            (await ta2).Should().BeEquivalentTo(new[] { 10, 20, 30 });
+        }
+
+        [Fact]
+        public async Task AsyncEnumeratorCancellation()
+        {
+            // Token1, Token2 and Cancel1
+            {
+                var cts1 = new CancellationTokenSource();
+                var cts2 = new CancellationTokenSource();
+
+                var (reference, channel) = CreateChannel();
+
+                var ta1 = reference.Reader.ReadAllAsync(cts1.Token).ToArrayAsync(cts2.Token);
+                var ta2 = channel.Reader.ReadAllAsync(cts1.Token).ToArrayAsync(cts2.Token);
+
+                foreach (var item in new[] { 10, 20, 30 })
+                {
+                    reference.Writer.TryWrite(item);
+                    channel.Writer.TryWrite(item);
+                }
+
+                cts1.Cancel();
+
+                await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta1);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta2)).CancellationToken.Should().Be(cts1.Token);
+            }
+            // Token1, Token2 and Cancel2
+            {
+                var cts1 = new CancellationTokenSource();
+                var cts2 = new CancellationTokenSource();
+
+                var (reference, channel) = CreateChannel();
+
+                var ta1 = reference.Reader.ReadAllAsync(cts1.Token).ToArrayAsync(cts2.Token);
+                var ta2 = channel.Reader.ReadAllAsync(cts1.Token).ToArrayAsync(cts2.Token);
+
+                foreach (var item in new[] { 10, 20, 30 })
+                {
+                    reference.Writer.TryWrite(item);
+                    channel.Writer.TryWrite(item);
+                }
+
+                cts2.Cancel();
+
+                await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta1);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta2)).CancellationToken.Should().Be(cts2.Token);
+            }
+            // Token1 and Cancel1
+            {
+                var cts1 = new CancellationTokenSource();
+
+                var (reference, channel) = CreateChannel();
+
+                var ta1 = reference.Reader.ReadAllAsync(cts1.Token).ToArrayAsync();
+                var ta2 = channel.Reader.ReadAllAsync(cts1.Token).ToArrayAsync();
+
+                foreach (var item in new[] { 10, 20, 30 })
+                {
+                    reference.Writer.TryWrite(item);
+                    channel.Writer.TryWrite(item);
+                }
+
+                cts1.Cancel();
+
+                await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta1);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta2)).CancellationToken.Should().Be(cts1.Token);
+            }
+            // Token2 and Cancel2
+            {
+                var cts2 = new CancellationTokenSource();
+
+                var (reference, channel) = CreateChannel();
+
+                var ta1 = reference.Reader.ReadAllAsync().ToArrayAsync(cts2.Token);
+                var ta2 = channel.Reader.ReadAllAsync().ToArrayAsync(cts2.Token);
+
+                foreach (var item in new[] { 10, 20, 30 })
+                {
+                    reference.Writer.TryWrite(item);
+                    channel.Writer.TryWrite(item);
+                }
+
+                cts2.Cancel();
+
+                await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta1);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta2)).CancellationToken.Should().Be(cts2.Token);
+            }
+        }
+    }
+}
--- a/src/UniTask.NetCoreTests/DeferTest.cs
+++ b/src/UniTask.NetCoreTests/DeferTest.cs
@@ -0,0 +1,47 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using Cysharp.Threading.Tasks.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests
+{
+    public class DeferTest
+    {
+        [Fact]
+        public async Task D()
+        {
+            var created = false;
+            var v = UniTask.Defer(() => { created = true; return UniTask.Run(() => 10); });
+
+            created.Should().BeFalse();
+
+            var t = await v;
+
+            created.Should().BeTrue();
+
+            t.Should().Be(10);
+        }
+
+        [Fact]
+        public async Task D2()
+        {
+            var created = false;
+            var v = UniTask.Defer(() => { created = true; return UniTask.Run(() => 10).AsUniTask(); });
+
+            created.Should().BeFalse();
+
+            await v;
+
+            created.Should().BeTrue();
+        }
+    }
+
+
+}
--- a/src/UniTask.NetCoreTests/Linq/Projection.cs
+++ b/src/UniTask.NetCoreTests/Linq/Projection.cs
@@ -319,5 +319,119 @@ namespace NetCoreTests.Linq
                await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
            }
        }
+
+        [Fact]
+        public async Task CombineLatestOK()
+        {
+            var a = new AsyncReactiveProperty<int>(0);
+            var b = new AsyncReactiveProperty<int>(0);
+
+            var list = new List<(int, int)>();
+            var complete = a.WithoutCurrent().CombineLatest(b.WithoutCurrent(), (x, y) => (x, y)).ForEachAsync(x => list.Add(x));
+
+            list.Count.Should().Be(0);
+
+            a.Value = 10;
+            list.Count.Should().Be(0);
+
+            a.Value = 20;
+            list.Count.Should().Be(0);
+
+            b.Value = 1;
+            list.Count.Should().Be(1);
+
+            list[0].Should().Be((20, 1));
+
+            a.Value = 30;
+            list.Last().Should().Be((30, 1));
+
+            b.Value = 2;
+            list.Last().Should().Be((30, 2));
+
+            a.Dispose();
+            b.Value = 3;
+            list.Last().Should().Be((30, 3));
+
+            b.Dispose();
+
+            await complete;
+        }
+
+        [Fact]
+        public async Task CombineLatestLong()
+        {
+            var a = UniTaskAsyncEnumerable.Range(1, 100000);
+            var b = new AsyncReactiveProperty<int>(0);
+
+            var list = new List<(int, int)>();
+            var complete = a.CombineLatest(b.WithoutCurrent(), (x, y) => (x, y)).ForEachAsync(x => list.Add(x));
+
+            b.Value = 1;
+
+            list[0].Should().Be((100000, 1));
+
+            b.Dispose();
+
+            await complete;
+        }
+
+        [Fact]
+        public async Task CombineLatestError()
+        {
+            var a = new AsyncReactiveProperty<int>(0);
+            var b = new AsyncReactiveProperty<int>(0);
+
+            var list = new List<(int, int)>();
+            var complete = a.WithoutCurrent()
+                .Select(x => { if (x == 0) { throw new MyException(); } return x; })
+                .CombineLatest(b.WithoutCurrent(), (x, y) => (x, y)).ForEachAsync(x => list.Add(x));
+
+
+            a.Value = 10;
+            b.Value = 1;
+            list.Last().Should().Be((10, 1));
+
+            a.Value = 0;
+
+            await Assert.ThrowsAsync<MyException>(async () => await complete);
+        }
+
+
+
+        [Fact]
+        public async Task PariwiseImmediate()
+        {
+            var xs = await UniTaskAsyncEnumerable.Range(1, 5).Pairwise().ToArrayAsync();
+            xs.Should().BeEquivalentTo((1, 2), (2, 3), (3, 4), (4, 5));
+        }
+
+        [Fact]
+        public async Task Pariwise()
+        {
+            var a = new AsyncReactiveProperty<int>(0);
+
+            var list = new List<(int, int)>();
+            var complete = a.WithoutCurrent().Pairwise().ForEachAsync(x => list.Add(x));
+
+            list.Count.Should().Be(0);
+            a.Value = 10;
+            list.Count.Should().Be(0);
+            a.Value = 20;
+            list.Count.Should().Be(1);
+            a.Value = 30;
+            a.Value = 40;
+            a.Value = 50;
+
+            a.Dispose();
+
+            await complete;
+
+            list.Should().BeEquivalentTo((10, 20), (20, 30), (30, 40), (40, 50));
+        }
+
+        class MyException : Exception
+        {
+
+        }
    }
 }
--- a/src/UniTask.NetCoreTests/Linq/PulbishTest.cs
+++ b/src/UniTask.NetCoreTests/Linq/PulbishTest.cs
@@ -0,0 +1,78 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class PublishTest
+    {
+        [Fact]
+        public async Task Normal()
+        {
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var multicast = rp.Publish();
+
+            var a = multicast.ToArrayAsync();
+            var b = multicast.Take(2).ToArrayAsync();
+
+            var disp = multicast.Connect();
+
+            rp.Value = 2;
+
+            (await b).Should().BeEquivalentTo(1, 2);
+
+            var c = multicast.ToArrayAsync();
+
+            rp.Value = 3;
+            rp.Value = 4;
+            rp.Value = 5;
+
+            rp.Dispose();
+
+            (await a).Should().BeEquivalentTo(1, 2, 3, 4, 5);
+            (await c).Should().BeEquivalentTo(3, 4, 5);
+
+            disp.Dispose();
+        }
+
+        [Fact]
+        public async Task Cancel()
+        {
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var multicast = rp.Publish();
+
+            var a = multicast.ToArrayAsync();
+            var b = multicast.Take(2).ToArrayAsync();
+
+            var disp = multicast.Connect();
+
+            rp.Value = 2;
+
+            (await b).Should().BeEquivalentTo(1, 2);
+
+            var c = multicast.ToArrayAsync();
+
+            rp.Value = 3;
+
+            disp.Dispose();
+
+            rp.Value = 4;
+            rp.Value = 5;
+
+            rp.Dispose();
+
+            await Assert.ThrowsAsync<OperationCanceledException>(async () => await a);
+            await Assert.ThrowsAsync<OperationCanceledException>(async () => await c);
+        }
+
+
+    }
+}
--- a/src/UniTask.NetCoreTests/Linq/QueueTest.cs
+++ b/src/UniTask.NetCoreTests/Linq/QueueTest.cs
@@ -0,0 +1,29 @@
+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 QueueTest
+    {
+        [Fact]
+        public async Task Q()
+        {
+            var rp = new AsyncReactiveProperty<int>(100);
+
+            var l = new List<int>();
+            await rp.Take(10).Queue().ForEachAsync(x =>
+            {
+                rp.Value += 10;
+                l.Add(x);
+            });
+
+            l.Should().BeEquivalentTo(100, 110, 120, 130, 140, 150, 160, 170, 180, 190);
+        }
+    }
+}
--- a/src/UniTask.NetCoreTests/Linq/TakeInfinityTest.cs
+++ b/src/UniTask.NetCoreTests/Linq/TakeInfinityTest.cs
@@ -0,0 +1,106 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class TakeInfinityTest
+    {
+        [Fact]
+        public async Task Take()
+        {
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.Take(5).ToArrayAsync();
+
+            rp.Value = 2;
+            rp.Value = 3;
+            rp.Value = 4;
+            rp.Value = 5;
+
+            (await xs).Should().BeEquivalentTo(1, 2, 3, 4, 5);
+        }
+
+        [Fact]
+        public async Task TakeWhile()
+        {
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.TakeWhile(x => x != 5).ToArrayAsync();
+
+            rp.Value = 2;
+            rp.Value = 3;
+            rp.Value = 4;
+            rp.Value = 5;
+
+            (await xs).Should().BeEquivalentTo(1, 2, 3, 4);
+        }
+
+        [Fact]
+        public async Task TakeUntil()
+        {
+            var cts = new CancellationTokenSource();
+
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.TakeUntilCanceled(cts.Token).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.Cancel();
+                rp.Value = 30;
+                await Task.Yield();
+                rp.Value = 40;
+            }
+        }
+
+        [Fact]
+        public async Task SkipUntil()
+        {
+            var cts = new CancellationTokenSource();
+
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.SkipUntilCanceled(cts.Token).ToArrayAsync();
+
+            var c = CancelAsync();
+
+            await c;
+            var foo = await xs;
+
+            foo.Should().BeEquivalentTo(new[] { 30, 40 });
+
+            async Task CancelAsync()
+            {
+                rp.Value = 10;
+                await Task.Yield();
+                rp.Value = 20;
+                await Task.Yield();
+                cts.Cancel();
+                rp.Value = 30;
+                await Task.Yield();
+                rp.Value = 40;
+
+                rp.Dispose(); // complete.
+            }
+        }
+
+    }
+}
--- a/src/UniTask.NetCoreTests/TaskBuilderCases.cs
+++ b/src/UniTask.NetCoreTests/TaskBuilderCases.cs
@@ -0,0 +1,301 @@
+#pragma warning disable CS1998 
+
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using Cysharp.Threading.Tasks.Linq;
+using System.Threading.Tasks;
+using Xunit;
+using System.Runtime.CompilerServices;
+
+namespace NetCoreTests
+{
+    public class UniTaskBuilderTest
+    {
+        [Fact]
+        public async Task Empty()
+        {
+            await Core();
+
+            static async UniTask Core()
+            {
+            }
+        }
+
+        [Fact]
+        public async Task EmptyThrow()
+        {
+            await Assert.ThrowsAsync<TaskTestException>(async () => await Core());
+
+            static async UniTask Core()
+            {
+                throw new TaskTestException();
+            }
+        }
+
+        [Fact]
+        public async Task Task_Done()
+        {
+            await Core();
+
+            static async UniTask Core()
+            {
+                await new TestAwaiter(true, UniTaskStatus.Succeeded);
+            }
+        }
+
+        [Fact]
+        public async Task Task_Fail()
+        {
+            await Assert.ThrowsAsync<TaskTestException>(async () => await Core());
+
+            static async UniTask Core()
+            {
+                await new TestAwaiter(true, UniTaskStatus.Faulted);
+            }
+        }
+
+        [Fact]
+        public async Task Task_Cancel()
+        {
+            await Assert.ThrowsAsync<OperationCanceledException>(async () => await Core());
+
+            static async UniTask Core()
+            {
+                await new TestAwaiter(true, UniTaskStatus.Canceled);
+            }
+        }
+
+        [Fact]
+        public async Task AwaitUnsafeOnCompletedCall_Task_SetResult()
+        {
+            await Core();
+
+            static async UniTask Core()
+            {
+                await new TestAwaiter(false, UniTaskStatus.Succeeded);
+                await new TestAwaiter(false, UniTaskStatus.Succeeded);
+                await new TestAwaiter(false, UniTaskStatus.Succeeded);
+            }
+        }
+
+        [Fact]
+        public async Task AwaitUnsafeOnCompletedCall_Task_SetException()
+        {
+            await Assert.ThrowsAsync<TaskTestException>(async () => await Core());
+
+            static async UniTask Core()
+            {
+                await new TestAwaiter(false, UniTaskStatus.Succeeded);
+                await new TestAwaiter(false, UniTaskStatus.Faulted);
+                throw new InvalidOperationException();
+            }
+        }
+
+        [Fact]
+        public async Task AwaitUnsafeOnCompletedCall_Task_SetCancelException()
+        {
+            await Assert.ThrowsAsync<OperationCanceledException>(async () => await Core());
+
+            static async UniTask Core()
+            {
+                await new TestAwaiter(false, UniTaskStatus.Succeeded);
+                await new TestAwaiter(false, UniTaskStatus.Canceled);
+                throw new InvalidOperationException();
+            }
+        }
+    }
+
+    public class UniTask_T_BuilderTest
+    {
+        [Fact]
+        public async Task Empty()
+        {
+            (await Core()).Should().Be(10);
+
+            static async UniTask<int> Core()
+            {
+                return 10;
+            }
+        }
+
+        [Fact]
+        public async Task EmptyThrow()
+        {
+            await Assert.ThrowsAsync<TaskTestException>(async () => await Core());
+
+            static async UniTask<int> Core()
+            {
+                throw new TaskTestException();
+            }
+        }
+
+        [Fact]
+        public async Task Task_Done()
+        {
+            (await Core()).Should().Be(10);
+
+            static async UniTask<int> Core()
+            {
+                return await new TestAwaiter<int>(true, UniTaskStatus.Succeeded, 10);
+            }
+        }
+
+        [Fact]
+        public async Task Task_Fail()
+        {
+            await Assert.ThrowsAsync<TaskTestException>(async () => await Core());
+
+            static async UniTask<int> Core()
+            {
+                return await new TestAwaiter<int>(true, UniTaskStatus.Faulted, 10);
+            }
+        }
+
+        [Fact]
+        public async Task Task_Cancel()
+        {
+            await Assert.ThrowsAsync<OperationCanceledException>(async () => await Core());
+
+            static async UniTask<int> Core()
+            {
+                return await new TestAwaiter<int>(true, UniTaskStatus.Canceled, 10);
+            }
+        }
+
+        [Fact]
+        public async Task AwaitUnsafeOnCompletedCall_Task_SetResult()
+        {
+            (await Core()).Should().Be(6);
+
+            static async UniTask<int> Core()
+            {
+                var sum = 0;
+                sum += await new TestAwaiter<int>(false, UniTaskStatus.Succeeded, 1);
+                sum += await new TestAwaiter<int>(false, UniTaskStatus.Succeeded, 2);
+                sum += await new TestAwaiter<int>(false, UniTaskStatus.Succeeded, 3);
+                return sum;
+            }
+        }
+
+        [Fact]
+        public async Task AwaitUnsafeOnCompletedCall_Task_SetException()
+        {
+            await Assert.ThrowsAsync<TaskTestException>(async () => await Core());
+
+            static async UniTask<int> Core()
+            {
+                await new TestAwaiter<int>(false, UniTaskStatus.Succeeded, 10);
+                await new TestAwaiter<int>(false, UniTaskStatus.Faulted, 10);
+                throw new InvalidOperationException();
+            }
+        }
+
+        [Fact]
+        public async Task AwaitUnsafeOnCompletedCall_Task_SetCancelException()
+        {
+            await Assert.ThrowsAsync<OperationCanceledException>(async () => await Core());
+
+            static async UniTask<int> Core()
+            {
+                await new TestAwaiter<int>(false, UniTaskStatus.Succeeded, 10);
+                await new TestAwaiter<int>(false, UniTaskStatus.Canceled, 10);
+                throw new InvalidOperationException();
+            }
+        }
+    }
+
+    public class TaskTestException : Exception
+    {
+
+    }
+
+    public struct TestAwaiter : ICriticalNotifyCompletion
+    {
+        readonly UniTaskStatus status;
+        readonly bool isCompleted;
+
+        public TestAwaiter(bool isCompleted, UniTaskStatus status)
+        {
+            this.isCompleted = isCompleted;
+            this.status = status;
+        }
+
+        public TestAwaiter GetAwaiter() => this;
+
+        public bool IsCompleted => isCompleted;
+
+        public void GetResult()
+        {
+            switch (status)
+            {
+                case UniTaskStatus.Faulted:
+                    throw new TaskTestException();
+                case UniTaskStatus.Canceled:
+                    throw new OperationCanceledException();
+                case UniTaskStatus.Pending:
+                case UniTaskStatus.Succeeded:
+                default:
+                    break;
+            }
+        }
+
+        public void OnCompleted(Action continuation)
+        {
+            ThreadPool.QueueUserWorkItem(_ => continuation(), null);
+        }
+
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            ThreadPool.UnsafeQueueUserWorkItem(_ => continuation(), null);
+        }
+    }
+
+    public struct TestAwaiter<T> : ICriticalNotifyCompletion
+    {
+        readonly UniTaskStatus status;
+        readonly bool isCompleted;
+        readonly T value;
+
+        public TestAwaiter(bool isCompleted, UniTaskStatus status, T value)
+        {
+            this.isCompleted = isCompleted;
+            this.status = status;
+            this.value = value;
+        }
+
+        public TestAwaiter<T> GetAwaiter() => this;
+
+        public bool IsCompleted => isCompleted;
+
+        public T GetResult()
+        {
+            switch (status)
+            {
+                case UniTaskStatus.Faulted:
+                    throw new TaskTestException();
+                case UniTaskStatus.Canceled:
+                    throw new OperationCanceledException();
+                case UniTaskStatus.Pending:
+                case UniTaskStatus.Succeeded:
+                default:
+                    return value;
+            }
+        }
+
+        public void OnCompleted(Action continuation)
+        {
+            ThreadPool.QueueUserWorkItem(_ => continuation(), null);
+        }
+
+        public void UnsafeOnCompleted(Action continuation)
+        {
+            ThreadPool.UnsafeQueueUserWorkItem(_ => continuation(), null);
+        }
+    }
+}
--- a/src/UniTask.NetCoreTests/TriggerEventTest.cs
+++ b/src/UniTask.NetCoreTests/TriggerEventTest.cs
@@ -0,0 +1,637 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using Cysharp.Threading.Tasks.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests
+{
+    public class TriggerEventTest
+    {
+        [Fact]
+        public void SimpleAdd()
+        {
+            var ev = new TriggerEvent<int>();
+
+            // do nothing
+            ev.SetResult(0);
+            ev.SetError(null);
+            ev.SetCompleted();
+            ev.SetCanceled(default);
+
+            {
+                var one = new TestEvent(1);
+
+                ev.Add(one);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+
+                ev.SetCompleted();
+
+                one.CompletedCalled.Count.Should().Be(1);
+
+                // do nothing
+                ev.SetResult(0);
+                ev.SetError(null);
+                ev.SetCompleted();
+                ev.SetCanceled(default);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.CompletedCalled.Count.Should().Be(1);
+            }
+            // after removed, onemore
+            {
+                var one = new TestEvent(1);
+
+                ev.Add(one);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+
+                ev.SetCompleted();
+
+                one.CompletedCalled.Count.Should().Be(1);
+
+                // do nothing
+                ev.SetResult(0);
+                ev.SetError(null);
+                ev.SetCompleted();
+                ev.SetCanceled(default);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.CompletedCalled.Count.Should().Be(1);
+            }
+        }
+
+        [Fact]
+        public void AddFour()
+        {
+            var ev = new TriggerEvent<int>();
+
+            // do nothing
+            ev.SetResult(0);
+            ev.SetError(null);
+            ev.SetCompleted();
+            ev.SetCanceled(default);
+
+            {
+                var one = new TestEvent(1);
+                var two = new TestEvent(2);
+                var three = new TestEvent(3);
+                var four = new TestEvent(4);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+                ev.Add(four);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                four.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+
+                ev.SetCompleted();
+
+                one.CompletedCalled.Count.Should().Be(1);
+                two.CompletedCalled.Count.Should().Be(1);
+                three.CompletedCalled.Count.Should().Be(1);
+
+
+                // do nothing
+                ev.SetResult(0);
+                ev.SetError(null);
+                ev.SetCompleted();
+                ev.SetCanceled(default);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.CompletedCalled.Count.Should().Be(1);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.CompletedCalled.Count.Should().Be(1);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.CompletedCalled.Count.Should().Be(1);
+            }
+
+            // after removed, onemore.
+            {
+                var one = new TestEvent(1);
+                var two = new TestEvent(2);
+                var three = new TestEvent(3);
+                var four = new TestEvent(4);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+                ev.Add(four);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+                ev.Add(four);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                four.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+
+                ev.SetCompleted();
+
+                one.CompletedCalled.Count.Should().Be(1);
+                two.CompletedCalled.Count.Should().Be(1);
+                three.CompletedCalled.Count.Should().Be(1);
+
+
+                // do nothing
+                ev.SetResult(0);
+                ev.SetError(null);
+                ev.SetCompleted();
+                ev.SetCanceled(default);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.CompletedCalled.Count.Should().Be(1);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.CompletedCalled.Count.Should().Be(1);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.CompletedCalled.Count.Should().Be(1);
+            }
+        }
+
+
+        [Fact]
+        public void OneRemove()
+        {
+            var ev = new TriggerEvent<int>();
+            {
+                var one = new TestEvent(1);
+                var two = new TestEvent(2);
+                var three = new TestEvent(3);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+
+                ev.Remove(one);
+
+                ev.SetResult(40);
+                ev.SetResult(50);
+                ev.SetResult(60);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
+            }
+        }
+        [Fact]
+        public void TwoRemove()
+        {
+            var ev = new TriggerEvent<int>();
+            {
+                var one = new TestEvent(1);
+                var two = new TestEvent(2);
+                var three = new TestEvent(3);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+
+                ev.Remove(two);
+
+                ev.SetResult(40);
+                ev.SetResult(50);
+                ev.SetResult(60);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
+            }
+        }
+        [Fact]
+        public void ThreeRemove()
+        {
+            var ev = new TriggerEvent<int>();
+            {
+                var one = new TestEvent(1);
+                var two = new TestEvent(2);
+                var three = new TestEvent(3);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+
+                ev.Remove(three);
+
+                ev.SetResult(40);
+                ev.SetResult(50);
+                ev.SetResult(60);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+        }
+
+        [Fact]
+        public void RemoveSelf()
+        {
+            new RemoveMe().Run1();
+            new RemoveMe().Run2();
+            new RemoveMe().Run3();
+        }
+
+        [Fact]
+        public void RemoveNextInIterating()
+        {
+            new RemoveNext().Run1();
+            new RemoveNext().Run2();
+            new RemoveNext().Run3();
+        }
+
+        [Fact]
+        public void RemoveNextNextTest()
+        {
+            new RemoveNextNext().Run1();
+            new RemoveNextNext().Run2();
+        }
+
+
+        [Fact]
+        public void AddTest()
+        {
+            new AddMe().Run1();
+            new AddMe().Run2();
+        }
+
+        public class RemoveMe
+        {
+            TriggerEvent<int> ev;
+
+            public void Run1()
+            {
+                TestEvent one = default;
+                one = new TestEvent(1, () => ev.Remove(one));
+
+                var two = new TestEvent(2);
+                var three = new TestEvent(3);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+
+            public void Run2()
+            {
+                TestEvent one = default;
+                one = new TestEvent(1, () => ev.Remove(one));
+
+                var two = new TestEvent(2);
+                var three = new TestEvent(3);
+
+                ev.Add(two);
+                ev.Add(one); // add second.
+                ev.Add(three);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+
+            public void Run3()
+            {
+                TestEvent one = default;
+                one = new TestEvent(1, () => ev.Remove(one));
+
+                var two = new TestEvent(2);
+                var three = new TestEvent(3);
+
+                ev.Add(two);
+                ev.Add(three);
+                ev.Add(one); // add thired.
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10);
+                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+        }
+
+        public class RemoveNext
+        {
+            TriggerEvent<int> ev;
+
+            public void Run1()
+            {
+                TestEvent one = default;
+                TestEvent two = default;
+                TestEvent three = default;
+                one = new TestEvent(1, () => ev.Remove(two));
+                two = new TestEvent(2);
+                three = new TestEvent(3);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Count.Should().Be(0);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+
+            public void Run2()
+            {
+                TestEvent one = default;
+                TestEvent two = default;
+                TestEvent three = default;
+                one = new TestEvent(1, () => ev.Remove(two));
+                two = new TestEvent(2);
+                three = new TestEvent(3);
+
+                ev.Add(two);
+                ev.Add(one); // add second
+                ev.Add(three);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().BeEquivalentTo(10);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+
+            public void Run3()
+            {
+                TestEvent one = default;
+                TestEvent two = default;
+                TestEvent three = default;
+                one = new TestEvent(1, () => ev.Remove(two));
+                two = new TestEvent(2);
+                three = new TestEvent(3);
+
+                ev.Add(two);
+                ev.Add(three);
+                ev.Add(one); // add thired.
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().BeEquivalentTo(10);
+                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+        }
+
+        public class RemoveNextNext
+        {
+            TriggerEvent<int> ev;
+
+            public void Run1()
+            {
+                TestEvent one = default;
+                TestEvent two = default;
+                TestEvent three = default;
+                TestEvent four = default;
+                one = new TestEvent(1, () => { ev.Remove(two); ev.Remove(three); });
+                two = new TestEvent(2);
+                three = new TestEvent(3);
+                four = new TestEvent(4);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+                ev.Add(four);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Count.Should().Be(0);
+                three.NextCalled.Count.Should().Be(0);
+                four.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+
+            public void Run2()
+            {
+                TestEvent one = default;
+                TestEvent two = default;
+                TestEvent three = default;
+                TestEvent four = default;
+                one = new TestEvent(1, () => { ev.Remove(one); ev.Remove(two); ev.Remove(three); });
+                two = new TestEvent(2);
+                three = new TestEvent(3);
+                four = new TestEvent(4);
+
+                ev.Add(one);
+                ev.Add(two);
+                ev.Add(three);
+                ev.Add(four);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+
+                one.NextCalled.Should().BeEquivalentTo(10);
+                two.NextCalled.Count.Should().Be(0);
+                three.NextCalled.Count.Should().Be(0);
+                four.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+            }
+
+
+        }
+
+        public class AddMe
+        {
+            TriggerEvent<int> ev;
+
+            public void Run1()
+            {
+                TestEvent one = default;
+                TestEvent two = default;
+                TestEvent three = default;
+                TestEvent four = default;
+
+                one = new TestEvent(1, () =>
+                {
+                    if (two == null)
+                    {
+                        ev.Add(two = new TestEvent(2));
+                    }
+                    else if (three == null)
+                    {
+                        ev.Add(three = new TestEvent(3));
+                    }
+                    else if (four == null)
+                    {
+                        ev.Add(four = new TestEvent(4));
+                    }
+                });
+
+                ev.Add(one);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+                ev.SetResult(40);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40);
+                two.NextCalled.Should().BeEquivalentTo(20, 30, 40);
+                three.NextCalled.Should().BeEquivalentTo(30, 40);
+                four.NextCalled.Should().BeEquivalentTo(40);
+            }
+
+            public void Run2()
+            {
+                TestEvent one = default;
+                TestEvent two = default;
+                TestEvent three = default;
+                TestEvent four = default;
+
+                one = new TestEvent(1, () =>
+                {
+                    if (two == null)
+                    {
+                        ev.Add(two = new TestEvent(2, () =>
+                        {
+                            if (three == null)
+                            {
+                                ev.Add(three = new TestEvent(3, () =>
+                                {
+                                    if (four == null)
+                                    {
+                                        ev.Add(four = new TestEvent(4));
+                                    }
+                                }));
+                            }
+                        }));
+                    }
+                });
+
+                ev.Add(one);
+
+                ev.SetResult(10);
+                ev.SetResult(20);
+                ev.SetResult(30);
+                ev.SetResult(40);
+
+                one.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40);
+                two.NextCalled.Should().BeEquivalentTo(20, 30, 40);
+                three.NextCalled.Should().BeEquivalentTo(30, 40);
+                four.NextCalled.Should().BeEquivalentTo(40);
+            }
+        }
+    }
+
+    public class TestEvent : ITriggerHandler<int>
+    {
+        public readonly int Id;
+        readonly Action iteratingEvent;
+
+        public TestEvent(int id)
+        {
+            this.Id = id;
+        }
+
+        public TestEvent(int id, Action iteratingEvent)
+        {
+            this.Id = id;
+            this.iteratingEvent = iteratingEvent;
+        }
+
+        public List<int> NextCalled = new List<int>();
+        public List<Exception> ErrorCalled = new List<Exception>();
+        public List<object> CompletedCalled = new List<object>();
+        public List<CancellationToken> CancelCalled = new List<CancellationToken>();
+
+        public ITriggerHandler<int> Prev { get; set; }
+        public ITriggerHandler<int> Next { get; set; }
+
+        public void OnCanceled(CancellationToken cancellationToken)
+        {
+            CancelCalled.Add(cancellationToken);
+
+        }
+
+        public void OnCompleted()
+        {
+            CompletedCalled.Add(new object());
+        }
+
+        public void OnError(Exception ex)
+        {
+            ErrorCalled.Add(ex);
+        }
+
+        public void OnNext(int value)
+        {
+            NextCalled.Add(value);
+            iteratingEvent?.Invoke();
+        }
+
+        public override string ToString()
+        {
+            return Id.ToString();
+        }
+    }
+
+
+}
--- a/src/UniTask/Assets/Editor/EditorRunnerChecker.cs
+++ b/src/UniTask/Assets/Editor/EditorRunnerChecker.cs
@@ -0,0 +1,30 @@
+#if UNITY_EDITOR
+
+using Cysharp.Threading.Tasks;
+using System;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Networking;
+
+public static class EditorRunnerChecker
+{
+    [MenuItem("Tools/UniTaskEditorRunnerChecker")]
+    public static void RunUniTaskAsync()
+    {
+        RunCore().Forget();
+    }
+
+    static async UniTaskVoid RunCore()
+    {
+        Debug.Log("Start");
+
+        var r = await UnityWebRequest.Get("https://bing.com/").SendWebRequest().ToUniTask();
+        Debug.Log(r.downloadHandler.text.Substring(0, 100));
+
+        Debug.Log("End");
+    }
+}
+
+#endif
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PromisePool.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PromisePool.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: fcb1f7467a3e2b64c8a016c8aee2f9b4
+guid: e51b78c06cb410f42b36e0af9de3b065
 MonoImporter:
  externalObjects: {}
  serializedVersion: 2
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncReactiveProperty.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncReactiveProperty.cs
@@ -1,21 +1,21 @@
-using Cysharp.Threading.Tasks.Linq;
-using System;
+using System;
 using System.Threading;

 namespace Cysharp.Threading.Tasks
 {
-    public interface IAsyncReadOnlyReactiveProperty<T> : IUniTaskAsyncEnumerable<T>
+    public interface IReadOnlyAsyncReactiveProperty<T> : IUniTaskAsyncEnumerable<T>
    {
        T Value { get; }
+        IUniTaskAsyncEnumerable<T> WithoutCurrent();
    }

-    public interface IAsyncReactiveProperty<T> : IAsyncReadOnlyReactiveProperty<T>
+    public interface IAsyncReactiveProperty<T> : IReadOnlyAsyncReactiveProperty<T>
    {
        new T Value { get; set; }
    }

    [Serializable]
-    public class AsyncReactiveProperty<T> : IUniTaskAsyncEnumerable<T>, IDisposable
+    public class AsyncReactiveProperty<T> : IAsyncReactiveProperty<T>, IDisposable
    {
        TriggerEvent<T> triggerEvent;

@@ -43,17 +43,55 @@ namespace Cysharp.Threading.Tasks
            this.triggerEvent = default;
        }

+        public IUniTaskAsyncEnumerable<T> WithoutCurrent()
+        {
+            return new WithoutCurrentEnumerable(this);
+        }
+
        public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken)
        {
-            return new Enumerator(this, cancellationToken);
+            return new Enumerator(this, cancellationToken, true);
        }

        public void Dispose()
        {
-            triggerEvent.SetCanceled(CancellationToken.None);
+            triggerEvent.SetCompleted();
        }

-        sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, IResolveCancelPromise<T>
+        public static implicit operator T(AsyncReactiveProperty<T> value)
+        {
+            return value.Value;
+        }
+
+        public override string ToString()
+        {
+            if (isValueType) return latestValue.ToString();
+            return latestValue?.ToString();
+        }
+
+        static bool isValueType;
+
+        static AsyncReactiveProperty()
+        {
+            isValueType = typeof(T).IsValueType;
+        }
+
+        class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable<T>
+        {
+            readonly AsyncReactiveProperty<T> parent;
+
+            public WithoutCurrentEnumerable(AsyncReactiveProperty<T> parent)
+            {
+                this.parent = parent;
+            }
+
+            public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+            {
+                return new Enumerator(parent, cancellationToken, false);
+            }
+        }
+
+        sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, ITriggerHandler<T>
        {
            static Action<object> cancellationCallback = CancellationCallback;

@@ -62,11 +100,13 @@ namespace Cysharp.Threading.Tasks
            readonly CancellationTokenRegistration cancellationTokenRegistration;
            T value;
            bool isDisposed;
+            bool firstCall;

-            public Enumerator(AsyncReactiveProperty<T> parent, CancellationToken cancellationToken)
+            public Enumerator(AsyncReactiveProperty<T> parent, CancellationToken cancellationToken, bool publishCurrentValue)
            {
                this.parent = parent;
                this.cancellationToken = cancellationToken;
+                this.firstCall = publishCurrentValue;

                parent.triggerEvent.Add(this);
                TaskTracker.TrackActiveTask(this, 3);
@@ -79,8 +119,19 @@ namespace Cysharp.Threading.Tasks

            public T Current => value;

+            ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }
+            ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }
+
            public UniTask<bool> MoveNextAsync()
            {
+                // raise latest value on first call.
+                if (firstCall)
+                {
+                    firstCall = false;
+                    value = parent.Value;
+                    return CompletedTasks.True;
+                }
+
                completionSource.Reset();
                return new UniTask<bool>(this, completionSource.Version);
            }
@@ -97,17 +148,25 @@ namespace Cysharp.Threading.Tasks
                return default;
            }

-            public bool TrySetResult(T value)
+            public void OnNext(T value)
            {
                this.value = value;
                completionSource.TrySetResult(true);
-                return true;
            }

-            public bool TrySetCanceled(CancellationToken cancellationToken = default)
+            public void OnCanceled(CancellationToken cancellationToken)
            {
                DisposeAsync().Forget();
-                return true;
+            }
+
+            public void OnCompleted()
+            {
+                completionSource.TrySetResult(false);
+            }
+
+            public void OnError(Exception ex)
+            {
+                completionSource.TrySetException(ex);
            }

            static void CancellationCallback(object state)
@@ -117,4 +176,200 @@ namespace Cysharp.Threading.Tasks
            }
        }
    }
-}
+
+    public class ReadOnlyAsyncReactiveProperty<T> : IReadOnlyAsyncReactiveProperty<T>, IDisposable
+    {
+        TriggerEvent<T> triggerEvent;
+
+        T latestValue;
+        IUniTaskAsyncEnumerator<T> enumerator;
+
+        public T Value
+        {
+            get
+            {
+                return latestValue;
+            }
+        }
+
+        public ReadOnlyAsyncReactiveProperty(T initialValue, IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
+        {
+            latestValue = initialValue;
+            ConsumeEnumerator(source, cancellationToken).Forget();
+        }
+
+        public ReadOnlyAsyncReactiveProperty(IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
+        {
+            ConsumeEnumerator(source, cancellationToken).Forget();
+        }
+
+        async UniTaskVoid ConsumeEnumerator(IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
+        {
+            enumerator = source.GetAsyncEnumerator(cancellationToken);
+            try
+            {
+                while (await enumerator.MoveNextAsync())
+                {
+                    var value = enumerator.Current;
+                    this.latestValue = value;
+                    triggerEvent.SetResult(value);
+                }
+            }
+            finally
+            {
+                await enumerator.DisposeAsync();
+                enumerator = null;
+            }
+        }
+
+        public IUniTaskAsyncEnumerable<T> WithoutCurrent()
+        {
+            return new WithoutCurrentEnumerable(this);
+        }
+
+        public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken)
+        {
+            return new Enumerator(this, cancellationToken, true);
+        }
+
+        public void Dispose()
+        {
+            if (enumerator != null)
+            {
+                enumerator.DisposeAsync().Forget();
+            }
+
+            triggerEvent.SetCompleted();
+        }
+
+        public static implicit operator T(ReadOnlyAsyncReactiveProperty<T> value)
+        {
+            return value.Value;
+        }
+
+        public override string ToString()
+        {
+            if (isValueType) return latestValue.ToString();
+            return latestValue?.ToString();
+        }
+
+        static bool isValueType;
+
+        static ReadOnlyAsyncReactiveProperty()
+        {
+            isValueType = typeof(T).IsValueType;
+        }
+
+        class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable<T>
+        {
+            readonly ReadOnlyAsyncReactiveProperty<T> parent;
+
+            public WithoutCurrentEnumerable(ReadOnlyAsyncReactiveProperty<T> parent)
+            {
+                this.parent = parent;
+            }
+
+            public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+            {
+                return new Enumerator(parent, cancellationToken, false);
+            }
+        }
+
+        sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, ITriggerHandler<T>
+        {
+            static Action<object> cancellationCallback = CancellationCallback;
+
+            readonly ReadOnlyAsyncReactiveProperty<T> parent;
+            readonly CancellationToken cancellationToken;
+            readonly CancellationTokenRegistration cancellationTokenRegistration;
+            T value;
+            bool isDisposed;
+            bool firstCall;
+
+            public Enumerator(ReadOnlyAsyncReactiveProperty<T> parent, CancellationToken cancellationToken, bool publishCurrentValue)
+            {
+                this.parent = parent;
+                this.cancellationToken = cancellationToken;
+                this.firstCall = publishCurrentValue;
+
+                parent.triggerEvent.Add(this);
+                TaskTracker.TrackActiveTask(this, 3);
+
+                if (cancellationToken.CanBeCanceled)
+                {
+                    cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
+                }
+            }
+
+            public T Current => value;
+            ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }
+            ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                // raise latest value on first call.
+                if (firstCall)
+                {
+                    firstCall = false;
+                    value = parent.Value;
+                    return CompletedTasks.True;
+                }
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!isDisposed)
+                {
+                    isDisposed = true;
+                    TaskTracker.RemoveTracking(this);
+                    completionSource.TrySetCanceled(cancellationToken);
+                    parent.triggerEvent.Remove(this);
+                }
+                return default;
+            }
+
+            public void OnNext(T value)
+            {
+                this.value = value;
+                completionSource.TrySetResult(true);
+            }
+
+            public void OnCanceled(CancellationToken cancellationToken)
+            {
+                DisposeAsync().Forget();
+            }
+
+            public void OnCompleted()
+            {
+                completionSource.TrySetResult(false);
+            }
+
+            public void OnError(Exception ex)
+            {
+                completionSource.TrySetException(ex);
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (Enumerator)state;
+                self.DisposeAsync().Forget();
+            }
+        }
+    }
+
+    public static class StateExtensions
+    {
+        public static ReadOnlyAsyncReactiveProperty<T> ToReadOnlyAsyncReactiveProperty<T>(this IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
+        {
+            return new ReadOnlyAsyncReactiveProperty<T>(source, cancellationToken);
+        }
+
+        public static ReadOnlyAsyncReactiveProperty<T> ToReadOnlyAsyncReactiveProperty<T>(this IUniTaskAsyncEnumerable<T> source, T initialValue, CancellationToken cancellationToken)
+        {
+            return new ReadOnlyAsyncReactiveProperty<T>(initialValue, source, cancellationToken);
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncUnit.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncUnit.cs
@@ -4,7 +4,7 @@ using System;

 namespace Cysharp.Threading.Tasks
 {
-    public struct AsyncUnit : IEquatable<AsyncUnit>
+    public readonly struct AsyncUnit : IEquatable<AsyncUnit>
    {
        public static readonly AsyncUnit Default = new AsyncUnit();

--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenExtensions.cs
@@ -1,6 +1,7 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

 using System;
+using System.Runtime.CompilerServices;
 using System.Threading;

 namespace Cysharp.Threading.Tasks
@@ -9,15 +10,15 @@ namespace Cysharp.Threading.Tasks
    {
        static readonly Action<object> cancellationTokenCallback = Callback;

-        public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cts)
+        public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cancellationToken)
        {
-            if (cts.IsCancellationRequested)
+            if (cancellationToken.IsCancellationRequested)
            {
-                return (UniTask.FromCanceled(cts), default(CancellationTokenRegistration));
+                return (UniTask.FromCanceled(cancellationToken), default(CancellationTokenRegistration));
            }

            var promise = new UniTaskCompletionSource();
-            return (promise.Task, cts.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, promise));
+            return (promise.Task, cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, promise));
        }

        static void Callback(object state)
@@ -26,6 +27,11 @@ namespace Cysharp.Threading.Tasks
            promise.TrySetResult();
        }

+        public static CancellationTokenAwaitable WaitUntilCanceled(this CancellationToken cancellationToken)
+        {
+            return new CancellationTokenAwaitable(cancellationToken);
+        }
+
        public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action callback)
        {
            var restoreFlow = false;
@@ -70,5 +76,46 @@ namespace Cysharp.Threading.Tasks
            }
        }
    }
+
+    public struct CancellationTokenAwaitable
+    {
+        CancellationToken cancellationToken;
+
+        public CancellationTokenAwaitable(CancellationToken cancellationToken)
+        {
+            this.cancellationToken = cancellationToken;
+        }
+
+        public Awaiter GetAwaiter()
+        {
+            return new Awaiter(cancellationToken);
+        }
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            CancellationToken cancellationToken;
+
+            public Awaiter(CancellationToken cancellationToken)
+            {
+                this.cancellationToken = cancellationToken;
+            }
+
+            public bool IsCompleted => !cancellationToken.CanBeCanceled || cancellationToken.IsCancellationRequested;
+
+            public void GetResult()
+            {
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                cancellationToken.RegisterWithoutCaptureExecutionContext(continuation);
+            }
+        }
+    }
 }

--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Channel.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Channel.cs
@@ -0,0 +1,450 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class Channel
+    {
+        public static Channel<T> CreateSingleConsumerUnbounded<T>()
+        {
+            return new SingleConsumerUnboundedChannel<T>();
+        }
+    }
+
+    public abstract class Channel<TWrite, TRead>
+    {
+        public ChannelReader<TRead> Reader { get; protected set; }
+        public ChannelWriter<TWrite> Writer { get; protected set; }
+
+        public static implicit operator ChannelReader<TRead>(Channel<TWrite, TRead> channel) => channel.Reader;
+        public static implicit operator ChannelWriter<TWrite>(Channel<TWrite, TRead> channel) => channel.Writer;
+    }
+
+    public abstract class Channel<T> : Channel<T, T>
+    {
+    }
+
+    public abstract class ChannelReader<T>
+    {
+        public abstract bool TryRead(out T item);
+        public abstract UniTask<bool> WaitToReadAsync(CancellationToken cancellationToken = default(CancellationToken));
+
+        public abstract UniTask Completion { get; }
+
+        public virtual UniTask<T> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (this.TryRead(out var item))
+            {
+                return UniTask.FromResult(item);
+            }
+
+            return ReadAsyncCore(cancellationToken);
+        }
+
+        async UniTask<T> ReadAsyncCore(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (await WaitToReadAsync(cancellationToken))
+            {
+                if (TryRead(out var item))
+                {
+                    return item;
+                }
+            }
+
+            throw new ChannelClosedException();
+        }
+
+        public abstract IUniTaskAsyncEnumerable<T> ReadAllAsync(CancellationToken cancellationToken = default(CancellationToken));
+    }
+
+    public abstract class ChannelWriter<T>
+    {
+        public abstract bool TryWrite(T item);
+        public abstract bool TryComplete(Exception error = null);
+
+        public void Complete(Exception error = null)
+        {
+            if (!TryComplete(error))
+            {
+                throw new ChannelClosedException();
+            }
+        }
+    }
+
+    public partial class ChannelClosedException : InvalidOperationException
+    {
+        public ChannelClosedException() :
+            base("Channel is already closed.")
+        { }
+
+        public ChannelClosedException(string message) : base(message) { }
+
+        public ChannelClosedException(Exception innerException) :
+            base("Channel is already closed", innerException)
+        { }
+
+        public ChannelClosedException(string message, Exception innerException) : base(message, innerException) { }
+    }
+
+    internal class SingleConsumerUnboundedChannel<T> : Channel<T>
+    {
+        readonly Queue<T> items;
+        readonly SingleConsumerUnboundedChannelReader readerSource;
+        UniTaskCompletionSource completedTaskSource;
+        UniTask completedTask;
+
+        Exception completionError;
+        bool closed;
+
+        public SingleConsumerUnboundedChannel()
+        {
+            items = new Queue<T>();
+            Writer = new SingleConsumerUnboundedChannelWriter(this);
+            readerSource = new SingleConsumerUnboundedChannelReader(this);
+            Reader = readerSource;
+        }
+
+        sealed class SingleConsumerUnboundedChannelWriter : ChannelWriter<T>
+        {
+            readonly SingleConsumerUnboundedChannel<T> parent;
+
+            public SingleConsumerUnboundedChannelWriter(SingleConsumerUnboundedChannel<T> parent)
+            {
+                this.parent = parent;
+            }
+
+            public override bool TryWrite(T item)
+            {
+                bool waiting;
+                lock (parent.items)
+                {
+                    if (parent.closed) return false;
+
+                    parent.items.Enqueue(item);
+                    waiting = parent.readerSource.isWaiting;
+                }
+
+                if (waiting)
+                {
+                    parent.readerSource.SingalContinuation();
+                }
+
+                return true;
+            }
+
+            public override bool TryComplete(Exception error = null)
+            {
+                bool waiting;
+                lock (parent.items)
+                {
+                    if (parent.closed) return false;
+                    parent.closed = true;
+                    waiting = parent.readerSource.isWaiting;
+
+                    if (parent.items.Count == 0)
+                    {
+                        if (error == null)
+                        {
+                            if (parent.completedTaskSource != null)
+                            {
+                                parent.completedTaskSource.TrySetResult();
+                            }
+                            else
+                            {
+                                parent.completedTask = UniTask.CompletedTask;
+                            }
+                        }
+                        else
+                        {
+                            if (parent.completedTaskSource != null)
+                            {
+                                parent.completedTaskSource.TrySetException(error);
+                            }
+                            else
+                            {
+                                parent.completedTask = UniTask.FromException(error);
+                            }
+                        }
+
+                        if (waiting)
+                        {
+                            parent.readerSource.SingalCompleted(error);
+                        }
+                    }
+
+                    parent.completionError = error;
+                }
+
+                return true;
+            }
+        }
+
+        sealed class SingleConsumerUnboundedChannelReader : ChannelReader<T>, IUniTaskSource<bool>
+        {
+            readonly Action<object> CancellationCallbackDelegate = CancellationCallback;
+            readonly SingleConsumerUnboundedChannel<T> parent;
+
+            CancellationToken cancellationToken;
+            CancellationTokenRegistration cancellationTokenRegistration;
+            UniTaskCompletionSourceCore<bool> core;
+            internal bool isWaiting;
+
+            public SingleConsumerUnboundedChannelReader(SingleConsumerUnboundedChannel<T> parent)
+            {
+                this.parent = parent;
+
+                TaskTracker.TrackActiveTask(this, 4);
+            }
+
+            public override UniTask Completion
+            {
+                get
+                {
+                    if (parent.completedTaskSource != null) return parent.completedTaskSource.Task;
+
+                    if (parent.closed)
+                    {
+                        return parent.completedTask;
+                    }
+
+                    parent.completedTaskSource = new UniTaskCompletionSource();
+                    return parent.completedTaskSource.Task;
+                }
+            }
+
+            public override bool TryRead(out T item)
+            {
+                lock (parent.items)
+                {
+                    if (parent.items.Count != 0)
+                    {
+                        item = parent.items.Dequeue();
+
+                        // complete when all value was consumed.
+                        if (parent.closed && parent.items.Count == 0)
+                        {
+                            if (parent.completionError != null)
+                            {
+                                if (parent.completedTaskSource != null)
+                                {
+                                    parent.completedTaskSource.TrySetException(parent.completionError);
+                                }
+                                else
+                                {
+                                    parent.completedTask = UniTask.FromException(parent.completionError);
+                                }
+                            }
+                            else
+                            {
+                                if (parent.completedTaskSource != null)
+                                {
+                                    parent.completedTaskSource.TrySetResult();
+                                }
+                                else
+                                {
+                                    parent.completedTask = UniTask.CompletedTask;
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        item = default;
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+
+            public override UniTask<bool> WaitToReadAsync(CancellationToken cancellationToken)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return UniTask.FromCanceled<bool>(cancellationToken);
+                }
+
+                lock (parent.items)
+                {
+                    if (parent.items.Count != 0)
+                    {
+                        return CompletedTasks.True;
+                    }
+
+                    if (parent.closed)
+                    {
+                        if (parent.completionError == null)
+                        {
+                            return CompletedTasks.False;
+                        }
+                        else
+                        {
+                            return UniTask.FromException<bool>(parent.completionError);
+                        }
+                    }
+
+                    cancellationTokenRegistration.Dispose();
+
+                    core.Reset();
+                    isWaiting = true;
+
+                    this.cancellationToken = cancellationToken;
+                    if (this.cancellationToken.CanBeCanceled)
+                    {
+                        cancellationTokenRegistration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(CancellationCallbackDelegate, this);
+                    }
+
+                    return new UniTask<bool>(this, core.Version);
+                }
+            }
+
+            public void SingalContinuation()
+            {
+                core.TrySetResult(true);
+            }
+
+            public void SingalCancellation(CancellationToken cancellationToken)
+            {
+                TaskTracker.RemoveTracking(this);
+                core.TrySetCanceled(cancellationToken);
+            }
+
+            public void SingalCompleted(Exception error)
+            {
+                if (error != null)
+                {
+                    TaskTracker.RemoveTracking(this);
+                    core.TrySetException(error);
+                }
+                else
+                {
+                    TaskTracker.RemoveTracking(this);
+                    core.TrySetResult(false);
+                }
+            }
+
+            public override IUniTaskAsyncEnumerable<T> ReadAllAsync(CancellationToken cancellationToken = default)
+            {
+                return new ReadAllAsyncEnumerable(this, cancellationToken);
+            }
+
+            bool IUniTaskSource<bool>.GetResult(short token)
+            {
+                return core.GetResult(token);
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                core.GetResult(token);
+            }
+
+            UniTaskStatus IUniTaskSource.GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            void IUniTaskSource.OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            UniTaskStatus IUniTaskSource.UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (SingleConsumerUnboundedChannelReader)state;
+                self.SingalCancellation(self.cancellationToken);
+            }
+
+            sealed class ReadAllAsyncEnumerable : IUniTaskAsyncEnumerable<T>, IUniTaskAsyncEnumerator<T>
+            {
+                readonly Action<object> CancellationCallback1Delegate = CancellationCallback1;
+                readonly Action<object> CancellationCallback2Delegate = CancellationCallback2;
+
+                readonly SingleConsumerUnboundedChannelReader parent;
+                CancellationToken cancellationToken1;
+                CancellationToken cancellationToken2;
+                CancellationTokenRegistration cancellationTokenRegistration1;
+                CancellationTokenRegistration cancellationTokenRegistration2;
+
+                T current;
+                bool cacheValue;
+                bool running;
+
+                public ReadAllAsyncEnumerable(SingleConsumerUnboundedChannelReader parent, CancellationToken cancellationToken)
+                {
+                    this.parent = parent;
+                    this.cancellationToken1 = cancellationToken;
+                }
+
+                public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+                {
+                    if (running)
+                    {
+                        throw new InvalidOperationException("Enumerator is already running, does not allow call GetAsyncEnumerator twice.");
+                    }
+
+                    if (this.cancellationToken1 != cancellationToken)
+                    {
+                        this.cancellationToken2 = cancellationToken;
+                    }
+
+                    if (this.cancellationToken1.CanBeCanceled)
+                    {
+                        this.cancellationTokenRegistration1 =  this.cancellationToken1.RegisterWithoutCaptureExecutionContext(CancellationCallback1Delegate, this);
+                    }
+
+                    if (this.cancellationToken2.CanBeCanceled)
+                    {
+                        this.cancellationTokenRegistration2 = this.cancellationToken2.RegisterWithoutCaptureExecutionContext(CancellationCallback2Delegate, this);
+                    }
+
+                    running = true;
+                    return this;
+                }
+
+                public T Current
+                {
+                    get
+                    {
+                        if (cacheValue)
+                        {
+                            return current;
+                        }
+                        parent.TryRead(out current);
+                        return current;
+                    }
+                }
+
+                public UniTask<bool> MoveNextAsync()
+                {
+                    cacheValue = false;
+                    return parent.WaitToReadAsync(CancellationToken.None); // ok to use None, registered in ctor.
+                }
+
+                public UniTask DisposeAsync()
+                {
+                    cancellationTokenRegistration1.Dispose();
+                    cancellationTokenRegistration2.Dispose();
+                    return default;
+                }
+
+                static void CancellationCallback1(object state)
+                {
+                    var self = (ReadAllAsyncEnumerable)state;
+                    self.parent.SingalCancellation(self.cancellationToken1);
+                }
+
+                static void CancellationCallback2(object state)
+                {
+                    var self = (ReadAllAsyncEnumerable)state;
+                    self.parent.SingalCancellation(self.cancellationToken2);
+                }
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/Hack.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/Hack.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 4d5a9a3e1f0f069478969f752fde29a9
+guid: 5ceb3107bbdd1f14eb39091273798360
 MonoImporter:
  externalObjects: {}
  serializedVersion: 2
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncUniTaskMethodBuilder.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncUniTaskMethodBuilder.cs
@@ -12,9 +12,8 @@ namespace Cysharp.Threading.Tasks.CompilerServices
    [StructLayout(LayoutKind.Auto)]
    public struct AsyncUniTaskMethodBuilder
    {
-        // cache items.
-        AutoResetUniTaskCompletionSource promise;
-        IMoveNextRunner runner;
+        internal IStateMachineRunnerPromise runnerPromise;
+        Exception ex;

        // 1. Static Create method.
        [DebuggerHidden]
@@ -31,98 +30,81 @@ namespace Cysharp.Threading.Tasks.CompilerServices
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get
            {
-                if (promise != null)
+                if (runnerPromise != null)
                {
-                    return promise.Task;
+                    return runnerPromise.Task;
                }
-
-                if (runner == null)
+                else if (ex != null)
+                {
+                    return UniTask.FromException(ex);
+                }
+                else
                {
                    return UniTask.CompletedTask;
                }
-
-                promise = AutoResetUniTaskCompletionSource.Create();
-                return promise.Task;
            }
        }

        // 3. SetException
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetException(Exception exception)
        {
-            // runner is finished, return first.
-            if (runner != null)
+            if (runnerPromise == null)
            {
-                runner.Return();
-                runner = null;
-            }
-
-            if (promise != null)
-            {
-                promise.TrySetException(exception);
+                ex = exception;
            }
            else
            {
-                promise = AutoResetUniTaskCompletionSource.CreateFromException(exception, out _);
+                runnerPromise.SetException(exception);
            }
        }

        // 4. SetResult
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetResult()
        {
-            // runner is finished, return first.
-            if (runner != null)
+            if (runnerPromise != null)
            {
-                runner.Return();
-                runner = null;
-            }
-
-            if (promise != null)
-            {
-                promise.TrySetResult();
+                runnerPromise.SetResult();
            }
        }

        // 5. AwaitOnCompleted
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
            where TAwaiter : INotifyCompletion
            where TStateMachine : IAsyncStateMachine
        {
-            if (promise == null)
+            if (runnerPromise == null)
            {
-                promise = AutoResetUniTaskCompletionSource.Create();
-            }
-            if (runner == null)
-            {
-                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+                AsyncUniTask<TStateMachine>.SetStateMachine(ref this, ref stateMachine);
            }

-            awaiter.OnCompleted(runner.CallMoveNext);
+            awaiter.OnCompleted(runnerPromise.MoveNext);
        }

        // 6. AwaitUnsafeOnCompleted
        [DebuggerHidden]
        [SecuritySafeCritical]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
            where TAwaiter : ICriticalNotifyCompletion
            where TStateMachine : IAsyncStateMachine
        {
-            if (promise == null)
+            if (runnerPromise == null)
            {
-                promise = AutoResetUniTaskCompletionSource.Create();
-            }
-            if (runner == null)
-            {
-                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+                AsyncUniTask<TStateMachine>.SetStateMachine(ref this, ref stateMachine);
            }

-            awaiter.OnCompleted(runner.CallMoveNext);
+            awaiter.UnsafeOnCompleted(runnerPromise.MoveNext);
        }

        // 7. Start
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Start<TStateMachine>(ref TStateMachine stateMachine)
            where TStateMachine : IAsyncStateMachine
        {
@@ -156,9 +138,8 @@ namespace Cysharp.Threading.Tasks.CompilerServices
    [StructLayout(LayoutKind.Auto)]
    public struct AsyncUniTaskMethodBuilder<T>
    {
-        // cache items.
-        AutoResetUniTaskCompletionSource<T> promise;
-        IMoveNextRunner runner;
+        internal IStateMachineRunnerPromise<T> runnerPromise;
+        Exception ex;
        T result;

        // 1. Static Create method.
@@ -170,106 +151,91 @@ namespace Cysharp.Threading.Tasks.CompilerServices
        }

        // 2. TaskLike Task property.
-        [DebuggerHidden]
        public UniTask<T> Task
        {
+            [DebuggerHidden]
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            get
            {
-                if (promise != null)
+                if (runnerPromise != null)
                {
-                    return promise.Task;
+                    return runnerPromise.Task;
                }
-
-                if (runner == null)
+                else if (ex != null)
+                {
+                    return UniTask.FromException<T>(ex);
+                }
+                else
                {
                    return UniTask.FromResult(result);
                }
-
-                promise = AutoResetUniTaskCompletionSource<T>.Create();
-                return promise.Task;
            }
        }

        // 3. SetException
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetException(Exception exception)
        {
-            // runner is finished, return first.
-            if (runner != null)
+            if (runnerPromise == null)
            {
-                runner.Return();
-                runner = null;
-            }
-
-            if (promise == null)
-            {
-                promise = AutoResetUniTaskCompletionSource<T>.CreateFromException(exception, out _);
+                ex = exception;
            }
            else
            {
-                promise.TrySetException(exception);
+                runnerPromise.SetException(exception);
            }
        }

        // 4. SetResult
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetResult(T result)
        {
-            // runner is finished, return first.
-            if (runner != null)
-            {
-                runner.Return();
-                runner = null;
-            }
-
-            if (promise == null)
+            if (runnerPromise == null)
            {
                this.result = result;
-                return;
            }
-
-            promise.TrySetResult(result);
+            else
+            {
+                runnerPromise.SetResult(result);
+            }
        }

        // 5. AwaitOnCompleted
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
            where TAwaiter : INotifyCompletion
            where TStateMachine : IAsyncStateMachine
        {
-            if (promise == null)
+            if (runnerPromise == null)
            {
-                promise = AutoResetUniTaskCompletionSource<T>.Create();
-            }
-            if (runner == null)
-            {
-                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+                AsyncUniTask<TStateMachine, T>.SetStateMachine(ref this, ref stateMachine);
            }

-            awaiter.OnCompleted(runner.CallMoveNext);
+            awaiter.OnCompleted(runnerPromise.MoveNext);
        }

        // 6. AwaitUnsafeOnCompleted
        [DebuggerHidden]
        [SecuritySafeCritical]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
            where TAwaiter : ICriticalNotifyCompletion
            where TStateMachine : IAsyncStateMachine
        {
-            if (promise == null)
+            if (runnerPromise == null)
            {
-                promise = AutoResetUniTaskCompletionSource<T>.Create();
-            }
-            if (runner == null)
-            {
-                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+                AsyncUniTask<TStateMachine, T>.SetStateMachine(ref this, ref stateMachine);
            }

-            awaiter.OnCompleted(runner.CallMoveNext);
+            awaiter.UnsafeOnCompleted(runnerPromise.MoveNext);
        }

        // 7. Start
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Start<TStateMachine>(ref TStateMachine stateMachine)
            where TStateMachine : IAsyncStateMachine
        {
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs
@@ -4,13 +4,15 @@
 using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Security;

 namespace Cysharp.Threading.Tasks.CompilerServices
 {
+    [StructLayout(LayoutKind.Auto)]
    public struct AsyncUniTaskVoidMethodBuilder
    {
-        IMoveNextRunner runner;
+        internal IStateMachineRunner runner;

        // 1. Static Create method.
        [DebuggerHidden]
@@ -33,6 +35,7 @@ namespace Cysharp.Threading.Tasks.CompilerServices

        // 3. SetException
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetException(Exception exception)
        {
            // runner is finished, return first.
@@ -47,6 +50,7 @@ namespace Cysharp.Threading.Tasks.CompilerServices

        // 4. SetResult
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetResult()
        {
            // runner is finished, return.
@@ -59,31 +63,33 @@ namespace Cysharp.Threading.Tasks.CompilerServices

        // 5. AwaitOnCompleted
        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
            where TAwaiter : INotifyCompletion
            where TStateMachine : IAsyncStateMachine
        {
            if (runner == null)
            {
-                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+                AsyncUniTaskVoid<TStateMachine>.SetStateMachine(ref this, ref stateMachine);
            }

-            awaiter.OnCompleted(runner.CallMoveNext);
+            awaiter.OnCompleted(runner.MoveNext);
        }

        // 6. AwaitUnsafeOnCompleted
        [DebuggerHidden]
        [SecuritySafeCritical]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
            where TAwaiter : ICriticalNotifyCompletion
            where TStateMachine : IAsyncStateMachine
        {
            if (runner == null)
            {
-                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+                AsyncUniTaskVoid<TStateMachine>.SetStateMachine(ref this, ref stateMachine);
            }

-            awaiter.OnCompleted(runner.CallMoveNext);
+            awaiter.UnsafeOnCompleted(runner.MoveNext);
        }

        // 7. Start
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/MoveNextRunner.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/MoveNextRunner.cs
@@ -1,57 +0,0 @@
-
-#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
-
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using Cysharp.Threading.Tasks.Internal;
-
-namespace Cysharp.Threading.Tasks.CompilerServices
-{
-    internal interface IMoveNextRunner
-    {
-        Action CallMoveNext { get; }
-        void Return();
-    }
-
-    internal sealed class MoveNextRunner<TStateMachine> : IMoveNextRunner, IPromisePoolItem
-        where TStateMachine : IAsyncStateMachine
-    {
-        static PromisePool<MoveNextRunner<TStateMachine>> pool = new PromisePool<MoveNextRunner<TStateMachine>>();
-
-        TStateMachine stateMachine;
-        internal readonly Action callMoveNext;
-
-        public Action CallMoveNext => callMoveNext;
-
-        MoveNextRunner()
-        {
-            callMoveNext = MoveNext;
-        }
-
-        public static MoveNextRunner<TStateMachine> Create(ref TStateMachine stateMachine)
-        {
-            var result = pool.TryRent() ?? new MoveNextRunner<TStateMachine>();
-            result.stateMachine = stateMachine;
-            return result;
-        }
-
-        [DebuggerHidden]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        void MoveNext()
-        {
-            stateMachine.MoveNext();
-        }
-
-        public void Return()
-        {
-            pool.TryReturn(this);
-        }
-
-        void IPromisePoolItem.Reset()
-        {
-            stateMachine = default;
-        }
-    }
-}
-
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/StateMachineRunner.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/StateMachineRunner.cs
@@ -0,0 +1,328 @@
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.CompilerServices
+{
+    internal interface IStateMachineRunner
+    {
+        Action MoveNext { get; }
+        void Return();
+    }
+
+    internal interface IStateMachineRunnerPromise : IUniTaskSource
+    {
+        Action MoveNext { get; }
+        UniTask Task { get; }
+        void SetResult();
+        void SetException(Exception exception);
+    }
+
+    internal interface IStateMachineRunnerPromise<T> : IUniTaskSource<T>
+    {
+        Action MoveNext { get; }
+        UniTask<T> Task { get; }
+        void SetResult(T result);
+        void SetException(Exception exception);
+    }
+
+    internal sealed class AsyncUniTaskVoid<TStateMachine> : IStateMachineRunner, ITaskPoolNode<AsyncUniTaskVoid<TStateMachine>>, IUniTaskSource
+        where TStateMachine : IAsyncStateMachine
+    {
+        static TaskPool<AsyncUniTaskVoid<TStateMachine>> pool;
+
+        TStateMachine stateMachine;
+
+        public Action MoveNext { get; }
+
+        public AsyncUniTaskVoid()
+        {
+            MoveNext = Run;
+        }
+
+        public static void SetStateMachine(ref AsyncUniTaskVoidMethodBuilder builder, ref TStateMachine stateMachine)
+        {
+            if (!pool.TryPop(out var result))
+            {
+                result = new AsyncUniTaskVoid<TStateMachine>();
+            }
+            TaskTracker.TrackActiveTask(result, 3);
+
+            builder.runner = result; // set runner before copied.
+            result.stateMachine = stateMachine; // copy struct StateMachine(in release build).
+        }
+
+        static AsyncUniTaskVoid()
+        {
+            TaskPool.RegisterSizeGetter(typeof(AsyncUniTaskVoid<TStateMachine>), () => pool.Size);
+        }
+
+        public AsyncUniTaskVoid<TStateMachine> NextNode { get; set; }
+
+        public void Return()
+        {
+            TaskTracker.RemoveTracking(this);
+            stateMachine = default;
+            pool.TryPush(this);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void Run()
+        {
+            stateMachine.MoveNext();
+        }
+
+        // dummy interface implementation for TaskTracker.
+
+        UniTaskStatus IUniTaskSource.GetStatus(short token)
+        {
+            return UniTaskStatus.Pending;
+        }
+
+        UniTaskStatus IUniTaskSource.UnsafeGetStatus()
+        {
+            return UniTaskStatus.Pending;
+        }
+
+        void IUniTaskSource.OnCompleted(Action<object> continuation, object state, short token)
+        {
+        }
+
+        void IUniTaskSource.GetResult(short token)
+        {
+        }
+    }
+
+    internal sealed class AsyncUniTask<TStateMachine> : IStateMachineRunnerPromise, IUniTaskSource, ITaskPoolNode<AsyncUniTask<TStateMachine>>
+        where TStateMachine : IAsyncStateMachine
+    {
+        static TaskPool<AsyncUniTask<TStateMachine>> pool;
+
+        TStateMachine stateMachine;
+
+        public Action MoveNext { get; }
+
+        UniTaskCompletionSourceCore<AsyncUnit> core;
+
+        AsyncUniTask()
+        {
+            MoveNext = Run;
+        }
+
+        public static void SetStateMachine(ref AsyncUniTaskMethodBuilder builder, ref TStateMachine stateMachine)
+        {
+            if (!pool.TryPop(out var result))
+            {
+                result = new AsyncUniTask<TStateMachine>();
+            }
+            TaskTracker.TrackActiveTask(result, 3);
+
+            builder.runnerPromise = result; // set runner before copied.
+            result.stateMachine = stateMachine; // copy struct StateMachine(in release build).
+        }
+
+        public AsyncUniTask<TStateMachine> NextNode { get; set; }
+
+        static AsyncUniTask()
+        {
+            TaskPool.RegisterSizeGetter(typeof(AsyncUniTask<TStateMachine>), () => pool.Size);
+        }
+
+        bool TryReturn()
+        {
+            TaskTracker.RemoveTracking(this);
+            core.Reset();
+            stateMachine = default;
+            return pool.TryPush(this);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void Run()
+        {
+            stateMachine.MoveNext();
+        }
+
+        public UniTask Task
+        {
+            [DebuggerHidden]
+            get
+            {
+                return new UniTask(this, core.Version);
+            }
+        }
+
+        [DebuggerHidden]
+        public void SetResult()
+        {
+            core.TrySetResult(AsyncUnit.Default);
+        }
+
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            core.TrySetException(exception);
+        }
+
+        [DebuggerHidden]
+        public void GetResult(short token)
+        {
+            try
+            {
+                core.GetResult(token);
+            }
+            finally
+            {
+                TryReturn();
+            }
+        }
+
+        [DebuggerHidden]
+        public UniTaskStatus GetStatus(short token)
+        {
+            return core.GetStatus(token);
+        }
+
+        [DebuggerHidden]
+        public UniTaskStatus UnsafeGetStatus()
+        {
+            return core.UnsafeGetStatus();
+        }
+
+        [DebuggerHidden]
+        public void OnCompleted(Action<object> continuation, object state, short token)
+        {
+            core.OnCompleted(continuation, state, token);
+        }
+
+        ~AsyncUniTask()
+        {
+            if (TryReturn())
+            {
+                GC.ReRegisterForFinalize(this);
+            }
+        }
+    }
+
+    internal sealed class AsyncUniTask<TStateMachine, T> : IStateMachineRunnerPromise<T>, IUniTaskSource<T>, ITaskPoolNode<AsyncUniTask<TStateMachine, T>>
+        where TStateMachine : IAsyncStateMachine
+    {
+        static TaskPool<AsyncUniTask<TStateMachine, T>> pool;
+
+        TStateMachine stateMachine;
+
+        public Action MoveNext { get; }
+
+        UniTaskCompletionSourceCore<T> core;
+
+        AsyncUniTask()
+        {
+            MoveNext = Run;
+        }
+
+        public static void SetStateMachine(ref AsyncUniTaskMethodBuilder<T> builder, ref TStateMachine stateMachine)
+        {
+            if (!pool.TryPop(out var result))
+            {
+                result = new AsyncUniTask<TStateMachine, T>();
+            }
+            TaskTracker.TrackActiveTask(result, 3);
+
+            builder.runnerPromise = result; // set runner before copied.
+            result.stateMachine = stateMachine; // copy struct StateMachine(in release build).
+        }
+
+        public AsyncUniTask<TStateMachine, T> NextNode { get; set; }
+
+        static AsyncUniTask()
+        {
+            TaskPool.RegisterSizeGetter(typeof(AsyncUniTask<TStateMachine, T>), () => pool.Size);
+        }
+
+        bool TryReturn()
+        {
+            TaskTracker.RemoveTracking(this);
+            core.Reset();
+            stateMachine = default;
+            return pool.TryPush(this);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void Run()
+        {
+            stateMachine.MoveNext();
+        }
+
+        public UniTask<T> Task
+        {
+            [DebuggerHidden]
+            get
+            {
+                return new UniTask<T>(this, core.Version);
+            }
+        }
+
+        [DebuggerHidden]
+        public void SetResult(T result)
+        {
+            core.TrySetResult(result);
+        }
+
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            core.TrySetException(exception);
+        }
+
+        [DebuggerHidden]
+        public T GetResult(short token)
+        {
+            try
+            {
+                return core.GetResult(token);
+            }
+            finally
+            {
+                TryReturn();
+            }
+        }
+
+        [DebuggerHidden]
+        void IUniTaskSource.GetResult(short token)
+        {
+            GetResult(token);
+        }
+
+        [DebuggerHidden]
+        public UniTaskStatus GetStatus(short token)
+        {
+            return core.GetStatus(token);
+        }
+
+        [DebuggerHidden]
+        public UniTaskStatus UnsafeGetStatus()
+        {
+            return core.UnsafeGetStatus();
+        }
+
+        [DebuggerHidden]
+        public void OnCompleted(Action<object> continuation, object state, short token)
+        {
+            core.OnCompleted(continuation, state, token);
+        }
+
+        ~AsyncUniTask()
+        {
+            if (TryReturn())
+            {
+                GC.ReRegisterForFinalize(this);
+            }
+        }
+    }
+}
+
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/StateMachineRunner.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/StateMachineRunner.cs.meta
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/EnumeratorAsyncExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/EnumeratorAsyncExtensions.cs
@@ -14,22 +14,31 @@ namespace Cysharp.Threading.Tasks
    {
        public static UniTask.Awaiter GetAwaiter(this IEnumerator enumerator)
        {
+            Error.ThrowArgumentNullException(enumerator, nameof(enumerator));
            return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, CancellationToken.None, out var token), token).GetAwaiter();
        }

-        public static UniTask ToUniTask(this IEnumerator enumerator)
+        public static UniTask WithCancellation(this IEnumerator enumerator, CancellationToken cancellationToken)
        {
-            return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, CancellationToken.None, out var token), token);
+            Error.ThrowArgumentNullException(enumerator, nameof(enumerator));
+            return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, cancellationToken, out var token), token);
        }

-        public static UniTask ConfigureAwait(this IEnumerator enumerator, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        public static UniTask ToUniTask(this IEnumerator enumerator, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
        {
+            Error.ThrowArgumentNullException(enumerator, nameof(enumerator));
            return new UniTask(EnumeratorPromise.Create(enumerator, timing, cancellationToken, out var token), token);
        }

-        class EnumeratorPromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        sealed class EnumeratorPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<EnumeratorPromise>
        {
-            static readonly PromisePool<EnumeratorPromise> pool = new PromisePool<EnumeratorPromise>();
+            static TaskPool<EnumeratorPromise> pool;
+            public EnumeratorPromise NextNode { get; set; }
+
+            static EnumeratorPromise()
+            {
+                TaskPool.RegisterSizeGetter(typeof(EnumeratorPromise), () => pool.Size);
+            }

            IEnumerator innerEnumerator;
            CancellationToken cancellationToken;
@@ -47,13 +56,15 @@ namespace Cysharp.Threading.Tasks
                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
                }

-                var result = pool.TryRent() ?? new EnumeratorPromise();
+                if (!pool.TryPop(out var result))
+                {
+                    result = new EnumeratorPromise();
+                }
+                TaskTracker.TrackActiveTask(result, 3);

                result.innerEnumerator = ConsumeEnumerator(innerEnumerator);
                result.cancellationToken = cancellationToken;

-                TaskTracker.TrackActiveTask(result, 3);
-
                PlayerLoopHelper.AddAction(timing, result);

                token = result.core.Version;
@@ -64,12 +75,11 @@ namespace Cysharp.Threading.Tasks
            {
                try
                {
-                    TaskTracker.RemoveTracking(this);
                    core.GetResult(token);
                }
                finally
                {
-                    pool.TryReturn(this);
+                    TryReturn();
                }
            }

@@ -113,16 +123,18 @@ namespace Cysharp.Threading.Tasks
                return false;
            }

-            public void Reset()
+            bool TryReturn()
            {
+                TaskTracker.RemoveTracking(this);
                core.Reset();
                innerEnumerator = default;
                cancellationToken = default;
+                return pool.TryPush(this);
            }

            ~EnumeratorPromise()
            {
-                if (pool.TryReturn(this))
+                if (TryReturn())
                {
                    GC.ReRegisterForFinalize(this);
                }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/External/AddressableAsyncExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/External/AddressableAsyncExtensions.cs
@@ -13,21 +13,23 @@ namespace Cysharp.Threading.Tasks
 {
    public static class AddressableAsyncExtensions
    {
-#region AsyncOperationHandle
+        #region AsyncOperationHandle

        public static AsyncOperationHandleAwaiter GetAwaiter(this AsyncOperationHandle handle)
        {
            return new AsyncOperationHandleAwaiter(handle);
        }

-        public static UniTask ToUniTask(this AsyncOperationHandle handle)
+        public static UniTask WithCancellation(this AsyncOperationHandle handle, CancellationToken cancellationToken)
        {
-            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (handle.IsDone) return UniTask.CompletedTask;
+            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
        }

-        public static UniTask ConfigureAwait(this AsyncOperationHandle handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask ToUniTask(this AsyncOperationHandle handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
        {
-            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellation, out var token), token);
+            if (handle.IsDone) return UniTask.CompletedTask;
+            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellationToken, out var token), token);
        }

        public struct AsyncOperationHandleAwaiter : ICriticalNotifyCompletion
@@ -70,14 +72,20 @@ namespace Cysharp.Threading.Tasks
            public void UnsafeOnCompleted(Action continuation)
            {
                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
-                continuationAction = continuation.AsFuncOfT<AsyncOperationHandle>(); // allocate delegate.
+                continuationAction = PooledDelegate<AsyncOperationHandle>.Create(continuation);
                handle.Completed += continuationAction;
            }
        }

-        class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        sealed class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleConfiguredSource>
        {
-            static readonly PromisePool<AsyncOperationHandleConfiguredSource> pool = new PromisePool<AsyncOperationHandleConfiguredSource>();
+            static TaskPool<AsyncOperationHandleConfiguredSource> pool;
+            public AsyncOperationHandleConfiguredSource NextNode { get; set; }
+
+            static AsyncOperationHandleConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource), () => pool.Size);
+            }

            AsyncOperationHandle handle;
            IProgress<float> progress;
@@ -97,7 +105,10 @@ namespace Cysharp.Threading.Tasks
                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
                }

-                var result = pool.TryRent() ?? new AsyncOperationHandleConfiguredSource();
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AsyncOperationHandleConfiguredSource();
+                }

                result.handle = handle;
                result.progress = progress;
@@ -115,12 +126,12 @@ namespace Cysharp.Threading.Tasks
            {
                try
                {
-                    TaskTracker.RemoveTracking(this);
+
                    core.GetResult(token);
                }
                finally
                {
-                    pool.TryReturn(this);
+                    TryReturn();
                }
            }

@@ -168,40 +179,44 @@ namespace Cysharp.Threading.Tasks
                return true;
            }

-            public void Reset()
+            bool TryReturn()
            {
                core.Reset();
+                TaskTracker.RemoveTracking(this);
                handle = default;
                progress = default;
                cancellationToken = default;
+                return pool.TryPush(this);
            }

            ~AsyncOperationHandleConfiguredSource()
            {
-                if (pool.TryReturn(this))
+                if (TryReturn())
                {
                    GC.ReRegisterForFinalize(this);
                }
            }
        }

-#endregion
+        #endregion

-#region AsyncOperationHandle_T
+        #region AsyncOperationHandle_T

        public static AsyncOperationHandleAwaiter<T> GetAwaiter<T>(this AsyncOperationHandle<T> handle)
        {
            return new AsyncOperationHandleAwaiter<T>(handle);
        }

-        public static UniTask<T> ToUniTask<T>(this AsyncOperationHandle<T> handle)
+        public static UniTask<T> WithCancellation<T>(this AsyncOperationHandle<T> handle, CancellationToken cancellationToken)
        {
-            return new UniTask<T>(AsyncOperationHandleConfiguredSource<T>.Create(handle, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (handle.IsDone) return UniTask.FromResult(handle.Result);
+            return new UniTask<T>(AsyncOperationHandleConfiguredSource<T>.Create(handle, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
        }

-        public static UniTask<T> ConfigureAwait<T>(this AsyncOperationHandle<T> handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask<T> ToUniTask<T>(this AsyncOperationHandle<T> handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
        {
-            return new UniTask<T>(AsyncOperationHandleConfiguredSource<T>.Create(handle, timing, progress, cancellation, out var token), token);
+            if (handle.IsDone) 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
@@ -245,14 +260,20 @@ namespace Cysharp.Threading.Tasks
            public void UnsafeOnCompleted(Action continuation)
            {
                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
-                continuationAction = continuation.AsFuncOfT<AsyncOperationHandle>(); // allocate delegate.
+                continuationAction = PooledDelegate<AsyncOperationHandle>.Create(continuation);
                handle.CompletedTypeless += continuationAction;
            }
        }

-        class AsyncOperationHandleConfiguredSource<T> : IUniTaskSource<T>, IPlayerLoopItem, IPromisePoolItem
+        sealed class AsyncOperationHandleConfiguredSource<T> : IUniTaskSource<T>, IPlayerLoopItem, ITaskPoolNode<AsyncOperationHandleConfiguredSource<T>>
        {
-            static readonly PromisePool<AsyncOperationHandleConfiguredSource<T>> pool = new PromisePool<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;
@@ -272,7 +293,10 @@ namespace Cysharp.Threading.Tasks
                    return AutoResetUniTaskCompletionSource<T>.CreateFromCanceled(cancellationToken, out token);
                }

-                var result = pool.TryRent() ?? new AsyncOperationHandleConfiguredSource<T>();
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AsyncOperationHandleConfiguredSource<T>();
+                }

                result.handle = handle;
                result.progress = progress;
@@ -290,13 +314,11 @@ namespace Cysharp.Threading.Tasks
            {
                try
                {
-                    TaskTracker.RemoveTracking(this);
-
                    return core.GetResult(token);
                }
                finally
                {
-                    pool.TryReturn(this);
+                    TryReturn();
                }
            }

@@ -349,24 +371,26 @@ namespace Cysharp.Threading.Tasks
                return true;
            }

-            public void Reset()
+            bool TryReturn()
            {
+                TaskTracker.RemoveTracking(this);
                core.Reset();
                handle = default;
                progress = default;
                cancellationToken = default;
+                return pool.TryPush(this);
            }

            ~AsyncOperationHandleConfiguredSource()
            {
-                if (pool.TryReturn(this))
+                if (TryReturn())
                {
                    GC.ReRegisterForFinalize(this);
                }
            }
        }

-#endregion
+        #endregion
    }
 }

--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/External/DoTweenAsyncExtensions.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/External/DoTweenAsyncExtensions.cs
@@ -0,0 +1,290 @@
+// asmdef Version Defines, enabled when com.demigiant.dotween is imported.
+
+#if UNITASK_DOTWEEN_SUPPORT
+
+using Cysharp.Threading.Tasks.Internal;
+using DG.Tweening;
+using System;
+using System.Collections.Concurrent;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    // The idea of TweenCancelBehaviour is borrowed from https://www.shibuya24.info/entry/dotween_async_await
+    public enum TweenCancelBehaviour
+    {
+        Kill,
+        KillWithCompleteCallback,
+        Complete,
+        CompleteWithSeqeunceCallback,
+        CancelAwait,
+
+        // AndCancelAwait
+        KillAndCancelAwait,
+        KillWithCompleteCallbackAndCancelAwait,
+        CompleteAndCancelAwait,
+        CompleteWithSeqeunceCallbackAndCancelAwait
+    }
+
+    public static class DOTweenAsyncExtensions
+    {
+        public static TweenAwaiter GetAwaiter(this Tween tween)
+        {
+            return new TweenAwaiter(tween);
+        }
+
+        public static UniTask WithCancellation(this Tween tween, CancellationToken cancellationToken)
+        {
+            Error.ThrowArgumentNullException(tween, nameof(tween));
+
+            if (!tween.IsActive()) return UniTask.CompletedTask;
+            return new UniTask(TweenConfiguredSource.Create(tween, TweenCancelBehaviour.Kill, cancellationToken, out var token), token);
+        }
+
+        public static UniTask ToUniTask(this Tween tween, TweenCancelBehaviour tweenCancelBehaviour = TweenCancelBehaviour.Kill, CancellationToken cancellationToken = default)
+        {
+            Error.ThrowArgumentNullException(tween, nameof(tween));
+
+            if (!tween.IsActive()) return UniTask.CompletedTask;
+            return new UniTask(TweenConfiguredSource.Create(tween, tweenCancelBehaviour, cancellationToken, out var token), token);
+        }
+
+        public struct TweenAwaiter : ICriticalNotifyCompletion
+        {
+            readonly Tween tween;
+
+            // killed(non active) as completed.
+            public bool IsCompleted => !tween.IsActive();
+
+            public TweenAwaiter(Tween tween)
+            {
+                this.tween = tween;
+            }
+
+            public TweenAwaiter GetAwaiter()
+            {
+                return this;
+            }
+
+            public void GetResult()
+            {
+            }
+
+            public void OnCompleted(System.Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(System.Action continuation)
+            {
+                // onKill is called after OnCompleted, both Complete(false/true) and Kill(false/true).
+                tween.onKill = PooledTweenCallback.Create(continuation);
+            }
+        }
+
+        sealed class TweenConfiguredSource : IUniTaskSource, ITaskPoolNode<TweenConfiguredSource>
+        {
+            static TaskPool<TweenConfiguredSource> pool;
+            public TweenConfiguredSource NextNode { get; set; }
+
+            static TweenConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(TweenConfiguredSource), () => pool.Size);
+            }
+
+            static readonly Action<object> CancellationCallbackDelegate = CancellationCallback;
+            static readonly TweenCallback EmptyTweenCallback = () => { };
+
+            readonly TweenCallback onKillDelegate;
+
+            Tween tween;
+            TweenCancelBehaviour cancelBehaviour;
+            CancellationToken cancellationToken;
+            bool canceled;
+
+            CancellationTokenRegistration cancellationTokenRegistration;
+            UniTaskCompletionSourceCore<AsyncUnit> core;
+
+            TweenConfiguredSource()
+            {
+                onKillDelegate = OnKill;
+            }
+
+            public static IUniTaskSource Create(Tween tween, TweenCancelBehaviour cancelBehaviour, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new TweenConfiguredSource();
+                }
+
+                result.tween = tween;
+                result.cancelBehaviour = cancelBehaviour;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                result.RegisterEvent();
+
+                token = result.core.Version;
+                return result;
+            }
+
+            void RegisterEvent()
+            {
+                if (cancellationToken.CanBeCanceled)
+                {
+                    cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(CancellationCallbackDelegate, this);
+                }
+
+                tween.OnKill(onKillDelegate);
+            }
+
+            void OnKill()
+            {
+                cancellationTokenRegistration.Dispose();
+                if (canceled)
+                {
+                    core.TrySetCanceled(cancellationToken);
+                }
+                else
+                {
+                    core.TrySetResult(AsyncUnit.Default);
+                }
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (TweenConfiguredSource)state;
+
+                switch (self.cancelBehaviour)
+                {
+                    case TweenCancelBehaviour.Kill:
+                    default:
+                        self.tween.Kill(false);
+                        break;
+                    case TweenCancelBehaviour.KillAndCancelAwait:
+                        self.canceled = true;
+                        self.tween.Kill(false);
+                        break;
+                    case TweenCancelBehaviour.KillWithCompleteCallback:
+                        self.tween.Kill(true);
+                        break;
+                    case TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait:
+                        self.canceled = true;
+                        self.tween.Kill(true);
+                        break;
+                    case TweenCancelBehaviour.Complete:
+                        self.tween.Complete(false);
+                        break;
+                    case TweenCancelBehaviour.CompleteAndCancelAwait:
+                        self.canceled = true;
+                        self.tween.Complete(false);
+                        break;
+                    case TweenCancelBehaviour.CompleteWithSeqeunceCallback:
+                        self.tween.Complete(true);
+                        break;
+                    case TweenCancelBehaviour.CompleteWithSeqeunceCallbackAndCancelAwait:
+                        self.canceled = true;
+                        self.tween.Complete(true);
+                        break;
+                    case TweenCancelBehaviour.CancelAwait:
+                        self.tween.onKill = EmptyTweenCallback; // replace to empty(avoid callback after Caceled(instance is returned to pool.)
+                        self.core.TrySetCanceled(self.cancellationToken);
+                        break;
+                }
+            }
+
+            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);
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                tween = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+
+            ~TweenConfiguredSource()
+            {
+                if (TryReturn())
+                {
+                    GC.ReRegisterForFinalize(this);
+                }
+            }
+        }
+    }
+
+    sealed class PooledTweenCallback
+    {
+        static readonly ConcurrentQueue<PooledTweenCallback> pool = new ConcurrentQueue<PooledTweenCallback>();
+
+        readonly TweenCallback runDelegate;
+
+        Action continuation;
+
+
+        PooledTweenCallback()
+        {
+            runDelegate = Run;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static TweenCallback Create(Action continuation)
+        {
+            if (!pool.TryDequeue(out var item))
+            {
+                item = new PooledTweenCallback();
+            }
+
+            item.continuation = continuation;
+            return item.runDelegate;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void Run()
+        {
+            var call = continuation;
+            continuation = null;
+            if (call != null)
+            {
+                pool.Enqueue(this);
+                call.Invoke();
+            }
+        }
+    }
+}
+
+#endif
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/External/DoTweenAsyncExtensions.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/External/DoTweenAsyncExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1f448d5bc5b232e4f98d89d5d1832e8e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/IUniTaskAsyncEnumerable.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/IUniTaskAsyncEnumerable.cs
@@ -28,6 +28,12 @@ namespace Cysharp.Threading.Tasks
        IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, CancellationToken, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending);
    }

+    public interface IConnectableUniTaskAsyncEnumerable<out T> : IUniTaskAsyncEnumerable<T>
+    {
+        IDisposable Connect();
+    }
+
+    // don't use AsyncGrouping.
    //public interface IUniTaskAsyncGrouping<out TKey, out TElement> : IUniTaskAsyncEnumerable<TElement>
    //{
    //    TKey Key { get; }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/IUniTaskSource.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/IUniTaskSource.cs
@@ -19,17 +19,75 @@ namespace Cysharp.Threading.Tasks

    // similar as IValueTaskSource
    public interface IUniTaskSource
+#if !UNITY_2018_3_OR_NEWER
+        : System.Threading.Tasks.Sources.IValueTaskSource
+#pragma warning disable CS0108
+#endif
    {
        UniTaskStatus GetStatus(short token);
        void OnCompleted(Action<object> continuation, object state, short token);
        void GetResult(short token);

        UniTaskStatus UnsafeGetStatus(); // only for debug use.
+
+#if !UNITY_2018_3_OR_NEWER
+#pragma warning restore CS0108
+
+        System.Threading.Tasks.Sources.ValueTaskSourceStatus System.Threading.Tasks.Sources.IValueTaskSource.GetStatus(short token)
+        {
+            return (System.Threading.Tasks.Sources.ValueTaskSourceStatus)(int)((IUniTaskSource)this).GetStatus(token);
+        }
+
+        void System.Threading.Tasks.Sources.IValueTaskSource.GetResult(short token)
+        {
+            ((IUniTaskSource)this).GetResult(token);
+        }
+
+        void System.Threading.Tasks.Sources.IValueTaskSource.OnCompleted(Action<object> continuation, object state, short token, System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags flags)
+        {
+            // ignore flags, always none.
+            ((IUniTaskSource)this).OnCompleted(continuation, state, token);
+        }
+
+#endif
    }

    public interface IUniTaskSource<out T> : IUniTaskSource
+#if !UNITY_2018_3_OR_NEWER
+        , System.Threading.Tasks.Sources.IValueTaskSource<T>
+#endif
    {
        new T GetResult(short token);
+
+#if !UNITY_2018_3_OR_NEWER
+
+        new public UniTaskStatus GetStatus(short token)
+        {
+            return ((IUniTaskSource)this).GetStatus(token);
+        }
+
+        new public void OnCompleted(Action<object> continuation, object state, short token)
+        {
+            ((IUniTaskSource)this).OnCompleted(continuation, state, token);
+        }
+
+        System.Threading.Tasks.Sources.ValueTaskSourceStatus System.Threading.Tasks.Sources.IValueTaskSource<T>.GetStatus(short token)
+        {
+            return (System.Threading.Tasks.Sources.ValueTaskSourceStatus)(int)((IUniTaskSource)this).GetStatus(token);
+        }
+
+        T System.Threading.Tasks.Sources.IValueTaskSource<T>.GetResult(short token)
+        {
+            return ((IUniTaskSource<T>)this).GetResult(token);
+        }
+
+        void System.Threading.Tasks.Sources.IValueTaskSource<T>.OnCompleted(Action<object> continuation, object state, short token, System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags flags)
+        {
+            // ignore flags, always none.
+            ((IUniTaskSource)this).OnCompleted(continuation, state, token);
+        }
+
+#endif
    }

    public static class UniTaskStatusExtensions
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/Hack.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/Hack.cs
@@ -1,23 +0,0 @@
-#if NET_4_6 || NET_STANDARD_2_0 || CSHARP_7_OR_LATER
-
-using System;
-
-namespace Cysharp.Threading.Tasks.Internal
-{
-    internal static class FuncExtensions
-    {
-        // avoid lambda capture
-
-        internal static Action<T> AsFuncOfT<T>(this Action action)
-        {
-            return new Action<T>(action.Invoke);
-        }
-
-        static void Invoke<T>(this Action action, T unused)
-        {
-            action();
-        }
-    }
-}
-
-#endif
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PooledDelegate.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PooledDelegate.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal sealed class PooledDelegate<T> : ITaskPoolNode<PooledDelegate<T>>
+    {
+        static TaskPool<PooledDelegate<T>> pool;
+
+        public PooledDelegate<T> NextNode { get; set; }
+
+        static PooledDelegate()
+        {
+            TaskPool.RegisterSizeGetter(typeof(PooledDelegate<T>), () => pool.Size);
+        }
+
+        readonly Action<T> runDelegate;
+        Action continuation;
+
+        PooledDelegate()
+        {
+            runDelegate = Run;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Action<T> Create(Action continuation)
+        {
+            if (!pool.TryPop(out var item))
+            {
+                item = new PooledDelegate<T>();
+            }
+
+            item.continuation = continuation;
+            return item.runDelegate;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void Run(T _)
+        {
+            var call = continuation;
+            continuation = null;
+            if (call != null)
+            {
+                pool.TryPush(this);
+                call.Invoke();
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PooledDelegate.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PooledDelegate.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8932579438742fa40b010edd412dbfba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PromisePool.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PromisePool.cs
@@ -1,55 +0,0 @@
-using System.Collections.Concurrent;
-using System.Runtime.CompilerServices;
-using System.Threading;
-
-namespace Cysharp.Threading.Tasks.Internal
-{
-    // public, allow to user create custom operator with pool.
-
-    public interface IPromisePoolItem
-    {
-        void Reset();
-    }
-
-    public class PromisePool<T>
-        where T : class, IPromisePoolItem
-    {
-        int count = 0;
-        readonly ConcurrentQueue<T> queue = new ConcurrentQueue<T>();
-        readonly int maxSize;
-
-        public PromisePool(int maxSize = 256)
-        {
-            this.maxSize = maxSize;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public T TryRent()
-        {
-            if (queue.TryDequeue(out var value))
-            {
-                Interlocked.Decrement(ref count);
-                return value;
-            }
-
-            return null;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool TryReturn(T value)
-        {
-            value.Reset(); // reset when return.
-
-            if (count < maxSize)
-            {
-                queue.Enqueue(value);
-                Interlocked.Increment(ref count);
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-    }
-}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/TaskTracker.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/TaskTracker.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Text;
 using System.Threading;
 using Cysharp.Threading.Tasks.Internal;

@@ -59,9 +60,9 @@ namespace Cysharp.Threading.Tasks
 #endif


-        static List<KeyValuePair<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)>> listPool = new List<KeyValuePair<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)>>();
+        static List<KeyValuePair<IUniTaskSource, (string formattedType, int trackingId, DateTime addTime, string stackTrace)>> listPool = new List<KeyValuePair<IUniTaskSource, (string formattedType, int trackingId, DateTime addTime, string stackTrace)>>();

-        static readonly WeakDictionary<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)> tracking = new WeakDictionary<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)>();
+        static readonly WeakDictionary<IUniTaskSource, (string formattedType, int trackingId, DateTime addTime, string stackTrace)> tracking = new WeakDictionary<IUniTaskSource, (string formattedType, int trackingId, DateTime addTime, string stackTrace)>();

        [Conditional("UNITY_EDITOR")]
        public static void TrackActiveTask(IUniTaskSource task, int skipFrame)
@@ -70,7 +71,19 @@ namespace Cysharp.Threading.Tasks
            dirty = true;
            if (!EditorEnableState.EnableTracking) return;
            var stackTrace = EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame, true).CleanupAsyncStackTrace() : "";
-            tracking.TryAdd(task, (Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace));
+
+            string typeName;
+            if (EditorEnableState.EnableStackTrace)
+            {
+                var sb = new StringBuilder();
+                TypeBeautify(task.GetType(), sb);
+                typeName = sb.ToString();
+            }
+            else
+            {
+                typeName = task.GetType().Name;
+            }
+            tracking.TryAdd(task, (typeName, Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace));
 #endif
        }

@@ -103,19 +116,8 @@ namespace Cysharp.Threading.Tasks
                {
                    for (int i = 0; i < count; i++)
                    {
-                        string typeName = null;
-                        var keyType = listPool[i].Key.GetType();
-                        if (keyType.IsNested)
-                        {
-                            typeName = keyType.DeclaringType.Name + "." + keyType.Name;
-                        }
-                        else
-                        {
-                            typeName = keyType.Name;
-                        }
-
-                        action(listPool[i].Value.trackingId, typeName, listPool[i].Key.UnsafeGetStatus(), listPool[i].Value.addTime, listPool[i].Value.stackTrace);
-                        listPool[i] = new KeyValuePair<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)>(null, (0, default(DateTime), null)); // clear
+                        action(listPool[i].Value.trackingId, listPool[i].Value.formattedType, listPool[i].Key.UnsafeGetStatus(), listPool[i].Value.addTime, listPool[i].Value.stackTrace);
+                        listPool[i] = default;
                    }
                }
                catch
@@ -125,6 +127,52 @@ namespace Cysharp.Threading.Tasks
                }
            }
        }
+
+        static void TypeBeautify(Type type, StringBuilder sb)
+        {
+            if (type.IsNested)
+            {
+                // TypeBeautify(type.DeclaringType, sb);
+                sb.Append(type.DeclaringType.Name.ToString());
+                sb.Append(".");
+            }
+
+            if (type.IsGenericType)
+            {
+                var genericsStart = type.Name.IndexOf("`");
+                if (genericsStart != -1)
+                {
+                    sb.Append(type.Name.Substring(0, genericsStart));
+                }
+                else
+                {
+                    sb.Append(type.Name);
+                }
+                sb.Append("<");
+                var first = true;
+                foreach (var item in type.GetGenericArguments())
+                {
+                    if (!first)
+                    {
+                        sb.Append(", ");
+                    }
+                    first = false;
+                    TypeBeautify(item, sb);
+                }
+                sb.Append(">");
+            }
+            else
+            {
+                sb.Append(type.Name);
+            }
+        }
+
+        //static string RemoveUniTaskNamespace(string str)
+        //{
+        //    return str.Replace("Cysharp.Threading.Tasks.CompilerServices", "")
+        //        .Replace("Cysharp.Threading.Tasks.Linq", "")
+        //        .Replace("Cysharp.Threading.Tasks", "");
+        //}
    }
 }

--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AppendPrepend.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AppendPrepend.cs
@@ -65,6 +65,8 @@ namespace Cysharp.Threading.Tasks.Linq
                this.element = element;
                this.state = append ? State.RequireAppend : State.RequirePrepend;
                this.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TSource Current { get; private set; }
@@ -136,6 +138,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AsyncEnumeratorBase.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AsyncEnumeratorBase.cs
@@ -3,66 +3,9 @@ using System.Threading;

 namespace Cysharp.Threading.Tasks.Linq
 {
-    public abstract class MoveNextSource : IUniTaskSource<bool>
-    {
-        protected UniTaskCompletionSourceCore<bool> completionSource;
-
-        public bool GetResult(short token)
-        {
-            return completionSource.GetResult(token);
-        }
-
-        public UniTaskStatus GetStatus(short token)
-        {
-            return completionSource.GetStatus(token);
-        }
-
-        public void OnCompleted(Action<object> continuation, object state, short token)
-        {
-            completionSource.OnCompleted(continuation, state, token);
-        }
-
-        public UniTaskStatus UnsafeGetStatus()
-        {
-            return completionSource.UnsafeGetStatus();
-        }
-
-        void IUniTaskSource.GetResult(short token)
-        {
-            completionSource.GetResult(token);
-        }
-
-        protected bool TryGetResult<T>(UniTask<T>.Awaiter awaiter, out T result)
-        {
-            try
-            {
-                result = awaiter.GetResult();
-                return true;
-            }
-            catch (Exception ex)
-            {
-                completionSource.TrySetException(ex);
-                result = default;
-                return false;
-            }
-        }
-
-        protected bool TryGetResult(UniTask.Awaiter awaiter)
-        {
-            try
-            {
-                awaiter.GetResult();
-                return true;
-            }
-            catch (Exception ex)
-            {
-                completionSource.TrySetException(ex);
-                return false;
-            }
-        }
-    }
-
-    public abstract class AsyncEnumeratorBase<TSource, TResult> : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
+    // note: refactor all inherit class and should remove this.
+    // see Select and Where.
+    internal abstract class AsyncEnumeratorBase<TSource, TResult> : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
    {
        static readonly Action<object> moveNextCallbackDelegate = MoveNextCallBack;

@@ -76,6 +19,7 @@ namespace Cysharp.Threading.Tasks.Linq
        {
            this.source = source;
            this.cancellationToken = cancellationToken;
+            TaskTracker.TrackActiveTask(this, 4);
        }

        // abstract
@@ -178,6 +122,7 @@ namespace Cysharp.Threading.Tasks.Linq
        // if require additional resource to dispose, override and call base.DisposeAsync.
        public virtual UniTask DisposeAsync()
        {
+            TaskTracker.RemoveTracking(this);
            if (enumerator != null)
            {
                return enumerator.DisposeAsync();
@@ -186,7 +131,7 @@ namespace Cysharp.Threading.Tasks.Linq
        }
    }

-    public abstract class AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TAwait> : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
+    internal abstract class AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TAwait> : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
    {
        static readonly Action<object> moveNextCallbackDelegate = MoveNextCallBack;
        static readonly Action<object> setCurrentCallbackDelegate = SetCurrentCallBack;
@@ -204,6 +149,7 @@ namespace Cysharp.Threading.Tasks.Linq
        {
            this.source = source;
            this.cancellationToken = cancellationToken;
+            TaskTracker.TrackActiveTask(this, 4);
        }

        // abstract
@@ -399,6 +345,7 @@ namespace Cysharp.Threading.Tasks.Linq
        // if require additional resource to dispose, override and call base.DisposeAsync.
        public virtual UniTask DisposeAsync()
        {
+            TaskTracker.RemoveTracking(this);
            if (enumerator != null)
            {
                return enumerator.DisposeAsync();
@@ -406,5 +353,4 @@ namespace Cysharp.Threading.Tasks.Linq
            return default;
        }
    }
-
 }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Buffer.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Buffer.cs
@@ -61,6 +61,8 @@ namespace Cysharp.Threading.Tasks.Linq
                this.source = source;
                this.count = count;
                this.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public IList<TSource> Current { get; private set; }
@@ -167,6 +169,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
@@ -217,6 +220,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.count = count;
                this.skip = skip;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public IList<TSource> Current { get; private set; }
@@ -329,6 +333,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.cs
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6cb07f6e88287e34d9b9301a572284a5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.tt
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.tt
@@ -0,0 +1,221 @@
+<#@ 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 tMax = 15;
+    Func<int, string> typeArgs = x => string.Join(", ", Enumerable.Range(1, x).Select(x => $"T{x}")) + ", TResult";
+    Func<int, string> paramArgs = x => string.Join(", ", Enumerable.Range(1, x).Select(x => $"IUniTaskAsyncEnumerable<T{x}> source{x}"));
+    Func<int, string> parameters = x => string.Join(", ", Enumerable.Range(1, x).Select(x => $"source{x}"));
+
+
+#>
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+<# for(var i = 2; i <= tMax; i++) { #>
+        public static IUniTaskAsyncEnumerable<TResult> CombineLatest<<#= typeArgs(i) #>>(this <#= paramArgs(i) #>, Func<<#= typeArgs(i) #>> resultSelector)
+        {
+<# for(var j = 1; j <= i; j++) { #>
+            Error.ThrowArgumentNullException(source<#= j #>, nameof(source<#= j #>));
+<# } #>
+            Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector));
+
+            return new CombineLatest<<#= typeArgs(i) #>>(<#= parameters(i) #>, resultSelector);
+        }
+
+<# } #>
+    }
+
+<# for(var i = 2; i <= tMax; i++) { #>
+    internal class CombineLatest<<#= typeArgs(i) #>> : IUniTaskAsyncEnumerable<TResult>
+    {
+<# for(var j = 1; j <= i; j++) { #>
+        readonly IUniTaskAsyncEnumerable<T<#= j #>> source<#= j #>;
+<# } #>        
+        readonly Func<<#= typeArgs(i) #>> resultSelector;
+
+        public CombineLatest(<#= paramArgs(i) #>, Func<<#= typeArgs(i) #>> resultSelector)
+        {
+<# for(var j = 1; j <= i; j++) { #>
+            this.source<#= j #> = source<#= j #>;
+<# } #>        
+            this.resultSelector = resultSelector;
+        }
+
+        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _CombineLatest(<#= parameters(i) #>, resultSelector, cancellationToken);
+        }
+
+        class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
+        {
+<# for(var j = 1; j <= i; j++) { #>
+            static readonly Action<object> Completed<#= j #>Delegate = Completed<#= j #>;
+<# } #>
+            const int CompleteCount = <#= i #>;
+
+<# for(var j = 1; j <= i; j++) { #>
+            readonly IUniTaskAsyncEnumerable<T<#= j #>> source<#= j #>;
+<# } #>       
+            readonly Func<<#= typeArgs(i) #>> resultSelector;
+            CancellationToken cancellationToken;
+
+<# for(var j = 1; j <= i; j++) { #>
+            IUniTaskAsyncEnumerator<T<#= j #>> enumerator<#= j #>;
+            UniTask<bool>.Awaiter awaiter<#= j #>;
+            bool hasCurrent<#= j #>;
+            bool running<#= j #>;
+            T<#= j #> current<#= j #>;
+
+<# } #>
+            int completedCount;
+            bool syncRunning;
+            TResult result;
+
+            public _CombineLatest(<#= paramArgs(i) #>, Func<<#= typeArgs(i) #>> resultSelector, CancellationToken cancellationToken)
+            {
+<# for(var j = 1; j <= i; j++) { #>
+                this.source<#= j #> = source<#= j #>;
+<# } #>                
+                this.resultSelector = resultSelector;
+                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
+            }
+
+            public TResult Current => result;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                if (completedCount == CompleteCount) return CompletedTasks.False;
+
+                if (enumerator1 == null)
+                {
+<# for(var j = 1; j <= i; j++) { #>
+                    enumerator<#= j #> = source<#= j #>.GetAsyncEnumerator(cancellationToken);
+<# } #>
+                }
+
+                completionSource.Reset();
+
+                AGAIN:
+                syncRunning = true;
+<# for(var j = 1; j <= i; j++) { #>
+                if (!running<#= j #>)
+                {
+                    running<#= j #> = true;
+                    awaiter<#= j #> = enumerator<#= j #>.MoveNextAsync().GetAwaiter();
+                    if (awaiter<#= j #>.IsCompleted)
+                    {
+                        Completed<#= j #>(this);
+                    }
+                    else
+                    {
+                        awaiter<#= j #>.SourceOnCompleted(Completed<#= j #>Delegate, this);
+                    }
+                }
+<# } #>
+
+                if (<#= string.Join(" || ", Enumerable.Range(1, i).Select(x => $"!running{x}")) #>)
+                {
+                    goto AGAIN;
+                }
+                syncRunning = false;
+
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+<# for(var j = 1; j <= i; j++) { #>
+            static void Completed<#= j #>(object state)
+            {
+                var self = (_CombineLatest)state;
+                self.running<#= j #> = false;
+
+                try
+                {
+                    if (self.awaiter<#= j #>.GetResult())
+                    {
+                        self.hasCurrent<#= j #> = true;
+                        self.current<#= j #> = self.enumerator<#= j #>.Current;
+                        goto SUCCESS;
+                    }
+                    else
+                    {
+                        self.running<#= j #> = true; // as complete, no more call MoveNextAsync.
+                        if (Interlocked.Increment(ref self.completedCount) == CompleteCount)
+                        {
+                            goto COMPLETE;
+                        }
+                        return;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    self.running<#= j #> = true; // as complete, no more call MoveNextAsync.
+                    self.completedCount = CompleteCount;
+                    self.completionSource.TrySetException(ex);
+                    return;
+                }
+
+                SUCCESS:
+                if (!self.TrySetResult())
+                {
+                    if (self.syncRunning) return;
+                    self.running<#= j #> = true; // as complete, no more call MoveNextAsync.
+                    try
+                    {
+                        self.awaiter<#= j #> = self.enumerator<#= j #>.MoveNextAsync().GetAwaiter();
+                    }
+                    catch (Exception ex)
+                    {
+                        self.completedCount = CompleteCount;
+                        self.completionSource.TrySetException(ex);
+                        return;
+                    }
+
+                    self.awaiter<#= j #>.SourceOnCompleted(Completed<#= j #>Delegate, self);
+                }
+                return;
+                COMPLETE:
+                self.completionSource.TrySetResult(false);
+                return;
+            }
+
+<# } #>
+            bool TrySetResult()
+            {
+                if (<#= string.Join(" && ", Enumerable.Range(1, i).Select(x => $"hasCurrent{x}")) #>)
+                {
+                    result = resultSelector(<#= string.Join(", ", Enumerable.Range(1, i).Select(x => $"current{x}")) #>);
+                    completionSource.TrySetResult(true);
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            public async UniTask DisposeAsync()
+            {
+                TaskTracker.RemoveTracking(this);
+<# for(var j = 1; j <= i; j++) { #>
+                if (enumerator<#= j #> != null)
+                {
+                    await enumerator<#= j #>.DisposeAsync();
+                }
+<# } #>
+            }
+        }
+    }
+
+<# } #>
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.tt.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.tt.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b1b8cfa9d17af814a971ee2224aaaaa2
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Concat.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Concat.cs
@@ -57,6 +57,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.second = second;
                this.cancellationToken = cancellationToken;
                this.iteratingState = IteratingState.IteratingFirst;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TSource Current { get; private set; }
@@ -150,6 +151,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/DefaultIfEmpty.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/DefaultIfEmpty.cs
@@ -63,6 +63,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.cancellationToken = cancellationToken;

                this.iteratingState = IteratingState.Empty;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TSource Current { get; private set; }
@@ -128,6 +129,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/DistinctUntilChanged.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/DistinctUntilChanged.cs
@@ -79,41 +79,123 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _DistinctUntilChanged(source, comparer, cancellationToken);
        }

-        class _DistinctUntilChanged : AsyncEnumeratorBase<TSource, TSource>
+        sealed class _DistinctUntilChanged : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly IEqualityComparer<TSource> comparer;
-            TSource prev;
-            bool first;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            Action moveNextAction;

            public _DistinctUntilChanged(IUniTaskAsyncEnumerable<TSource> source, IEqualityComparer<TSource> comparer, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
            {
+                this.source = source;
                this.comparer = comparer;
-                this.first = true;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                if (sourceHasCurrent)
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void MoveNext()
+            {
+                REPEAT:
+                try
                {
-                    var v = SourceCurrent;
-                    if (first || !comparer.Equals(prev, v))
+                    switch (state)
                    {
-                        first = false;
-                        Current = prev = v;
-                        result = true;
-                        return true;
-                    }
-                    else
-                    {
-                        result = default;
-                        return false;
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case -3;
+                            }
+                            else
+                            {
+                                state = -3;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case -3: // first
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 0: // normal
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                var v = enumerator.Current;
+                                if (!comparer.Equals(Current, v))
+                                {
+                                    Current = v;
+                                    goto CONTINUE;
+                                }
+                                else
+                                {
+                                    state = 0;
+                                    goto REPEAT;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case -2:
+                        default:
+                            goto DONE;
                    }
                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }

-                result = false;
-                return true;
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -136,45 +218,128 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _DistinctUntilChanged(source, keySelector, comparer, cancellationToken);
        }

-        class _DistinctUntilChanged : AsyncEnumeratorBase<TSource, TSource>
+        sealed class _DistinctUntilChanged : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
-            readonly IEqualityComparer<TKey> comparer;
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, TKey> keySelector;
+            readonly IEqualityComparer<TKey> comparer;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            Action moveNextAction;
            TKey prev;
-            bool first;

            public _DistinctUntilChanged(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
            {
-                this.comparer = comparer;
+                this.source = source;
                this.keySelector = keySelector;
-                this.first = true;
+                this.comparer = comparer;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                if (sourceHasCurrent)
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void MoveNext()
+            {
+                REPEAT:
+                try
                {
-                    var v = SourceCurrent;
-                    var key = keySelector(v);
-                    if (first || !comparer.Equals(prev, key))
+                    switch (state)
                    {
-                        first = false;
-                        prev = key;
-                        Current = v;
-                        result = true;
-                        return true;
-                    }
-                    else
-                    {
-                        result = default;
-                        return false;
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case -3;
+                            }
+                            else
+                            {
+                                state = -3;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case -3: // first
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 0: // normal
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                var v = enumerator.Current;
+                                var key = keySelector(v);
+                                if (!comparer.Equals(prev, key))
+                                {
+                                    prev = key;
+                                    Current = v;
+                                    goto CONTINUE;
+                                }
+                                else
+                                {
+                                    state = 0;
+                                    goto REPEAT;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case -2:
+                        default:
+                            goto DONE;
                    }
                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }

-                result = false;
-                return true;
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -197,42 +362,142 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _DistinctUntilChangedAwait(source, keySelector, comparer, cancellationToken);
        }

-        class _DistinctUntilChangedAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, TKey>
+        sealed class _DistinctUntilChangedAwait : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
-            readonly IEqualityComparer<TKey> comparer;
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, UniTask<TKey>> keySelector;
+            readonly IEqualityComparer<TKey> comparer;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<TKey>.Awaiter awaiter2;
+            Action moveNextAction;
+            TSource enumeratorCurrent;
            TKey prev;
-            bool first;

            public _DistinctUntilChangedAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
            {
-                this.comparer = comparer;
+                this.source = source;
                this.keySelector = keySelector;
-                this.first = true;
+                this.comparer = comparer;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<TKey> TransformAsync(TSource sourceCurrent)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return keySelector(sourceCurrent);
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(TKey key, out bool terminateIteration)
+            void MoveNext()
            {
-                if (first || !comparer.Equals(prev, key))
+                REPEAT:
+                try
                {
-                    first = false;
-                    prev = key;
-                    Current = SourceCurrent;
-                    terminateIteration = false;
-                    return true;
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case -3;
+                            }
+                            else
+                            {
+                                state = -3;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case -3: // first
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 0: // normal
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                enumeratorCurrent = enumerator.Current;
+                                awaiter2 = keySelector(enumeratorCurrent).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            var key = awaiter2.GetResult();
+                            if (!comparer.Equals(prev, key))
+                            {
+                                prev = key;
+                                Current = enumeratorCurrent;
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                state = 0;
+                                goto REPEAT;
+                            }
+                        case -2:
+                        default:
+                            goto DONE;
+                    }
                }
-                else
+                catch (Exception ex)
                {
-                    terminateIteration = false;
-                    return false;
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -255,42 +520,142 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _DistinctUntilChangedAwaitWithCancellation(source, keySelector, comparer, cancellationToken);
        }

-        class _DistinctUntilChangedAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, TKey>
+        sealed class _DistinctUntilChangedAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
-            readonly IEqualityComparer<TKey> comparer;
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, CancellationToken, UniTask<TKey>> keySelector;
+            readonly IEqualityComparer<TKey> comparer;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<TKey>.Awaiter awaiter2;
+            Action moveNextAction;
+            TSource enumeratorCurrent;
            TKey prev;
-            bool first;

            public _DistinctUntilChangedAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
            {
-                this.comparer = comparer;
+                this.source = source;
                this.keySelector = keySelector;
-                this.first = true;
+                this.comparer = comparer;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<TKey> TransformAsync(TSource sourceCurrent)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return keySelector(sourceCurrent, cancellationToken);
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(TKey key, out bool terminateIteration)
+            void MoveNext()
            {
-                if (first || !comparer.Equals(prev, key))
+                REPEAT:
+                try
                {
-                    first = false;
-                    prev = key;
-                    Current = SourceCurrent;
-                    terminateIteration = false;
-                    return true;
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case -3;
+                            }
+                            else
+                            {
+                                state = -3;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case -3: // first
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 0: // normal
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                enumeratorCurrent = enumerator.Current;
+                                awaiter2 = keySelector(enumeratorCurrent, cancellationToken).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            var key = awaiter2.GetResult();
+                            if (!comparer.Equals(prev, key))
+                            {
+                                prev = key;
+                                Current = enumeratorCurrent;
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                state = 0;
+                                goto REPEAT;
+                            }
+                        case -2:
+                        default:
+                            goto DONE;
+                    }
                }
-                else
+                catch (Exception ex)
                {
-                    terminateIteration = false;
-                    return false;
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Do.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Do.cs
@@ -124,6 +124,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.onError = onError;
                this.onCompleted = onCompleted;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TSource Current { get; private set; }
@@ -244,6 +245,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ForEach.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ForEach.cs
@@ -22,6 +22,22 @@ namespace Cysharp.Threading.Tasks.Linq
            return Cysharp.Threading.Tasks.Linq.ForEach.ForEachAsync(source, action, cancellationToken);
        }

+        /// <summary>Obsolete(Error), Use Use ForEachAwaitAsync instead.</summary>
+        [Obsolete("Use ForEachAwaitAsync instead.", true)]
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public static UniTask ForEachAsync<T>(this IUniTaskAsyncEnumerable<T> source, Func<T, UniTask> action, CancellationToken cancellationToken = default)
+        {
+            throw new NotSupportedException("Use ForEachAwaitAsync instead.");
+        }
+
+        /// <summary>Obsolete(Error), Use Use ForEachAwaitAsync instead.</summary>
+        [Obsolete("Use ForEachAwaitAsync instead.", true)]
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public static UniTask ForEachAsync<T>(this IUniTaskAsyncEnumerable<T> source, Func<T, int, UniTask> action, CancellationToken cancellationToken = default)
+        {
+            throw new NotSupportedException("Use ForEachAwaitAsync instead.");
+        }
+
        public static UniTask ForEachAwaitAsync<TSource>(this IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask> action, CancellationToken cancellationToken = default)
        {
            Error.ThrowArgumentNullException(source, nameof(source));
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/GroupBy.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/GroupBy.cs
@@ -255,6 +255,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.elementSelector = elementSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public IGrouping<TKey, TElement> Current { get; private set; }
@@ -313,6 +314,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (groupEnumerator != null)
                {
                    groupEnumerator.Dispose();
@@ -364,6 +366,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -423,6 +426,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (groupEnumerator != null)
                {
                    groupEnumerator.Dispose();
@@ -470,6 +474,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.elementSelector = elementSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public IGrouping<TKey, TElement> Current { get; private set; }
@@ -528,6 +533,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (groupEnumerator != null)
                {
                    groupEnumerator.Dispose();
@@ -582,6 +588,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -661,6 +668,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (groupEnumerator != null)
                {
                    groupEnumerator.Dispose();
@@ -708,6 +716,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.elementSelector = elementSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public IGrouping<TKey, TElement> Current { get; private set; }
@@ -766,6 +775,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (groupEnumerator != null)
                {
                    groupEnumerator.Dispose();
@@ -820,6 +830,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -899,6 +910,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (groupEnumerator != null)
                {
                    groupEnumerator.Dispose();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/GroupJoin.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/GroupJoin.cs
@@ -129,6 +129,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -208,6 +209,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
@@ -273,6 +275,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -401,6 +404,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
@@ -466,6 +470,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -594,6 +599,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Join.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Join.cs
@@ -131,6 +131,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -248,6 +249,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (valueEnumerator != null)
                {
                    valueEnumerator.Dispose();
@@ -321,6 +323,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -476,6 +479,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (valueEnumerator != null)
                {
                    valueEnumerator.Dispose();
@@ -549,6 +553,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.resultSelector = resultSelector;
                this.comparer = comparer;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -704,6 +709,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (valueEnumerator != null)
                {
                    valueEnumerator.Dispose();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/OrderBy.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/OrderBy.cs
@@ -422,6 +422,7 @@ namespace Cysharp.Threading.Tasks.Linq
            {
                this.parent = parent;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TElement Current { get; private set; }
@@ -477,6 +478,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                return default;
            }
        }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Pairwise.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Pairwise.cs
@@ -0,0 +1,128 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<(TSource, TSource)> Pairwise<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
+        {
+            Error.ThrowArgumentNullException(source, nameof(source));
+
+            return new Pairwise<TSource>(source);
+        }
+    }
+
+    internal sealed class Pairwise<TSource> : IUniTaskAsyncEnumerable<(TSource, TSource)>
+    {
+        readonly IUniTaskAsyncEnumerable<TSource> source;
+
+        public Pairwise(IUniTaskAsyncEnumerable<TSource> source)
+        {
+            this.source = source;
+        }
+
+        public IUniTaskAsyncEnumerator<(TSource, TSource)> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _Pairwise(source, cancellationToken);
+        }
+
+        sealed class _Pairwise : MoveNextSource, IUniTaskAsyncEnumerator<(TSource, TSource)>
+        {
+            static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;
+
+            readonly IUniTaskAsyncEnumerable<TSource> source;
+            CancellationToken cancellationToken;
+
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+
+            TSource prev;
+            bool isFirst;
+
+            public _Pairwise(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+            {
+                this.source = source;
+                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
+            }
+
+            public (TSource, TSource) Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (enumerator == null)
+                {
+                    isFirst = true;
+                    enumerator = source.GetAsyncEnumerator(cancellationToken);
+                }
+
+                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 = (_Pairwise)state;
+
+                if (self.TryGetResult(self.awaiter, out var result))
+                {
+                    if (result)
+                    {
+                        if (self.isFirst)
+                        {
+                            self.isFirst = false;
+                            self.prev = self.enumerator.Current;
+                            self.SourceMoveNext(); // run again. okay to use recursive(only one more).
+                        }
+                        else
+                        {
+                            var p = self.prev;
+                            self.prev = self.enumerator.Current;
+                            self.Current = (p, self.prev);
+                            self.completionSource.TrySetResult(true);
+                        }
+                    }
+                    else
+                    {
+                        self.completionSource.TrySetResult(false);
+                    }
+                }
+            }
+
+            public UniTask DisposeAsync()
+            {
+                TaskTracker.RemoveTracking(this);
+                if (enumerator != null)
+                {
+                    return enumerator.DisposeAsync();
+                }
+                return default;
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Pairwise.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Pairwise.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cddbf051d2a88f549986c468b23214af
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Publish.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Publish.cs
@@ -0,0 +1,173 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IConnectableUniTaskAsyncEnumerable<TSource> Publish<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
+        {
+            Error.ThrowArgumentNullException(source, nameof(source));
+
+            return new Publish<TSource>(source);
+        }
+    }
+
+    internal sealed class Publish<TSource> : IConnectableUniTaskAsyncEnumerable<TSource>
+    {
+        readonly IUniTaskAsyncEnumerable<TSource> source;
+        readonly CancellationTokenSource cancellationTokenSource;
+
+        TriggerEvent<TSource> trigger;
+        IUniTaskAsyncEnumerator<TSource> enumerator;
+        IDisposable connectedDisposable;
+        bool isCompleted;
+
+        public Publish(IUniTaskAsyncEnumerable<TSource> source)
+        {
+            this.source = source;
+            this.cancellationTokenSource = new CancellationTokenSource();
+        }
+
+        public IDisposable Connect()
+        {
+            if (connectedDisposable != null) return connectedDisposable;
+
+            if (enumerator == null)
+            {
+                enumerator = source.GetAsyncEnumerator(cancellationTokenSource.Token);
+            }
+
+            ConsumeEnumerator().Forget();
+
+            connectedDisposable = new ConnectDisposable(cancellationTokenSource);
+            return connectedDisposable;
+        }
+
+        async UniTaskVoid ConsumeEnumerator()
+        {
+            try
+            {
+                try
+                {
+                    while (await enumerator.MoveNextAsync())
+                    {
+                        trigger.SetResult(enumerator.Current);
+                    }
+                    trigger.SetCompleted();
+                }
+                catch (Exception ex)
+                {
+                    trigger.SetError(ex);
+                }
+            }
+            finally
+            {
+                isCompleted = true;
+                await enumerator.DisposeAsync();
+            }
+        }
+
+        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _Publish(this, cancellationToken);
+        }
+
+        sealed class ConnectDisposable : IDisposable
+        {
+            readonly CancellationTokenSource cancellationTokenSource;
+
+            public ConnectDisposable(CancellationTokenSource cancellationTokenSource)
+            {
+                this.cancellationTokenSource = cancellationTokenSource;
+            }
+
+            public void Dispose()
+            {
+                this.cancellationTokenSource.Cancel();
+            }
+        }
+
+        sealed class _Publish : MoveNextSource, IUniTaskAsyncEnumerator<TSource>, ITriggerHandler<TSource>
+        {
+            static readonly Action<object> CancelDelegate = OnCanceled;
+
+            readonly Publish<TSource> parent;
+            CancellationToken cancellationToken;
+            CancellationTokenRegistration cancellationTokenRegistration;
+            bool isDisposed;
+
+            public _Publish(Publish<TSource> parent, CancellationToken cancellationToken)
+            {
+                if (cancellationToken.IsCancellationRequested) return;
+
+                this.parent = parent;
+                this.cancellationToken = cancellationToken;
+
+                if (cancellationToken.CanBeCanceled)
+                {
+                    this.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(CancelDelegate, this);
+                }
+
+                parent.trigger.Add(this);
+                TaskTracker.TrackActiveTask(this, 3);
+            }
+
+            public TSource Current { get; private set; }
+            ITriggerHandler<TSource> ITriggerHandler<TSource>.Prev { get; set; }
+            ITriggerHandler<TSource> ITriggerHandler<TSource>.Next { get; set; }
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (parent.isCompleted) return CompletedTasks.False;
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            static void OnCanceled(object state)
+            {
+                var self = (_Publish)state;
+                self.completionSource.TrySetCanceled(self.cancellationToken);
+                self.DisposeAsync().Forget();
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!isDisposed)
+                {
+                    isDisposed = true;
+                    TaskTracker.RemoveTracking(this);
+                    cancellationTokenRegistration.Dispose();
+                    parent.trigger.Remove(this);
+                }
+
+                return default;
+            }
+
+            public void OnNext(TSource value)
+            {
+                Current = value;
+                completionSource.TrySetResult(true);
+            }
+
+            public void OnCanceled(CancellationToken cancellationToken)
+            {
+                completionSource.TrySetCanceled(cancellationToken);
+            }
+
+            public void OnCompleted()
+            {
+                completionSource.TrySetResult(false);
+            }
+
+            public void OnError(Exception ex)
+            {
+                completionSource.TrySetException(ex);
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Publish.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Publish.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 93c684d1e88c09d4e89b79437d97b810
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Queue.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Queue.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<TSource> Queue<TSource>(this IUniTaskAsyncEnumerable<TSource> source)
+        {
+            return new QueueOperator<TSource>(source);
+        }
+    }
+
+    internal sealed class QueueOperator<TSource> : IUniTaskAsyncEnumerable<TSource>
+    {
+        readonly IUniTaskAsyncEnumerable<TSource> source;
+
+        public QueueOperator(IUniTaskAsyncEnumerable<TSource> source)
+        {
+            this.source = source;
+        }
+
+        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _Queue(source, cancellationToken);
+        }
+
+        sealed class _Queue : IUniTaskAsyncEnumerator<TSource>
+        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
+            CancellationToken cancellationToken;
+
+            Channel<TSource> channel;
+            IUniTaskAsyncEnumerator<TSource> channelEnumerator;
+            IUniTaskAsyncEnumerator<TSource> sourceEnumerator;
+            bool channelClosed;
+
+            public _Queue(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+            {
+                this.source = source;
+                this.cancellationToken = cancellationToken;
+            }
+
+            public TSource Current => channelEnumerator.Current;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (sourceEnumerator == null)
+                {
+                    sourceEnumerator = source.GetAsyncEnumerator(cancellationToken);
+                    channel = Channel.CreateSingleConsumerUnbounded<TSource>();
+
+                    channelEnumerator = channel.Reader.ReadAllAsync().GetAsyncEnumerator(cancellationToken);
+
+                    ConsumeAll(this, sourceEnumerator, channel).Forget();
+                }
+
+                return channelEnumerator.MoveNextAsync();
+            }
+
+            static async UniTaskVoid ConsumeAll(_Queue self, IUniTaskAsyncEnumerator<TSource> enumerator, ChannelWriter<TSource> writer)
+            {
+                try
+                {
+                    while (await enumerator.MoveNextAsync())
+                    {
+                        writer.TryWrite(enumerator.Current);
+                    }
+                    writer.TryComplete();
+                }
+                catch (Exception ex)
+                {
+                    writer.TryComplete(ex);
+                }
+                finally
+                {
+                    self.channelClosed = true;
+                    await enumerator.DisposeAsync();
+                }
+            }
+
+            public async UniTask DisposeAsync()
+            {
+                if (sourceEnumerator != null)
+                {
+                    await sourceEnumerator.DisposeAsync();
+                }
+                if (channelEnumerator != null)
+                {
+                    await channelEnumerator.DisposeAsync();
+                }
+
+                if (!channelClosed)
+                {
+                    channelClosed = true;
+                    channel.Writer.TryComplete(new OperationCanceledException());
+                }
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Queue.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Queue.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b7ea1bcf9dbebb042bc99c7816249e02
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Reverse.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Reverse.cs
@@ -40,6 +40,7 @@ namespace Cysharp.Threading.Tasks.Linq
            {
                this.source = source;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TSource Current { get; private set; }
@@ -69,6 +70,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                return default;
            }
        }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Select.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Select.cs
@@ -71,29 +71,92 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _Select(source, selector, cancellationToken);
        }

-        sealed class _Select : AsyncEnumeratorBase<TSource, TResult>
+        sealed class _Select : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, TResult> selector;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            Action moveNextAction;

            public _Select(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, TResult> selector, CancellationToken cancellationToken)
-                : base(source, cancellationToken)
            {
+                this.source = source;
                this.selector = selector;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
+            public TResult Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                if (sourceHasCurrent)
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void MoveNext()
+            {
+                try
                {
-                    Current = selector(SourceCurrent);
-                    result = true;
-                    return true;
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                Current = selector(enumerator.Current);
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        default:
+                            goto DONE;
+                    }
                }
-                else
+                catch (Exception ex)
                {
-                    result = false;
-                    return true;
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -111,33 +174,96 @@ namespace Cysharp.Threading.Tasks.Linq

        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
        {
-            return new _SelectInt(source, selector, cancellationToken);
+            return new _Select(source, selector, cancellationToken);
        }

-        sealed class _SelectInt : AsyncEnumeratorBase<TSource, TResult>
+        sealed class _Select : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, int, TResult> selector;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            Action moveNextAction;
            int index;

-            public _SelectInt(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, TResult> selector, CancellationToken cancellationToken)
-                : base(source, cancellationToken)
+            public _Select(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, TResult> selector, CancellationToken cancellationToken)
            {
+                this.source = source;
                this.selector = selector;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
+            public TResult Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                if (sourceHasCurrent)
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void MoveNext()
+            {
+                try
                {
-                    Current = selector(SourceCurrent, checked(index++));
-                    result = true;
-                    return true;
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                Current = selector(enumerator.Current, checked(index++));
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        default:
+                            goto DONE;
+                    }
                }
-                else
+                catch (Exception ex)
                {
-                    result = false;
-                    return true;
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -158,26 +284,105 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _SelectAwait(source, selector, cancellationToken);
        }

-        sealed class _SelectAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TResult>
+        sealed class _SelectAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, UniTask<TResult>> selector;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<TResult>.Awaiter awaiter2;
+            Action moveNextAction;

            public _SelectAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<TResult>> selector, CancellationToken cancellationToken)
-                : base(source, cancellationToken)
            {
+                this.source = source;
                this.selector = selector;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<TResult> TransformAsync(TSource sourceCurrent)
+            public TResult Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return selector(sourceCurrent);
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(TResult awaitResult, out bool terminateIteration)
+            void MoveNext()
            {
-                Current = awaitResult;
-                terminateIteration = false;
-                return true;
+                try
+                {
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                awaiter2 = selector(enumerator.Current).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            Current = awaiter2.GetResult();
+                            goto CONTINUE;
+                        default:
+                            goto DONE;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -195,30 +400,109 @@ namespace Cysharp.Threading.Tasks.Linq

        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
        {
-            return new _SelectIntAwait(source, selector, cancellationToken);
+            return new _SelectAwait(source, selector, cancellationToken);
        }

-        sealed class _SelectIntAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TResult>
+        sealed class _SelectAwait : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, int, UniTask<TResult>> selector;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<TResult>.Awaiter awaiter2;
+            Action moveNextAction;
            int index;

-            public _SelectIntAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<TResult>> selector, CancellationToken cancellationToken)
-                : base(source, cancellationToken)
+            public _SelectAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<TResult>> selector, CancellationToken cancellationToken)
            {
+                this.source = source;
                this.selector = selector;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<TResult> TransformAsync(TSource sourceCurrent)
+            public TResult Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return selector(sourceCurrent, checked(index++));
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(TResult awaitResult, out bool terminateIteration)
+            void MoveNext()
            {
-                Current = awaitResult;
-                terminateIteration = false;
-                return true;
+                try
+                {
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                awaiter2 = selector(enumerator.Current, checked(index++)).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            Current = awaiter2.GetResult();
+                            goto CONTINUE;
+                        default:
+                            goto DONE;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -239,26 +523,105 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _SelectAwaitWithCancellation(source, selector, cancellationToken);
        }

-        sealed class _SelectAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TResult>
+        sealed class _SelectAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, CancellationToken, UniTask<TResult>> selector;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<TResult>.Awaiter awaiter2;
+            Action moveNextAction;

            public _SelectAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken)
-                : base(source, cancellationToken)
            {
+                this.source = source;
                this.selector = selector;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<TResult> TransformAsync(TSource sourceCurrent)
+            public TResult Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return selector(sourceCurrent, cancellationToken);
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(TResult awaitResult, out bool terminateIteration)
+            void MoveNext()
            {
-                Current = awaitResult;
-                terminateIteration = false;
-                return true;
+                try
+                {
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                awaiter2 = selector(enumerator.Current, cancellationToken).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            Current = awaiter2.GetResult();
+                            goto CONTINUE;
+                        default:
+                            goto DONE;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -276,32 +639,110 @@ namespace Cysharp.Threading.Tasks.Linq

        public IUniTaskAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default)
        {
-            return new _SelectIntAwaitWithCancellation(source, selector, cancellationToken);
+            return new _SelectAwaitWithCancellation(source, selector, cancellationToken);
        }

-        sealed class _SelectIntAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TResult, TResult>
+        sealed class _SelectAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TResult>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, int, CancellationToken, UniTask<TResult>> selector;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<TResult>.Awaiter awaiter2;
+            Action moveNextAction;
            int index;

-            public _SelectIntAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken)
-                : base(source, cancellationToken)
+            public _SelectAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<TResult>> selector, CancellationToken cancellationToken)
            {
+                this.source = source;
                this.selector = selector;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<TResult> TransformAsync(TSource sourceCurrent)
+            public TResult Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return selector(sourceCurrent, checked(index++), cancellationToken);
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(TResult awaitResult, out bool terminateIteration)
+            void MoveNext()
            {
-                Current = awaitResult;
-                terminateIteration = false;
-                return true;
+                try
+                {
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                awaiter2 = selector(enumerator.Current, checked(index++), cancellationToken).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            Current = awaiter2.GetResult();
+                            goto CONTINUE;
+                        default:
+                            goto DONE;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
-
 }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SelectMany.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SelectMany.cs
@@ -160,6 +160,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.selector2 = selector2;
                this.resultSelector = resultSelector;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -324,6 +325,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public async UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (selectedEnumerator != null)
                {
                    await selectedEnumerator.DisposeAsync();
@@ -398,6 +400,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.selector2 = selector2;
                this.resultSelector = resultSelector;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -598,6 +601,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public async UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (selectedEnumerator != null)
                {
                    await selectedEnumerator.DisposeAsync();
@@ -672,6 +676,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.selector2 = selector2;
                this.resultSelector = resultSelector;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -872,6 +877,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public async UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (selectedEnumerator != null)
                {
                    await selectedEnumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipLast.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipLast.cs
@@ -56,6 +56,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.source = source;
                this.count = count;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TSource Current { get; private set; }
@@ -146,6 +147,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntilCanceled.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntilCanceled.cs
@@ -0,0 +1,144 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<TSource> SkipUntilCanceled<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            Error.ThrowArgumentNullException(source, nameof(source));
+
+            return new SkipUntilCanceled<TSource>(source, cancellationToken);
+        }
+    }
+
+    internal sealed class SkipUntilCanceled<TSource> : IUniTaskAsyncEnumerable<TSource>
+    {
+        readonly IUniTaskAsyncEnumerable<TSource> source;
+        readonly CancellationToken cancellationToken;
+
+        public SkipUntilCanceled(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            this.source = source;
+            this.cancellationToken = cancellationToken;
+        }
+
+        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _SkipUntilCanceled(source, this.cancellationToken, cancellationToken);
+        }
+
+        sealed class _SkipUntilCanceled : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
+        {
+            static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;
+
+            readonly IUniTaskAsyncEnumerable<TSource> source;
+            CancellationToken cancellationToken1;
+            CancellationToken cancellationToken2;
+
+            bool isCanceled;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            bool continueNext;
+
+            public _SkipUntilCanceled(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken1, CancellationToken cancellationToken2)
+            {
+                this.source = source;
+                this.cancellationToken1 = cancellationToken1;
+                this.cancellationToken2 = cancellationToken2;
+                TaskTracker.TrackActiveTask(this, 3);
+            }
+
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                if (cancellationToken1.IsCancellationRequested) isCanceled = true;
+                if (cancellationToken2.IsCancellationRequested) isCanceled = true;
+
+                if (enumerator == null)
+                {
+                    enumerator = source.GetAsyncEnumerator(cancellationToken2); // use only AsyncEnumerator provided token.
+                }
+                completionSource.Reset();
+                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 = (_SkipUntilCanceled)state;
+
+                if (self.TryGetResult(self.awaiter, out var result))
+                {
+                    if (result)
+                    {
+                        AGAIN:
+
+                        if (self.isCanceled)
+                        {
+                            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();
+                            }
+                        }
+                    }
+                    else
+                    {
+                        self.completionSource.TrySetResult(false);
+                    }
+                }
+            }
+
+            public UniTask DisposeAsync()
+            {
+                TaskTracker.RemoveTracking(this);
+                if (enumerator != null)
+                {
+                    return enumerator.DisposeAsync();
+                }
+                return default;
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntilCanceled.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntilCanceled.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4b1a778aef7150d47b93a49aa1bc34ae
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Take.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Take.cs
@@ -30,40 +30,95 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _Take(source, count, cancellationToken);
        }

-        sealed class _Take : AsyncEnumeratorBase<TSource, TSource>
+        sealed class _Take : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
-            readonly int count;
+            static readonly Action<object> MoveNextCoreDelegate = MoveNextCore;

+            readonly IUniTaskAsyncEnumerable<TSource> source;
+            readonly int count;
+            CancellationToken cancellationToken;
+
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
            int index;

            public _Take(IUniTaskAsyncEnumerable<TSource> source, int count, CancellationToken cancellationToken)
-                : base(source, cancellationToken)
            {
+                this.source = source;
                this.count = count;
+                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

-            protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                if (sourceHasCurrent)
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (enumerator == null)
                {
-                    if (checked(index++) < count)
+                    enumerator = source.GetAsyncEnumerator(cancellationToken);
+                }
+
+                if (checked(index) >= count)
+                {
+                    return CompletedTasks.False;
+                }
+
+                completionSource.Reset();
+                SourceMoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void SourceMoveNext()
+            {
+                try
+                {
+                    awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                    if (awaiter.IsCompleted)
                    {
-                        Current = SourceCurrent;
-                        result = true;
-                        return true;
+                        MoveNextCore(this);
                    }
                    else
                    {
-                        result = false;
-                        return true;
+                        awaiter.SourceOnCompleted(MoveNextCoreDelegate, this);
                    }
                }
-                else
+                catch (Exception ex)
                {
-                    result = false;
-                    return true;
+                    completionSource.TrySetException(ex);
                }
            }
+
+            static void MoveNextCore(object state)
+            {
+                var self = (_Take)state;
+
+                if (self.TryGetResult(self.awaiter, out var result))
+                {
+                    if (result)
+                    {
+                        self.index++;
+                        self.Current = self.enumerator.Current;
+                        self.completionSource.TrySetResult(true);
+                    }
+                    else
+                    {
+                        self.completionSource.TrySetResult(false);
+                    }
+                }
+            }
+
+            public UniTask DisposeAsync()
+            {
+                TaskTracker.RemoveTracking(this);
+                if (enumerator != null)
+                {
+                    return enumerator.DisposeAsync();
+                }
+                return default;
+            }
        }
    }
 }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeLast.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeLast.cs
@@ -57,6 +57,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.source = source;
                this.count = count;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TSource Current { get; private set; }
@@ -162,6 +163,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (enumerator != null)
                {
                    return enumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntilCanceled.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntilCanceled.cs
@@ -0,0 +1,164 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<TSource> TakeUntilCanceled<TSource>(this IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            Error.ThrowArgumentNullException(source, nameof(source));
+
+            return new TakeUntilCanceled<TSource>(source, cancellationToken);
+        }
+    }
+
+    internal sealed class TakeUntilCanceled<TSource> : IUniTaskAsyncEnumerable<TSource>
+    {
+        readonly IUniTaskAsyncEnumerable<TSource> source;
+        readonly CancellationToken cancellationToken;
+
+        public TakeUntilCanceled(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken)
+        {
+            this.source = source;
+            this.cancellationToken = cancellationToken;
+        }
+
+        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _TakeUntilCanceled(source, this.cancellationToken, cancellationToken);
+        }
+
+        sealed class _TakeUntilCanceled : 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;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+
+            public _TakeUntilCanceled(IUniTaskAsyncEnumerable<TSource> source, CancellationToken cancellationToken1, CancellationToken cancellationToken2)
+            {
+                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);
+            }
+
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                if (cancellationToken1.IsCancellationRequested) isCanceled = true;
+                if (cancellationToken2.IsCancellationRequested) isCanceled = true;
+
+                if (enumerator == null)
+                {
+                    enumerator = source.GetAsyncEnumerator(cancellationToken2); // use only AsyncEnumerator provided token.
+                }
+
+                if (isCanceled) return CompletedTasks.False;
+
+                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 = (_TakeUntilCanceled)state;
+
+                if (self.TryGetResult(self.awaiter, out var result))
+                {
+                    if (result)
+                    {
+                        if (self.isCanceled)
+                        {
+                            self.completionSource.TrySetResult(false);
+                        }
+                        else
+                        {
+                            self.Current = self.enumerator.Current;
+                            self.completionSource.TrySetResult(true);
+                        }
+                    }
+                    else
+                    {
+                        self.completionSource.TrySetResult(false);
+                    }
+                }
+            }
+
+            static void OnCanceled1(object state)
+            {
+                var self = (_TakeUntilCanceled)state;
+                if (!self.isCanceled)
+                {
+                    self.cancellationTokenRegistration2.Dispose();
+                    self.completionSource.TrySetResult(false);
+                }
+            }
+
+            static void OnCanceled2(object state)
+            {
+                var self = (_TakeUntilCanceled)state;
+                if (!self.isCanceled)
+                {
+                    self.cancellationTokenRegistration1.Dispose();
+                    self.completionSource.TrySetResult(false);
+                }
+            }
+
+            public UniTask DisposeAsync()
+            {
+                TaskTracker.RemoveTracking(this);
+                cancellationTokenRegistration1.Dispose();
+                cancellationTokenRegistration2.Dispose();
+                if (enumerator != null)
+                {
+                    return enumerator.DisposeAsync();
+                }
+                return default;
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntilCanceled.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntilCanceled.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e82f498cf3a1df04cbf646773fc11319
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UniTask.Linq.asmdef
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UniTask.Linq.asmdef
@@ -0,0 +1,15 @@
+{
+    "name": "UniTask.Linq",
+    "references": [
+        "UniTask"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UniTask.Linq.asmdef.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UniTask.Linq.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5c01796d064528144a599661eaab93a6
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryUpdate.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryUpdate.cs
@@ -1,7 +1,4 @@
-using Cysharp.Threading.Tasks.Internal;
-using System;
-using System.Collections.Generic;
-using System.Threading;
+using System.Threading;

 namespace Cysharp.Threading.Tasks.Linq
 {
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs
@@ -0,0 +1,241 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<TProperty> EveryValueChanged<TTarget, TProperty>(TTarget target, Func<TTarget, TProperty> propertySelector, PlayerLoopTiming monitorTiming = PlayerLoopTiming.Update, IEqualityComparer<TProperty> equalityComparer = null)
+            where TTarget : class
+        {
+            var unityObject = target as UnityEngine.Object;
+            var isUnityObject = target is UnityEngine.Object; // don't use (unityObject == null)
+
+            if (isUnityObject)
+            {
+                return new EveryValueChangedUnityObject<TTarget, TProperty>(target, propertySelector, equalityComparer ?? UnityEqualityComparer.GetDefault<TProperty>(), monitorTiming);
+            }
+            else
+            {
+                return new EveryValueChangedStandardObject<TTarget, TProperty>(target, propertySelector, equalityComparer ?? UnityEqualityComparer.GetDefault<TProperty>(), monitorTiming);
+            }
+        }
+    }
+
+    internal sealed class EveryValueChangedUnityObject<TTarget, TProperty> : IUniTaskAsyncEnumerable<TProperty>
+    {
+        readonly TTarget target;
+        readonly Func<TTarget, TProperty> propertySelector;
+        readonly IEqualityComparer<TProperty> equalityComparer;
+        readonly PlayerLoopTiming monitorTiming;
+
+        public EveryValueChangedUnityObject(TTarget target, Func<TTarget, TProperty> propertySelector, IEqualityComparer<TProperty> equalityComparer, PlayerLoopTiming monitorTiming)
+        {
+            this.target = target;
+            this.propertySelector = propertySelector;
+            this.equalityComparer = equalityComparer;
+            this.monitorTiming = monitorTiming;
+        }
+
+        public IUniTaskAsyncEnumerator<TProperty> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _EveryValueChanged(target, propertySelector, equalityComparer, monitorTiming, cancellationToken);
+        }
+
+        sealed class _EveryValueChanged : MoveNextSource, IUniTaskAsyncEnumerator<TProperty>, IPlayerLoopItem
+        {
+            readonly TTarget target;
+            readonly UnityEngine.Object targetAsUnityObject;
+            readonly IEqualityComparer<TProperty> equalityComparer;
+            readonly Func<TTarget, TProperty> propertySelector;
+            CancellationToken cancellationToken;
+
+            bool first;
+            TProperty currentValue;
+            bool disposed;
+
+            public _EveryValueChanged(TTarget target, Func<TTarget, TProperty> propertySelector, IEqualityComparer<TProperty> equalityComparer, PlayerLoopTiming monitorTiming, CancellationToken cancellationToken)
+            {
+                this.target = target;
+                this.targetAsUnityObject = target as UnityEngine.Object;
+                this.propertySelector = propertySelector;
+                this.equalityComparer = equalityComparer;
+                this.cancellationToken = cancellationToken;
+                this.first = true;
+                TaskTracker.TrackActiveTask(this, 2);
+                PlayerLoopHelper.AddAction(monitorTiming, this);
+            }
+
+            public TProperty Current => currentValue;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                // return false instead of throw
+                if (disposed || cancellationToken.IsCancellationRequested) return CompletedTasks.False;
+
+                if (first)
+                {
+                    first = false;
+                    if (targetAsUnityObject == null)
+                    {
+                        return CompletedTasks.False;
+                    }
+                    this.currentValue = propertySelector(target);
+                    return CompletedTasks.True;
+                }
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!disposed)
+                {
+                    disposed = true;
+                    TaskTracker.RemoveTracking(this);
+                }
+                return default;
+            }
+
+            public bool MoveNext()
+            {
+                if (disposed || cancellationToken.IsCancellationRequested || targetAsUnityObject == null) // destroyed = cancel.
+                {
+                    completionSource.TrySetResult(false);
+                    DisposeAsync().Forget();
+                    return false;
+                }
+
+                TProperty nextValue = default(TProperty);
+                try
+                {
+                    nextValue = propertySelector(target);
+                    if (equalityComparer.Equals(currentValue, nextValue))
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    completionSource.TrySetException(ex);
+                    DisposeAsync().Forget();
+                    return false;
+                }
+
+                currentValue = nextValue;
+                completionSource.TrySetResult(true);
+                return true;
+            }
+        }
+    }
+
+    internal sealed class EveryValueChangedStandardObject<TTarget, TProperty> : IUniTaskAsyncEnumerable<TProperty>
+        where TTarget : class
+    {
+        readonly WeakReference<TTarget> target;
+        readonly Func<TTarget, TProperty> propertySelector;
+        readonly IEqualityComparer<TProperty> equalityComparer;
+        readonly PlayerLoopTiming monitorTiming;
+
+        public EveryValueChangedStandardObject(TTarget target, Func<TTarget, TProperty> propertySelector, IEqualityComparer<TProperty> equalityComparer, PlayerLoopTiming monitorTiming)
+        {
+            this.target = new WeakReference<TTarget>(target, false);
+            this.propertySelector = propertySelector;
+            this.equalityComparer = equalityComparer;
+            this.monitorTiming = monitorTiming;
+        }
+
+        public IUniTaskAsyncEnumerator<TProperty> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _EveryValueChanged(target, propertySelector, equalityComparer, monitorTiming, cancellationToken);
+        }
+
+        sealed class _EveryValueChanged : MoveNextSource, IUniTaskAsyncEnumerator<TProperty>, IPlayerLoopItem
+        {
+            readonly WeakReference<TTarget> target;
+            readonly IEqualityComparer<TProperty> equalityComparer;
+            readonly Func<TTarget, TProperty> propertySelector;
+            CancellationToken cancellationToken;
+
+            bool first;
+            TProperty currentValue;
+            bool disposed;
+
+            public _EveryValueChanged(WeakReference<TTarget> target, Func<TTarget, TProperty> propertySelector, IEqualityComparer<TProperty> equalityComparer, PlayerLoopTiming monitorTiming, CancellationToken cancellationToken)
+            {
+                this.target = target;
+                this.propertySelector = propertySelector;
+                this.equalityComparer = equalityComparer;
+                this.cancellationToken = cancellationToken;
+                this.first = true;
+                TaskTracker.TrackActiveTask(this, 2);
+                PlayerLoopHelper.AddAction(monitorTiming, this);
+            }
+
+            public TProperty Current => currentValue;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                if (disposed || cancellationToken.IsCancellationRequested) return CompletedTasks.False;
+
+                if (first)
+                {
+                    first = false;
+                    if (!target.TryGetTarget(out var t))
+                    {
+                        return CompletedTasks.False;
+                    }
+                    this.currentValue = propertySelector(t);
+                    return CompletedTasks.True;
+                }
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!disposed)
+                {
+                    disposed = true;
+                    TaskTracker.RemoveTracking(this);
+                }
+                return default;
+            }
+
+            public bool MoveNext()
+            {
+                UnityEngine.Debug.Log("TRY_RESULT:" + target.TryGetTarget(out var _));
+                if (disposed || cancellationToken.IsCancellationRequested || !target.TryGetTarget(out var t))
+                {
+                    completionSource.TrySetResult(false);
+                    DisposeAsync().Forget();
+                    return false;
+                }
+
+                TProperty nextValue = default(TProperty);
+                try
+                {
+                    nextValue = propertySelector(t);
+                    if (equalityComparer.Equals(currentValue, nextValue))
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    completionSource.TrySetException(ex);
+                    DisposeAsync().Forget();
+                    return false;
+                }
+
+                currentValue = nextValue;
+                completionSource.TrySetResult(true);
+                return true;
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1ec39f1c41c305344854782c935ad354
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/Timer.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/Timer.cs
@@ -66,6 +66,7 @@ namespace Cysharp.Threading.Tasks.Linq

            float elapsed;
            bool dueTimePhase;
+            bool completed;
            bool disposed;

            public _Timer(TimeSpan dueTime, TimeSpan? period, PlayerLoopTiming updateTiming, bool ignoreTimeScale, CancellationToken cancellationToken)
@@ -91,7 +92,7 @@ namespace Cysharp.Threading.Tasks.Linq
            public UniTask<bool> MoveNextAsync()
            {
                // return false instead of throw
-                if (disposed || cancellationToken.IsCancellationRequested) return CompletedTasks.False;
+                if (disposed || cancellationToken.IsCancellationRequested || completed) return CompletedTasks.False;

                // reset value here.
                this.elapsed = 0;
@@ -131,6 +132,7 @@ namespace Cysharp.Threading.Tasks.Linq
                {
                    if (period == null)
                    {
+                        completed = true;
                        completionSource.TrySetResult(false);
                        return false;
                    }
@@ -172,6 +174,7 @@ namespace Cysharp.Threading.Tasks.Linq

            int currentFrame;
            bool dueTimePhase;
+            bool completed;
            bool disposed;

            public _TimerFrame(int dueTimeFrameCount, int? periodFrameCount, PlayerLoopTiming updateTiming, CancellationToken cancellationToken)
@@ -195,7 +198,7 @@ namespace Cysharp.Threading.Tasks.Linq
            public UniTask<bool> MoveNextAsync()
            {
                // return false instead of throw
-                if (disposed || cancellationToken.IsCancellationRequested) return CompletedTasks.False;
+                if (disposed || cancellationToken.IsCancellationRequested || completed) return CompletedTasks.False;


                // reset value here.
@@ -235,6 +238,7 @@ namespace Cysharp.Threading.Tasks.Linq
                {
                    if (periodFrameCount == null)
                    {
+                        completed = true;
                        completionSource.TrySetResult(false);
                        return false;
                    }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Where.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Where.cs
@@ -71,36 +71,101 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _Where(source, predicate, cancellationToken);
        }

-        class _Where : AsyncEnumeratorBase<TSource, TSource>
+        sealed class _Where : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, bool> predicate;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            Action moveNextAction;

            public _Where(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, bool> predicate, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
            {
+                this.source = source;
                this.predicate = predicate;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                if (sourceHasCurrent)
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void MoveNext()
+            {
+                REPEAT:
+                try
                {
-                    if (predicate(SourceCurrent))
+                    switch (state)
                    {
-                        Current = SourceCurrent;
-                        result = true;
-                        return true;
-                    }
-                    else
-                    {
-                        result = default;
-                        return false;
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+                                if (predicate(Current))
+                                {
+                                    goto CONTINUE;
+                                }
+                                else
+                                {
+                                    state = 0;
+                                    goto REPEAT;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        default:
+                            goto DONE;
                    }
                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }

-                result = false;
-                return true;
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -118,40 +183,105 @@ namespace Cysharp.Threading.Tasks.Linq

        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
        {
-            return new _WhereInt(source, predicate, cancellationToken);
+            return new _Where(source, predicate, cancellationToken);
        }

-        class _WhereInt : AsyncEnumeratorBase<TSource, TSource>
+        sealed class _Where : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, int, bool> predicate;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            Action moveNextAction;
            int index;

-            public _WhereInt(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
+            public _Where(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, bool> predicate, CancellationToken cancellationToken)
            {
+                this.source = source;
                this.predicate = predicate;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                if (sourceHasCurrent)
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            void MoveNext()
+            {
+                REPEAT:
+                try
                {
-                    if (predicate(SourceCurrent, checked(index++)))
+                    switch (state)
                    {
-                        Current = SourceCurrent;
-                        result = true;
-                        return true;
-                    }
-                    else
-                    {
-                        result = default;
-                        return false;
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+                                if (predicate(Current, checked(index++)))
+                                {
+                                    goto CONTINUE;
+                                }
+                                else
+                                {
+                                    state = 0;
+                                    goto REPEAT;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        default:
+                            goto DONE;
                    }
                }
+                catch (Exception ex)
+                {
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
+                }

-                result = false;
-                return true;
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -172,34 +302,115 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _WhereAwait(source, predicate, cancellationToken);
        }

-        class _WhereAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
+        sealed class _WhereAwait : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, UniTask<bool>> predicate;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<bool>.Awaiter awaiter2;
+            Action moveNextAction;

            public _WhereAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, UniTask<bool>> predicate, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
            {
+                this.source = source;
                this.predicate = predicate;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return predicate(sourceCurrent);
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
+            void MoveNext()
            {
-                terminateIteration = false;
-                if (awaitResult)
+                REPEAT:
+                try
                {
-                    Current = SourceCurrent;
-                    return true;
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+
+                                awaiter2 = predicate(Current).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            if (awaiter2.GetResult())
+                            {
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                state = 0;
+                                goto REPEAT;
+                            }
+                        default:
+                            goto DONE;
+                    }
                }
-                else
+                catch (Exception ex)
                {
-                    return false;
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -217,44 +428,123 @@ namespace Cysharp.Threading.Tasks.Linq

        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
        {
-            return new _WhereIntAwait(source, predicate, cancellationToken);
+            return new _WhereAwait(source, predicate, cancellationToken);
        }

-        class _WhereIntAwait : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
+        sealed class _WhereAwait : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, int, UniTask<bool>> predicate;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<bool>.Awaiter awaiter2;
+            Action moveNextAction;
            int index;

-            public _WhereIntAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
+            public _WhereAwait(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, UniTask<bool>> predicate, CancellationToken cancellationToken)
            {
+                this.source = source;
                this.predicate = predicate;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return predicate(sourceCurrent, checked(index++));
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
+            void MoveNext()
            {
-                terminateIteration = false;
-                if (awaitResult)
+                REPEAT:
+                try
                {
-                    Current = SourceCurrent;
-                    return true;
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+
+                                awaiter2 = predicate(Current, checked(index++)).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            if (awaiter2.GetResult())
+                            {
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                state = 0;
+                                goto REPEAT;
+                            }
+                        default:
+                            goto DONE;
+                    }
                }
-                else
+                catch (Exception ex)
                {
-                    return false;
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }

-
-
    internal sealed class WhereAwaitWithCancellation<TSource> : IUniTaskAsyncEnumerable<TSource>
    {
        readonly IUniTaskAsyncEnumerable<TSource> source;
@@ -271,34 +561,115 @@ namespace Cysharp.Threading.Tasks.Linq
            return new _WhereAwaitWithCancellation(source, predicate, cancellationToken);
        }

-        class _WhereAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
+        sealed class _WhereAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, CancellationToken, UniTask<bool>> predicate;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<bool>.Awaiter awaiter2;
+            Action moveNextAction;

            public _WhereAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
            {
+                this.source = source;
                this.predicate = predicate;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return predicate(sourceCurrent, cancellationToken);
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
+            void MoveNext()
            {
-                terminateIteration = false;
-                if (awaitResult)
+                REPEAT:
+                try
                {
-                    Current = SourceCurrent;
-                    return true;
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+
+                                awaiter2 = predicate(Current, cancellationToken).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            if (awaiter2.GetResult())
+                            {
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                state = 0;
+                                goto REPEAT;
+                            }
+                        default:
+                            goto DONE;
+                    }
                }
-                else
+                catch (Exception ex)
                {
-                    return false;
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
@@ -316,40 +687,120 @@ namespace Cysharp.Threading.Tasks.Linq

        public IUniTaskAsyncEnumerator<TSource> GetAsyncEnumerator(CancellationToken cancellationToken = default)
        {
-            return new _WhereIntAwaitWithCancellation(source, predicate, cancellationToken);
+            return new _WhereAwaitWithCancellation(source, predicate, cancellationToken);
        }

-        class _WhereIntAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase<TSource, TSource, bool>
+        sealed class _WhereAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator<TSource>
        {
+            readonly IUniTaskAsyncEnumerable<TSource> source;
            readonly Func<TSource, int, CancellationToken, UniTask<bool>> predicate;
+            readonly CancellationToken cancellationToken;
+
+            int state = -1;
+            IUniTaskAsyncEnumerator<TSource> enumerator;
+            UniTask<bool>.Awaiter awaiter;
+            UniTask<bool>.Awaiter awaiter2;
+            Action moveNextAction;
            int index;

-            public _WhereIntAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
-
-                : base(source, cancellationToken)
+            public _WhereAwaitWithCancellation(IUniTaskAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, UniTask<bool>> predicate, CancellationToken cancellationToken)
            {
+                this.source = source;
                this.predicate = predicate;
+                this.cancellationToken = cancellationToken;
+                this.moveNextAction = MoveNext;
            }

-            protected override UniTask<bool> TransformAsync(TSource sourceCurrent)
+            public TSource Current { get; private set; }
+
+            public UniTask<bool> MoveNextAsync()
            {
-                return predicate(sourceCurrent, checked(index++), cancellationToken);
+                if (state == -2) return default;
+
+                completionSource.Reset();
+                MoveNext();
+                return new UniTask<bool>(this, completionSource.Version);
            }

-            protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration)
+            void MoveNext()
            {
-                terminateIteration = false;
-                if (awaitResult)
+                REPEAT:
+                try
                {
-                    Current = SourceCurrent;
-                    return true;
+                    switch (state)
+                    {
+                        case -1: // init
+                            enumerator = source.GetAsyncEnumerator(cancellationToken);
+                            goto case 0;
+                        case 0:
+                            awaiter = enumerator.MoveNextAsync().GetAwaiter();
+                            if (awaiter.IsCompleted)
+                            {
+                                goto case 1;
+                            }
+                            else
+                            {
+                                state = 1;
+                                awaiter.UnsafeOnCompleted(moveNextAction);
+                                return;
+                            }
+                        case 1:
+                            if (awaiter.GetResult())
+                            {
+                                Current = enumerator.Current;
+
+                                awaiter2 = predicate(Current, checked(index++), cancellationToken).GetAwaiter();
+                                if (awaiter2.IsCompleted)
+                                {
+                                    goto case 2;
+                                }
+                                else
+                                {
+                                    state = 2;
+                                    awaiter2.UnsafeOnCompleted(moveNextAction);
+                                    return;
+                                }
+                            }
+                            else
+                            {
+                                goto DONE;
+                            }
+                        case 2:
+                            if (awaiter2.GetResult())
+                            {
+                                goto CONTINUE;
+                            }
+                            else
+                            {
+                                state = 0;
+                                goto REPEAT;
+                            }
+                        default:
+                            goto DONE;
+                    }
                }
-                else
+                catch (Exception ex)
                {
-                    return false;
+                    state = -2;
+                    completionSource.TrySetException(ex);
+                    return;
                }
+
+                DONE:
+                state = -2;
+                completionSource.TrySetResult(false);
+                return;
+
+                CONTINUE:
+                state = 0;
+                completionSource.TrySetResult(true);
+                return;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
            }
        }
    }
-
 }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Zip.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Zip.cs
@@ -84,6 +84,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.second = second;
                this.resultSelector = resultSelector;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -181,6 +182,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public async UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (firstEnumerator != null)
                {
                    await firstEnumerator.DisposeAsync();
@@ -236,6 +238,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.second = second;
                this.resultSelector = resultSelector;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -351,6 +354,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public async UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (firstEnumerator != null)
                {
                    await firstEnumerator.DisposeAsync();
@@ -406,6 +410,7 @@ namespace Cysharp.Threading.Tasks.Linq
                this.second = second;
                this.resultSelector = resultSelector;
                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 3);
            }

            public TResult Current { get; private set; }
@@ -521,6 +526,7 @@ namespace Cysharp.Threading.Tasks.Linq

            public async UniTask DisposeAsync()
            {
+                TaskTracker.RemoveTracking(this);
                if (firstEnumerator != null)
                {
                    await firstEnumerator.DisposeAsync();
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/MoveNextSource.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/MoveNextSource.cs
@@ -0,0 +1,63 @@
+using System;
+
+namespace Cysharp.Threading.Tasks
+{
+    public abstract class MoveNextSource : IUniTaskSource<bool>
+    {
+        protected UniTaskCompletionSourceCore<bool> completionSource;
+
+        public bool GetResult(short token)
+        {
+            return completionSource.GetResult(token);
+        }
+
+        public UniTaskStatus GetStatus(short token)
+        {
+            return completionSource.GetStatus(token);
+        }
+
+        public void OnCompleted(Action<object> continuation, object state, short token)
+        {
+            completionSource.OnCompleted(continuation, state, token);
+        }
+
+        public UniTaskStatus UnsafeGetStatus()
+        {
+            return completionSource.UnsafeGetStatus();
+        }
+
+        void IUniTaskSource.GetResult(short token)
+        {
+            completionSource.GetResult(token);
+        }
+
+        protected bool TryGetResult<T>(UniTask<T>.Awaiter awaiter, out T result)
+        {
+            try
+            {
+                result = awaiter.GetResult();
+                return true;
+            }
+            catch (Exception ex)
+            {
+                completionSource.TrySetException(ex);
+                result = default;
+                return false;
+            }
+        }
+
+        protected bool TryGetResult(UniTask.Awaiter awaiter)
+        {
+            try
+            {
+                awaiter.GetResult();
+                return true;
+            }
+            catch (Exception ex)
+            {
+                completionSource.TrySetException(ex);
+                return false;
+            }
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/MoveNextSource.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/MoveNextSource.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dc4c5dc2a5f246e4f8df44cab735826c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs
@@ -200,27 +200,43 @@ namespace Cysharp.Threading.Tasks


 #if UNITY_EDITOR
+
        [InitializeOnLoadMethod]
        static void InitOnEditor()
        {
-            //Execute the play mode init method
+            // Execute the play mode init method
            Init();

-            //register an Editor update delegate, used to forcing playerLoop update
+            // register an Editor update delegate, used to forcing playerLoop update
            EditorApplication.update += ForceEditorPlayerLoopUpdate;
        }

        private static void ForceEditorPlayerLoopUpdate()
        {
-            if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling ||
-                EditorApplication.isUpdating)
+            if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating)
            {
                // Not in Edit mode, don't interfere
                return;
            }

-            //force unity to update PlayerLoop callbacks
-            EditorApplication.QueuePlayerLoopUpdate();
+            // EditorApplication.QueuePlayerLoopUpdate causes performance issue, don't call directly.
+            // EditorApplication.QueuePlayerLoopUpdate();
+
+            if (yielders != null)
+            {
+                foreach (var item in yielders)
+                {
+                    if (item != null) item.Run();
+                }
+            }
+
+            if (runners != null)
+            {
+                foreach (var item in runners)
+                {
+                    if (item != null) item.Run();
+                }
+            }
        }

 #endif
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Progress.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Progress.cs
@@ -1,7 +1,4 @@
-#if NET_4_6 || NET_STANDARD_2_0 || CSHARP_7_OR_LATER
-#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
-
-using System;
+using System;
 using System.Collections.Generic;
 using Cysharp.Threading.Tasks.Internal;

@@ -21,7 +18,11 @@ namespace Cysharp.Threading.Tasks
        public static IProgress<T> CreateOnlyValueChanged<T>(Action<T> handler, IEqualityComparer<T> comparer = null)
        {
            if (handler == null) return NullProgress<T>.Instance;
+#if UNITY_2018_3_OR_NEWER
            return new OnlyValueChangedProgress<T>(handler, comparer ?? UnityEqualityComparer.GetDefault<T>());
+#else
+            return new OnlyValueChangedProgress<T>(handler, comparer ?? EqualityComparer<T>.Default);
+#endif
        }

        sealed class NullProgress<T> : IProgress<T>
@@ -83,6 +84,4 @@ namespace Cysharp.Threading.Tasks
            }
        }
    }
-}
-
-#endif
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    // internaly used but public, allow to user create custom operator with pooling.
+
+    public static class TaskPool
+    {
+        internal static int MaxPoolSize;
+        static ConcurrentDictionary<Type, Func<int>> sizes = new ConcurrentDictionary<Type, Func<int>>();
+
+        static TaskPool()
+        {
+            try
+            {
+                var value = Environment.GetEnvironmentVariable("UNITASK_MAX_POOLSIZE");
+                if (value != null)
+                {
+                    if (int.TryParse(value, out var size))
+                    {
+                        MaxPoolSize = size;
+                        return;
+                    }
+                }
+            }
+            catch { }
+
+            MaxPoolSize = int.MaxValue;
+        }
+
+        public static void SetMaxPoolSize(int maxPoolSize)
+        {
+            MaxPoolSize = maxPoolSize;
+        }
+
+        public static IEnumerable<(Type, int)> GetCacheSizeInfo()
+        {
+            foreach (var item in sizes)
+            {
+                yield return (item.Key, item.Value());
+            }
+        }
+
+        public static void RegisterSizeGetter(Type type, Func<int> getSize)
+        {
+            sizes[type] = getSize;
+        }
+    }
+
+
+    public interface ITaskPoolNode<T>
+    {
+        T NextNode { get; set; }
+    }
+
+    // mutable struct, don't mark readonly.
+    [StructLayout(LayoutKind.Auto)]
+    public struct TaskPool<T>
+        where T : class, ITaskPoolNode<T>
+    {
+        int gate;
+        int size;
+        T root;
+
+        public int Size => size;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryPop(out T result)
+        {
+            if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+            {
+                var v = root;
+                if (!(v is null))
+                {
+                    root = v.NextNode;
+                    v.NextNode = null;
+                    size--;
+                    result = v;
+                    Volatile.Write(ref gate, 0);
+                    return true;
+                }
+
+                Volatile.Write(ref gate, 0);
+            }
+            result = default;
+            return false;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryPush(T item)
+        {
+            if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+            {
+                if (size < TaskPool.MaxPoolSize)
+                {
+                    item.NextNode = root;
+                    root = item;
+                    size++;
+                    Volatile.Write(ref gate, 0);
+                    return true;
+                }
+                else
+                {
+                    Volatile.Write(ref gate, 0);
+                }
+            }
+            return false;
+        }
+    }
+}
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs.meta
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 19f4e6575150765449cc99f25f06f25f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/TriggerEvent.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/TriggerEvent.cs
@@ -1,228 +1,310 @@
-using Cysharp.Threading.Tasks.Internal;
-using System;
+using System;
 using System.Threading;

 namespace Cysharp.Threading.Tasks
 {
-    public interface ITriggerEvent<T>
+    public interface ITriggerHandler<T>
    {
-        void SetResult(T value);
-        void SetCanceled(CancellationToken cancellationToken);
-        void Add(IResolveCancelPromise<T> handler);
-        void Remove(IResolveCancelPromise<T> handler);
+        void OnNext(T value);
+        void OnError(Exception ex);
+        void OnCompleted();
+        void OnCanceled(CancellationToken cancellationToken);
+
+        // set/get from TriggerEvent<T>
+        ITriggerHandler<T> Prev { get; set; }
+        ITriggerHandler<T> Next { get; set; }
    }

    // be careful to use, itself is struct.
-    public struct TriggerEvent<T> : ITriggerEvent<T>
+    public struct TriggerEvent<T>
    {
-        // optimize: many cases, handler is single.
-        IResolveCancelPromise<T> singleHandler;
+        ITriggerHandler<T> head; // head.prev is last
+        ITriggerHandler<T> iteratingHead;

-        IResolveCancelPromise<T>[] handlers;
+        bool preserveRemoveSelf;
+        ITriggerHandler<T> iteratingNode;

-        // when running(in TrySetResult), does not add immediately.
-        bool isRunning;
-        IResolveCancelPromise<T> waitHandler;
-        MinimumQueue<IResolveCancelPromise<T>> waitQueue;
+        void LogError(Exception ex)
+        {
+#if UNITY_2018_3_OR_NEWER
+            UnityEngine.Debug.LogException(ex);
+#else
+            Console.WriteLine(ex);
+#endif
+        }

        public void SetResult(T value)
        {
-            isRunning = true;
-
-            if (singleHandler != null)
+            if (iteratingNode != null)
            {
+                throw new InvalidOperationException("Can not trigger itself in iterating.");
+            }
+
+            var h = head;
+            while (h != null)
+            {
+                iteratingNode = h;
+
                try
                {
-                    singleHandler.TrySetResult(value);
+                    h.OnNext(value);
                }
                catch (Exception ex)
                {
-#if UNITY_2018_3_OR_NEWER
-                    UnityEngine.Debug.LogException(ex);
-#else
-                    Console.WriteLine(ex);
-#endif
+                    LogError(ex);
+                    Remove(h);
                }
-            }

-            if (handlers != null)
-            {
-                for (int i = 0; i < handlers.Length; i++)
+                if (preserveRemoveSelf)
                {
-                    if (handlers[i] != null)
-                    {
-                        try
-                        {
-                            handlers[i].TrySetResult(value);
-                        }
-                        catch (Exception ex)
-                        {
-                            handlers[i] = null;
-#if UNITY_2018_3_OR_NEWER
-                            UnityEngine.Debug.LogException(ex);
-#else
-                            Console.WriteLine(ex);
-#endif
-                        }
-                    }
+                    preserveRemoveSelf = false;
+                    iteratingNode = null;
+                    var next = h.Next;
+                    Remove(h);
+                    h = next;
                }
-            }
-
-            isRunning = false;
-
-            if (waitHandler != null)
-            {
-                var h = waitHandler;
-                waitHandler = null;
-                Add(h);
-            }
-
-            if (waitQueue != null)
-            {
-                while (waitQueue.Count != 0)
+                else
                {
-                    Add(waitQueue.Dequeue());
+                    h = h.Next;
                }
            }
+
+            iteratingNode = null;
+            if (iteratingHead != null)
+            {
+                Add(iteratingHead);
+                iteratingHead = null;
+            }
        }

        public void SetCanceled(CancellationToken cancellationToken)
        {
-            isRunning = true;
-
-            if (singleHandler != null)
+            if (iteratingNode != null)
            {
+                throw new InvalidOperationException("Can not trigger itself in iterating.");
+            }
+
+            var h = head;
+            while (h != null)
+            {
+                iteratingNode = h;
                try
                {
-                    ((ICancelPromise)singleHandler).TrySetCanceled(cancellationToken);
+                    h.OnCanceled(cancellationToken);
                }
                catch (Exception ex)
                {
-#if UNITY_2018_3_OR_NEWER
-                    UnityEngine.Debug.LogException(ex);
-#else
-                    Console.WriteLine(ex);
-#endif
+                    LogError(ex);
                }
+
+                preserveRemoveSelf = false;
+                iteratingNode = null;
+                var next = h.Next;
+                Remove(h);
+                h = next;
            }

-            if (handlers != null)
+            iteratingNode = null;
+            if (iteratingHead != null)
            {
-                for (int i = 0; i < handlers.Length; i++)
-                {
-                    if (handlers[i] != null)
-                    {
-                        try
-                        {
-                            ((ICancelPromise)handlers[i]).TrySetCanceled(cancellationToken);
-                        }
-                        catch (Exception ex)
-                        {
-#if UNITY_2018_3_OR_NEWER
-                            UnityEngine.Debug.LogException(ex);
-#else
-                            Console.WriteLine(ex);
-#endif
-                            handlers[i] = null;
-                        }
-                    }
-                }
-            }
-
-            isRunning = false;
-
-            if (waitHandler != null)
-            {
-                var h = waitHandler;
-                waitHandler = null;
-                Add(h);
-            }
-
-            if (waitQueue != null)
-            {
-                while (waitQueue.Count != 0)
-                {
-                    Add(waitQueue.Dequeue());
-                }
+                Add(iteratingHead);
+                iteratingHead = null;
            }
        }

-        public void Add(IResolveCancelPromise<T> handler)
+        public void SetCompleted()
        {
-            if (isRunning)
+            if (iteratingNode != null)
            {
-                if (waitHandler == null)
+                throw new InvalidOperationException("Can not trigger itself in iterating.");
+            }
+
+            var h = head;
+            while (h != null)
+            {
+                iteratingNode = h;
+                try
                {
-                    waitHandler = handler;
-                    return;
+                    h.OnCompleted();
+                }
+                catch (Exception ex)
+                {
+                    LogError(ex);
                }

-                if (waitQueue == null)
+                preserveRemoveSelf = false;
+                iteratingNode = null;
+                var next = h.Next;
+                Remove(h);
+                h = next;
+            }
+
+            iteratingNode = null;
+            if (iteratingHead != null)
+            {
+                Add(iteratingHead);
+                iteratingHead = null;
+            }
+        }
+
+        public void SetError(Exception exception)
+        {
+            if (iteratingNode != null)
+            {
+                throw new InvalidOperationException("Can not trigger itself in iterating.");
+            }
+
+            var h = head;
+            while (h != null)
+            {
+                iteratingNode = h;
+                try
                {
-                    waitQueue = new MinimumQueue<IResolveCancelPromise<T>>(4);
+                    h.OnError(exception);
                }
-                waitQueue.Enqueue(handler);
+                catch (Exception ex)
+                {
+                    LogError(ex);
+                }
+
+                preserveRemoveSelf = false;
+                iteratingNode = null;
+                var next = h.Next;
+                Remove(h);
+                h = next;
+            }
+
+            iteratingNode = null;
+            if (iteratingHead != null)
+            {
+                Add(iteratingHead);
+                iteratingHead = null;
+            }
+        }
+
+        public void Add(ITriggerHandler<T> handler)
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            // zero node.
+            if (head == null)
+            {
+                head = handler;
                return;
            }

-            if (singleHandler == null)
+            if (iteratingNode != null)
            {
-                singleHandler = handler;
+                if (iteratingHead == null)
+                {
+                    iteratingHead = handler;
+                    return;
+                }
+
+                var last = iteratingHead.Prev;
+                if (last == null)
+                {
+                    // single node.
+                    iteratingHead.Prev = handler;
+                    iteratingHead.Next = handler;
+                    handler.Prev = iteratingHead;
+                }
+                else
+                {
+                    // multi node
+                    iteratingHead.Prev = handler;
+                    last.Next = handler;
+                    handler.Prev = last;
+                }
            }
            else
            {
-                if (handlers == null)
+                var last = head.Prev;
+                if (last == null)
                {
-                    handlers = new IResolveCancelPromise<T>[4];
+                    // single node.
+                    head.Prev = handler;
+                    head.Next = handler;
+                    handler.Prev = head;
+                }
+                else
+                {
+                    // multi node
+                    head.Prev = handler;
+                    last.Next = handler;
+                    handler.Prev = last;
+                }
+            }
+        }
+
+        public void Remove(ITriggerHandler<T> handler)
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            if (iteratingNode != null && iteratingNode == handler)
+            {
+                // if remove self, reserve remove self after invoke completed.
+                preserveRemoveSelf = true;
+            }
+            else
+            {
+                var prev = handler.Prev;
+                var next = handler.Next;
+
+                if (next != null)
+                {
+                    next.Prev = prev;
                }

-                // check empty
-                for (int i = 0; i < handlers.Length; i++)
+                if (handler == head)
                {
-                    if (handlers[i] == null)
+                    head = next;
+                }
+                else if (handler == iteratingHead)
+                {
+                    iteratingHead = next;
+                }
+                else
+                {
+                    // when handler is head, prev indicate last so don't use it.
+                    if (prev != null)
                    {
-                        handlers[i] = handler;
-                        return;
+                        prev.Next = next;
                    }
                }

-                // full, ensure capacity
-                var last = handlers.Length;
+                if (head != null)
                {
-                    EnsureCapacity(ref handlers);
-                    handlers[last] = handler;
-                }
-            }
-        }
-
-        static void EnsureCapacity(ref IResolveCancelPromise<T>[] array)
-        {
-            var newSize = array.Length * 2;
-            var newArray = new IResolveCancelPromise<T>[newSize];
-            Array.Copy(array, 0, newArray, 0, array.Length);
-            array = newArray;
-        }
-
-        public void Remove(IResolveCancelPromise<T> handler)
-        {
-            if (singleHandler == handler)
-            {
-                singleHandler = null;
-            }
-            else
-            {
-                if (handlers != null)
-                {
-                    for (int i = 0; i < handlers.Length; i++)
+                    if (head.Prev == handler)
                    {
-                        if (handlers[i] == handler)
+                        if (prev != head)
                        {
-                            // fill null.
-                            handlers[i] = null;
-                            return;
+                            head.Prev = prev;
+                        }
+                        else
+                        {
+                            head.Prev = null;
                        }
                    }
                }
+
+                if (iteratingHead != null)
+                {
+                    if (iteratingHead.Prev == handler)
+                    {
+                        if (prev != iteratingHead.Prev)
+                        {
+                            iteratingHead.Prev = prev;
+                        }
+                        else
+                        {
+                            iteratingHead.Prev = null;
+                        }
+                    }
+                }
+
+                handler.Prev = null;
+                handler.Next = null;
            }
        }
    }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncTriggerBase.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncTriggerBase.cs
@@ -1,6 +1,5 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

-using Cysharp.Threading.Tasks.Linq;
 using System;
 using System.Threading;
 using UnityEngine;
@@ -24,10 +23,10 @@ namespace Cysharp.Threading.Tasks.Triggers
            if (calledDestroy) return;
            calledDestroy = true;

-            triggerEvent.SetCanceled(CancellationToken.None);
+            triggerEvent.SetCompleted();
        }

-        internal void AddHandler(IResolveCancelPromise<T> handler)
+        internal void AddHandler(ITriggerHandler<T> handler)
        {
            if (!calledAwake)
            {
@@ -37,7 +36,7 @@ namespace Cysharp.Threading.Tasks.Triggers
            triggerEvent.Add(handler);
        }

-        internal void RemoveHandler(IResolveCancelPromise<T> handler)
+        internal void RemoveHandler(ITriggerHandler<T> handler)
        {
            if (!calledAwake)
            {
@@ -57,7 +56,7 @@ namespace Cysharp.Threading.Tasks.Triggers
            return new AsyncTriggerEnumerator(this, cancellationToken);
        }

-        sealed class AsyncTriggerEnumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, IResolveCancelPromise<T>
+        sealed class AsyncTriggerEnumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, ITriggerHandler<T>
        {
            static Action<object> cancellationCallback = CancellationCallback;

@@ -73,15 +72,25 @@ namespace Cysharp.Threading.Tasks.Triggers
                this.cancellationToken = cancellationToken;
            }

-            public bool TrySetCanceled(CancellationToken cancellationToken = default)
+            public void OnCanceled(CancellationToken cancellationToken = default)
            {
-                return completionSource.TrySetCanceled(cancellationToken);
+                completionSource.TrySetCanceled(cancellationToken);
            }

-            public bool TrySetResult(T value)
+            public void OnNext(T value)
            {
                Current = value;
-                return completionSource.TrySetResult(true);
+                completionSource.TrySetResult(true);
+            }
+
+            public void OnCompleted()
+            {
+                completionSource.TrySetResult(false);
+            }
+
+            public void OnError(Exception ex)
+            {
+                completionSource.TrySetException(ex);
            }

            static void CancellationCallback(object state)
@@ -93,6 +102,8 @@ namespace Cysharp.Threading.Tasks.Triggers
            }

            public T Current { get; private set; }
+            ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }
+            ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }

            public UniTask<bool> MoveNextAsync()
            {
@@ -164,7 +175,7 @@ namespace Cysharp.Threading.Tasks.Triggers
        }
    }

-    public sealed partial class AsyncTriggerHandler<T> : IUniTaskSource<T>, IResolveCancelPromise<T>, IDisposable
+    public sealed partial class AsyncTriggerHandler<T> : IUniTaskSource<T>, ITriggerHandler<T>, IDisposable
    {
        static Action<object> cancellationCallback = CancellationCallback;

@@ -179,6 +190,9 @@ namespace Cysharp.Threading.Tasks.Triggers

        internal CancellationToken CancellationToken => cancellationToken;

+        ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }
+        ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }
+
        internal AsyncTriggerHandler(AsyncTriggerBase<T> trigger, bool callOnce)
        {
            if (cancellationToken.IsCancellationRequested)
@@ -253,14 +267,24 @@ namespace Cysharp.Threading.Tasks.Triggers
            }
        }

-        bool IResolvePromise<T>.TrySetResult(T result)
+        void ITriggerHandler<T>.OnNext(T value)
        {
-            return core.TrySetResult(result);
+            core.TrySetResult(value);
        }

-        bool ICancelPromise.TrySetCanceled(CancellationToken cancellationToken)
+        void ITriggerHandler<T>.OnCanceled(CancellationToken cancellationToken)
        {
-            return core.TrySetCanceled(cancellationToken);
+            core.TrySetCanceled(cancellationToken);
+        }
+
+        void ITriggerHandler<T>.OnCompleted()
+        {
+            core.TrySetCanceled(CancellationToken.None);
+        }
+
+        void ITriggerHandler<T>.OnError(Exception ex)
+        {
+            core.TrySetException(ex);
        }

        void IUniTaskSource.GetResult(short token)
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs
@@ -56,9 +56,15 @@ namespace Cysharp.Threading.Tasks
                : new UniTask(DelayPromise.Create(delayTimeSpan, delayTiming, cancellationToken, out token), token);
        }

-        sealed class YieldPromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        sealed class YieldPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<YieldPromise>
        {
-            static readonly PromisePool<YieldPromise> pool = new PromisePool<YieldPromise>();
+            static TaskPool<YieldPromise> pool;
+            public YieldPromise NextNode { get; set; }
+
+            static YieldPromise()
+            {
+                TaskPool.RegisterSizeGetter(typeof(YieldPromise), () => pool.Size);
+            }

            CancellationToken cancellationToken;
            UniTaskCompletionSourceCore<object> core;
@@ -74,7 +80,11 @@ namespace Cysharp.Threading.Tasks
                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
                }

-                var result = pool.TryRent() ?? new YieldPromise();
+                if (!pool.TryPop(out var result))
+                {
+                    result = new YieldPromise();
+                }
+

                result.cancellationToken = cancellationToken;

@@ -90,12 +100,11 @@ namespace Cysharp.Threading.Tasks
            {
                try
                {
-                    TaskTracker.RemoveTracking(this);
                    core.GetResult(token);
                }
                finally
                {
-                    pool.TryReturn(this);
+                    TryReturn();
                }
            }

@@ -126,24 +135,32 @@ namespace Cysharp.Threading.Tasks
                return false;
            }

-            public void Reset()
+            bool TryReturn()
            {
+                TaskTracker.RemoveTracking(this);
                core.Reset();
                cancellationToken = default;
+                return pool.TryPush(this);
            }

            ~YieldPromise()
            {
-                if (pool.TryReturn(this))
+                if (TryReturn())
                {
                    GC.ReRegisterForFinalize(this);
                }
            }
        }

-        sealed class DelayFramePromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        sealed class DelayFramePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<DelayFramePromise>
        {
-            static readonly PromisePool<DelayFramePromise> pool = new PromisePool<DelayFramePromise>();
+            static TaskPool<DelayFramePromise> pool;
+            public DelayFramePromise NextNode { get; set; }
+
+            static DelayFramePromise()
+            {
+                TaskPool.RegisterSizeGetter(typeof(DelayFramePromise), () => pool.Size);
+            }

            int delayFrameCount;
            CancellationToken cancellationToken;
@@ -162,7 +179,10 @@ namespace Cysharp.Threading.Tasks
                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
                }

-                var result = pool.TryRent() ?? new DelayFramePromise();
+                if (!pool.TryPop(out var result))
+                {
+                    result = new DelayFramePromise();
+                }

                result.delayFrameCount = delayFrameCount;
                result.cancellationToken = cancellationToken;
@@ -179,12 +199,11 @@ namespace Cysharp.Threading.Tasks
            {
                try
                {
-                    TaskTracker.RemoveTracking(this);
                    core.GetResult(token);
                }
                finally
                {
-                    pool.TryReturn(this);
+                    TryReturn();
                }
            }

@@ -221,26 +240,34 @@ namespace Cysharp.Threading.Tasks
                return true;
            }

-            public void Reset()
+            bool TryReturn()
            {
+                TaskTracker.RemoveTracking(this);
                core.Reset();
                currentFrameCount = default;
                delayFrameCount = default;
                cancellationToken = default;
+                return pool.TryPush(this);
            }

            ~DelayFramePromise()
            {
-                if (pool.TryReturn(this))
+                if (TryReturn())
                {
                    GC.ReRegisterForFinalize(this);
                }
            }
        }

-        sealed class DelayPromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        sealed class DelayPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<DelayPromise>
        {
-            static readonly PromisePool<DelayPromise> pool = new PromisePool<DelayPromise>();
+            static TaskPool<DelayPromise> pool;
+            public DelayPromise NextNode { get; set; }
+
+            static DelayPromise()
+            {
+                TaskPool.RegisterSizeGetter(typeof(DelayPromise), () => pool.Size);
+            }

            float delayFrameTimeSpan;
            float elapsed;
@@ -259,7 +286,10 @@ namespace Cysharp.Threading.Tasks
                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
                }

-                var result = pool.TryRent() ?? new DelayPromise();
+                if (!pool.TryPop(out var result))
+                {
+                    result = new DelayPromise();
+                }

                result.elapsed = 0.0f;
                result.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
@@ -277,12 +307,11 @@ namespace Cysharp.Threading.Tasks
            {
                try
                {
-                    TaskTracker.RemoveTracking(this);
                    core.GetResult(token);
                }
                finally
                {
-                    pool.TryReturn(this);
+                    TryReturn();
                }
            }

@@ -319,26 +348,34 @@ namespace Cysharp.Threading.Tasks
                return true;
            }

-            public void Reset()
+            bool TryReturn()
            {
+                TaskTracker.RemoveTracking(this);
                core.Reset();
                delayFrameTimeSpan = default;
                elapsed = default;
                cancellationToken = default;
+                return pool.TryPush(this);
            }

            ~DelayPromise()
            {
-                if (pool.TryReturn(this))
+                if (TryReturn())
                {
                    GC.ReRegisterForFinalize(this);
                }
            }
        }

-        sealed class DelayIgnoreTimeScalePromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        sealed class DelayIgnoreTimeScalePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<DelayIgnoreTimeScalePromise>
        {
-            static readonly PromisePool<DelayIgnoreTimeScalePromise> pool = new PromisePool<DelayIgnoreTimeScalePromise>();
+            static TaskPool<DelayIgnoreTimeScalePromise> pool;
+            public DelayIgnoreTimeScalePromise NextNode { get; set; }
+
+            static DelayIgnoreTimeScalePromise()
+            {
+                TaskPool.RegisterSizeGetter(typeof(DelayIgnoreTimeScalePromise), () => pool.Size);
+            }

            float delayFrameTimeSpan;
            float elapsed;
@@ -357,7 +394,10 @@ namespace Cysharp.Threading.Tasks
                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
                }

-                var result = pool.TryRent() ?? new DelayIgnoreTimeScalePromise();
+                if (!pool.TryPop(out var result))
+                {
+                    result = new DelayIgnoreTimeScalePromise();
+                }

                result.elapsed = 0.0f;
                result.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
@@ -375,12 +415,11 @@ namespace Cysharp.Threading.Tasks
            {
                try
                {
-                    TaskTracker.RemoveTracking(this);
                    core.GetResult(token);
                }
                finally
                {
-                    pool.TryReturn(this);
+                    TryReturn();
                }
            }

@@ -417,17 +456,19 @@ namespace Cysharp.Threading.Tasks
                return true;
            }

-            public void Reset()
+            bool TryReturn()
            {
+                TaskTracker.RemoveTracking(this);
                core.Reset();
                delayFrameTimeSpan = default;
                elapsed = default;
                cancellationToken = default;
+                return pool.TryPush(this);
            }

            ~DelayIgnoreTimeScalePromise()
            {
-                if (pool.TryReturn(this))
+                if (TryReturn())
                {
                    GC.ReRegisterForFinalize(this);
                }
--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Factory.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Factory.cs
@@ -1,6 +1,8 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

+using Cysharp.Threading.Tasks.Internal;
 using System;
+using System.Runtime.CompilerServices;
 using System.Threading;

 namespace Cysharp.Threading.Tasks
@@ -102,35 +104,161 @@ namespace Cysharp.Threading.Tasks
        }

        /// <summary>
-        /// helper of create add UniTaskVoid to delegate.
-        /// For example: FooEvent += () => UniTask.Void(async () => { /* */ })
+        /// helper of fire and forget void action.
        /// </summary>
-        public static void Void(Func<UniTask> asyncAction)
+        public static void Void(Func<UniTaskVoid> asyncAction)
        {
            asyncAction().Forget();
        }

-        public static Action VoidAction(Func<UniTask> asyncAction)
+        /// <summary>
+        /// helper of fire and forget void action.
+        /// </summary>
+        public static void Void(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
        {
-            return () => Void(asyncAction);
+            asyncAction(cancellationToken).Forget();
+        }
+
+        /// <summary>
+        /// helper of fire and forget void action.
+        /// </summary>
+        public static void Void<T>(Func<T, UniTaskVoid> asyncAction, T state)
+        {
+            asyncAction(state).Forget();
+        }
+
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// For example: FooAction = UniTask.Action(async () => { /* */ })
+        /// </summary>
+        public static Action Action(Func<UniTaskVoid> asyncAction)
+        {
+            return () => asyncAction().Forget();
+        }
+
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// </summary>
+        public static Action Action(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
+        {
+            return () => asyncAction(cancellationToken).Forget();
        }

 #if UNITY_2018_3_OR_NEWER

-        public static UnityEngine.Events.UnityAction VoidUnityAction(Func<UniTask> asyncAction)
+        /// <summary>
+        /// Create async void(UniTaskVoid) UnityAction.
+        /// For exampe: onClick.AddListener(UniTask.UnityAction(async () => { /* */ } ))
+        /// </summary>
+        public static UnityEngine.Events.UnityAction UnityAction(Func<UniTaskVoid> asyncAction)
        {
-            return () => Void(asyncAction);
+            return () => asyncAction().Forget();
+        }
+
+        /// <summary>
+        /// Create async void(UniTaskVoid) UnityAction.
+        /// For exampe: onClick.AddListener(UniTask.UnityAction(FooAsync, this.GetCancellationTokenOnDestroy()))
+        /// </summary>
+        public static UnityEngine.Events.UnityAction UnityAction(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
+        {
+            return () => asyncAction(cancellationToken).Forget();
        }

 #endif

        /// <summary>
-        /// helper of create add UniTaskVoid to delegate.
-        /// For example: FooEvent += (sender, e) => UniTask.Void(async arg => { /* */ }, (sender, e))
+        /// Defer the task creation just before call await.
        /// </summary>
-        public static void Void<T>(Func<T, UniTask> asyncAction, T state)
+        public static UniTask Defer(Func<UniTask> factory)
        {
-            asyncAction(state).Forget();
+            return new UniTask(new DeferPromise(factory), 0);
+        }
+
+        /// <summary>
+        /// Defer the task creation just before call await.
+        /// </summary>
+        public static UniTask<T> Defer<T>(Func<UniTask<T>> factory)
+        {
+            return new UniTask<T>(new DeferPromise<T>(factory), 0);
+        }
+
+        sealed class DeferPromise : IUniTaskSource
+        {
+            Func<UniTask> factory;
+            UniTask task;
+            UniTask.Awaiter awaiter;
+
+            public DeferPromise(Func<UniTask> factory)
+            {
+                this.factory = factory;
+            }
+
+            public void GetResult(short token)
+            {
+                awaiter.GetResult();
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                var f = Interlocked.Exchange(ref factory, null);
+                if (f == null) throw new InvalidOperationException("Can't call twice.");
+
+                task = f();
+                awaiter = f().GetAwaiter();
+                return task.Status;
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                awaiter.SourceOnCompleted(continuation, state);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return task.Status;
+            }
+        }
+
+        sealed class DeferPromise<T> : IUniTaskSource<T>
+        {
+            Func<UniTask<T>> factory;
+            UniTask<T> task;
+            UniTask<T>.Awaiter awaiter;
+
+            public DeferPromise(Func<UniTask<T>> factory)
+            {
+                this.factory = factory;
+            }
+
+            public T GetResult(short token)
+            {
+                return awaiter.GetResult();
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                awaiter.GetResult();
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                var f = Interlocked.Exchange(ref factory, null);
+                if (f == null) throw new InvalidOperationException("Can't call twice.");
+
+                task = f();
+                awaiter = f().GetAwaiter();
+                return task.Status;
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                awaiter.SourceOnCompleted(continuation, state);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return task.Status;
+            }
        }
    }

--- a/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Threading.cs
+++ b/src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Threading.cs
@@ -17,7 +17,31 @@ namespace Cysharp.Threading.Tasks
        /// </summary>
        public static SwitchToMainThreadAwaitable SwitchToMainThread()
        {
-            return new SwitchToMainThreadAwaitable();
+            return new SwitchToMainThreadAwaitable(PlayerLoopTiming.Update);
+        }
+
+        /// <summary>
+        /// If running on mainthread, do nothing. Otherwise, same as UniTask.Yield(timing).
+        /// </summary>
+        public static SwitchToMainThreadAwaitable SwitchToMainThread(PlayerLoopTiming timing)
+        {
+            return new SwitchToMainThreadAwaitable(timing);
+        }
+
+        /// <summary>
+        /// Return to mainthread(same as await SwitchToMainThread) after using scope is closed.
+        /// </summary>
+        public static ReturnToMainThread ReturnToMainThread()
+        {
+            return new ReturnToMainThread(PlayerLoopTiming.Update);
+        }
+
+        /// <summary>
+        /// Return to mainthread(same as await SwitchToMainThread) after using scope is closed.
+        /// </summary>
+        public static ReturnToMainThread ReturnToMainThread(PlayerLoopTiming timing)
+        {
+            return new ReturnToMainThread(timing);
        }

 #endif
@@ -27,15 +51,28 @@ namespace Cysharp.Threading.Tasks
            return new SwitchToThreadPoolAwaitable();
        }

+        /// <summary>
+        /// Note: use SwitchToThreadPool is recommended.
+        /// </summary>
        public static SwitchToTaskPoolAwaitable SwitchToTaskPool()
        {
            return new SwitchToTaskPoolAwaitable();
        }

-        public static SwitchToSynchronizationContextAwaitable SwitchToSynchronizationContext(SynchronizationContext syncContext)
+        public static SwitchToSynchronizationContextAwaitable SwitchToSynchronizationContext(SynchronizationContext synchronizationContext)
        {
-            Error.ThrowArgumentNullException(syncContext, nameof(syncContext));
-            return new SwitchToSynchronizationContextAwaitable(syncContext);
+            Error.ThrowArgumentNullException(synchronizationContext, nameof(synchronizationContext));
+            return new SwitchToSynchronizationContextAwaitable(synchronizationContext);
+        }
+
+        public static ReturnToSynchronizationContext ReturnToSynchronizationContext(SynchronizationContext synchronizationContext)
+        {
+            return new ReturnToSynchronizationContext(synchronizationContext, false);
+        }
+
+        public static ReturnToSynchronizationContext ReturnToCurrentSynchronizationContext(bool dontPostWhenSameContext = true)
+        {
+            return new ReturnToSynchronizationContext(SynchronizationContext.Current, dontPostWhenSameContext);
        }
    }

@@ -43,10 +80,24 @@ namespace Cysharp.Threading.Tasks

    public struct SwitchToMainThreadAwaitable
    {
-        public Awaiter GetAwaiter() => new Awaiter();
+        readonly PlayerLoopTiming playerLoopTiming;
+
+        public SwitchToMainThreadAwaitable(PlayerLoopTiming playerLoopTiming)
+        {
+            this.playerLoopTiming = playerLoopTiming;
+        }
+
+        public Awaiter GetAwaiter() => new Awaiter(playerLoopTiming);

        public struct Awaiter : ICriticalNotifyCompletion
        {
+            readonly PlayerLoopTiming playerLoopTiming;
+
+            public Awaiter(PlayerLoopTiming playerLoopTiming)
+            {
+                this.playerLoopTiming = playerLoopTiming;
+            }
+
            public bool IsCompleted
            {
                get
@@ -67,12 +118,53 @@ namespace Cysharp.Threading.Tasks

            public void OnCompleted(Action continuation)
            {
-                PlayerLoopHelper.AddContinuation(PlayerLoopTiming.Update, continuation);
+                PlayerLoopHelper.AddContinuation(playerLoopTiming, continuation);
            }

            public void UnsafeOnCompleted(Action continuation)
            {
-                PlayerLoopHelper.AddContinuation(PlayerLoopTiming.Update, continuation);
+                PlayerLoopHelper.AddContinuation(playerLoopTiming, continuation);
+            }
+        }
+    }
+
+    public struct ReturnToMainThread
+    {
+        readonly PlayerLoopTiming playerLoopTiming;
+
+        public ReturnToMainThread(PlayerLoopTiming playerLoopTiming)
+        {
+            this.playerLoopTiming = playerLoopTiming;
+        }
+
+        public Awaiter DisposeAsync()
+        {
+            return new Awaiter(playerLoopTiming); // run immediate.
+        }
+
+        public readonly struct Awaiter : ICriticalNotifyCompletion
+        {
+            readonly PlayerLoopTiming timing;
+
+            public Awaiter(PlayerLoopTiming timing)
+            {
+                this.timing = timing;
+            }
+
+            public Awaiter GetAwaiter() => this;
+
+            public bool IsCompleted => PlayerLoopHelper.MainThreadId == System.Threading.Thread.CurrentThread.ManagedThreadId;
+
+            public void GetResult() { }
+
+            public void OnCompleted(Action continuation)
+            {
+                PlayerLoopHelper.AddContinuation(timing, continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                PlayerLoopHelper.AddContinuation(timing, continuation);
            }
        }
    }
@@ -92,12 +184,16 @@ namespace Cysharp.Threading.Tasks

            public void OnCompleted(Action continuation)
            {
-                ThreadPool.UnsafeQueueUserWorkItem(switchToCallback, continuation);
+                ThreadPool.QueueUserWorkItem(switchToCallback, continuation);
            }

            public void UnsafeOnCompleted(Action continuation)
            {
+#if NETCOREAPP3_1
+                ThreadPool.UnsafeQueueUserWorkItem(ThreadPoolWorkItem.Create(continuation), false);
+#else
                ThreadPool.UnsafeQueueUserWorkItem(switchToCallback, continuation);
+#endif
            }

            static void Callback(object state)
@@ -106,6 +202,47 @@ namespace Cysharp.Threading.Tasks
                continuation();
            }
        }
+
+#if NETCOREAPP3_1
+
+        sealed class ThreadPoolWorkItem : IThreadPoolWorkItem, ITaskPoolNode<ThreadPoolWorkItem>
+        {
+            static TaskPool<ThreadPoolWorkItem> pool;
+            public ThreadPoolWorkItem NextNode { get; set; }
+
+            static ThreadPoolWorkItem()
+            {
+                TaskPool.RegisterSizeGetter(typeof(ThreadPoolWorkItem), () => pool.Size);
+            }
+
+            Action continuation;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static ThreadPoolWorkItem Create(Action continuation)
+            {
+                if (!pool.TryPop(out var item))
+                {
+                    item = new ThreadPoolWorkItem();
+                }
+
+                item.continuation = continuation;
+                return item;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Execute()
+            {
+                var call = continuation;
+                continuation = null;
+                if (call != null)
+                {
+                    pool.TryPush(this);
+                    call.Invoke();
+                }
+            }
+        }
+
+#endif
    }

    public struct SwitchToTaskPoolAwaitable
@@ -178,5 +315,71 @@ namespace Cysharp.Threading.Tasks
            }
        }
    }
-}

+    public struct ReturnToSynchronizationContext
+    {
+        readonly SynchronizationContext syncContext;
+        readonly bool dontPostWhenSameContext;
+
+        public ReturnToSynchronizationContext(SynchronizationContext syncContext, bool dontPostWhenSameContext)
+        {
+            this.syncContext = syncContext;
+            this.dontPostWhenSameContext = dontPostWhenSameContext;
+        }
+
+        public Awaiter DisposeAsync()
+        {
+            return new Awaiter(syncContext, dontPostWhenSameContext);
+        }
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            static readonly SendOrPostCallback switchToCallback = Callback;
+
+            readonly SynchronizationContext synchronizationContext;
+            readonly bool dontPostWhenSameContext;
+
+            public Awaiter(SynchronizationContext synchronizationContext, bool dontPostWhenSameContext)
+            {
+                this.synchronizationContext = synchronizationContext;
+                this.dontPostWhenSameContext = dontPostWhenSameContext;
+            }
+
+            public Awaiter GetAwaiter() => this;
+
+            public bool IsCompleted
+            {
+                get
+                {
+                    var current = SynchronizationContext.Current;
+                    if (current == synchronizationContext)
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            public void GetResult() { }
+
+            public void OnCompleted(Action continuation)
+            {
+                synchronizationContext.Post(switchToCallback, continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                synchronizationContext.Post(switchToCallback, continuation);
+            }
+
+            static void Callback(object state)
+            {
+                var continuation = (Action)state;
+                continuation();
+            }
+        }
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
neuecc	da329e19d1	CI more	2020-06-04 15:24:09 +09:00
Yoshifumi Kawai	b8260d4e91	Merge pull request #61 from Cysharp/unitask2 UniTask2	2020-06-04 15:17:19 +09:00
neuecc	345e32aaf0	CI again	2020-06-04 15:14:40 +09:00
neuecc	d7bef8c5b5	setup release	2020-06-04 15:11:51 +09:00
neuecc	b2f82df4d3	fix action	2020-06-04 14:58:11 +09:00
neuecc	83596b3d1f	docs: update TOC	2020-06-04 05:53:07 +00:00
neuecc	0022598a1c	readme	2020-06-04 14:52:42 +09:00
neuecc	f4294d3752	Task Pool moved from Internal	2020-06-04 14:52:36 +09:00
neuecc	a1444c0b39	refactor DistinctUntilChanged	2020-06-03 02:03:31 +09:00
neuecc	e1d5359d73	refactor Where	2020-06-03 01:18:39 +09:00
neuecc	239bf749b6	refactor UniTaskAsyncEnumerable.Select	2020-06-03 00:50:39 +09:00
neuecc	2bf3b1e172	pj	2020-06-02 23:27:42 +09:00
neuecc	d225de201f	gitignore	2020-06-02 23:00:47 +09:00
neuecc	c3b8a3852d	UniTask.Linq.asmdef	2020-06-02 23:00:20 +09:00
neuecc	c31dab888e	fix UnITaskTracker causes Stackoverflow	2020-06-02 22:49:40 +09:00
neuecc	d4cf59bd2f	CI	2020-06-01 14:50:25 +09:00
neuecc	d5edc3acd3	guard for trigger invalid ops	2020-06-01 13:51:37 +09:00
neuecc	130286e8c2	TriggerEvent becomes linkedlist	2020-06-01 13:40:35 +09:00
neuecc	a9baa52309	Add ReturnToMainThread, ReturnToSynchronizationContext, ReturnToCurrentSynchronizationContext	2020-05-31 04:30:03 +09:00
neuecc	3001996298	Q check	2020-05-31 04:28:05 +09:00
neuecc	bfcd18aabb	MoveNextRunner -> StateMachineRunner	2020-05-29 14:35:50 +09:00
neuecc	96aa299e7e	support version -> unity 2018.4	2020-05-29 14:25:26 +09:00
neuecc	24faa34418	TaskPoolMonitor -> TaskPool	2020-05-29 03:58:22 +09:00
neuecc	21bf08a6b3	replace all promisepool to new taskpool system	2020-05-29 03:43:18 +09:00
neuecc	d5db96b913	rename StackNode to TaskPool	2020-05-29 02:08:11 +09:00
neuecc	a8455af16d	Improve pooling mechanism	2020-05-29 01:22:46 +09:00
neuecc	2290b14532	reduce AsyncBuilder heap allocation	2020-05-28 22:20:06 +09:00
neuecc	90c5a6311b	check il2cpp generics limitation	2020-05-28 21:18:35 +09:00
neuecc	6e0ad3623b	non public	2020-05-27 09:16:46 +09:00
neuecc	005e02a1fa	sealed	2020-05-27 07:39:19 +09:00
neuecc	10fb8060fa	use PooledDelegate to avoid convert Action to Action<AsyncOperation> allocation	2020-05-27 07:37:16 +09:00
neuecc	35b933730b	2.0.11-rc8	2020-05-25 19:44:57 +09:00
neuecc	7ab9467069	IObservable<T>.ToUniTask parameter order changed from CancellationToken cancellationToken, bool useFirst to bool useFirst, CancellationToken cancellationToken	2020-05-25 19:42:51 +09:00
neuecc	598312ba61	DOTween's WithCancellation remove = default	2020-05-25 19:38:08 +09:00
neuecc	985aa5c43a	add allocationchecker in netcore sandbox project	2020-05-25 19:37:11 +09:00
neuecc	10eff95a42	fix: does not work zero-allocation mechanism in release build	2020-05-25 19:36:39 +09:00
neuecc	d27d6d5d9d	UniTask.Yield in .NET Core becomes zero allocation	2020-05-25 19:33:54 +09:00
neuecc	b8c109848e	UniTaskVoid can not await.	2020-05-25 19:33:11 +09:00
neuecc	8b7f832c0f	JobHandle.WaitAsync accepts CancellationToken	2020-05-25 09:58:06 +09:00
neuecc	7cce0f48e5	call webRequest.Abort() on canceled	2020-05-25 09:54:26 +09:00
neuecc	8a56838111	modify cannot await twice message	2020-05-25 01:55:35 +09:00
neuecc	ff15e00003	f	2020-05-24 03:33:25 +09:00
neuecc	f60d2c51fb	fix in UnityEditor performance issue	2020-05-24 03:27:05 +09:00
neuecc	6dfb969015	Add ValueTask.AsUniTask only for .NET Core	2020-05-24 01:30:52 +09:00
neuecc	da7e9fc4b3	UniTask marked StructLayout(LayoutKind.Auto)	2020-05-24 01:30:33 +09:00
neuecc	70385c4115	Fix channel's cancellationTokenRegistration does not handle correctly	2020-05-24 00:19:13 +09:00
neuecc	51ba740413	In .NET Core, IUniTaskSource implements IValueTaskSource and implicit, zero overhead conversion	2020-05-24 00:18:39 +09:00
neuecc	f3e3ba8864	fix DOTweenExt's TweenCancelBehaviour.CancelAwait	2020-05-23 02:53:48 +09:00
neuecc	07cf65c1ec	lower support is 2019.1	2020-05-23 02:12:19 +09:00
neuecc	eca5b1c096	2.0.10-rc7	2020-05-23 02:11:00 +09:00
neuecc	c74ce14ad1	DoTween -> DOTween	2020-05-23 02:10:18 +09:00
neuecc	f59c56506f	Remove ConfigureAwait method from all async object extensions(renamed to ToUniTask). Add WithCancellation method to all async object extensions. Improved performance when async object is done.	2020-05-23 02:07:46 +09:00
neuecc	896eef1ee4	Add DoTween Extension	2020-05-23 01:10:04 +09:00
neuecc	ec0123eec7	rename UniTask.VoidAction -> UniTask.Action, UniTask.VoidUnityAction -> UniTask.UnityAction, there return type Func<UniTask> -> Func<UniTaskVoid>	2020-05-22 21:42:23 +09:00
neuecc	78f56b9b33	OCS	2020-05-22 17:15:36 +09:00
neuecc	1d88ed85bc	fix ComibineLatest	2020-05-22 11:08:03 +09:00
neuecc	2b7986da19	2.0.9-rc6	2020-05-22 10:45:16 +09:00
neuecc	c3d22968e1	State rename to AsyncReadOnlyReactiveProperty and removed setter and implicit conversion.	2020-05-22 10:44:41 +09:00
neuecc	0e25122ee2	Add Pairwise	2020-05-22 03:19:54 +09:00
neuecc	4504d84aa8	cl2	2020-05-22 02:34:04 +09:00
neuecc	2b87cadba3	Add CombineLatest	2020-05-22 02:25:36 +09:00
neuecc	21dc83c641	2.0.8-rc5	2020-05-21 02:26:55 +09:00
neuecc	3b593f349c	Add UnityEvent<T> and InputField AsyncEventHandler and extensions	2020-05-21 02:26:09 +09:00
neuecc	962c215e3b	Fix UniTask.WaitUntilValueChanged does not handle UnityEngine.Object is destroyed correctly	2020-05-21 02:24:12 +09:00
neuecc	42dcfdbcdc	Add UniTaskAsyncEnumerable.EveryValueChanged	2020-05-21 02:23:40 +09:00
neuecc	6d7e6ec871	Impl AsyncReactiveProperty.ToString, Add State	2020-05-21 02:22:24 +09:00
neuecc	36d53a3bcb	rc4	2020-05-20 11:05:58 +09:00
neuecc	ea9e61c2e1	Add CancellationToken.WaitUntilCanceled	2020-05-20 11:04:59 +09:00
neuecc	a52c26102b	guard for ForEachAsync	2020-05-20 10:48:28 +09:00
neuecc	e31c87b8a8	Add IUniTaskAsyncEnumerable.Publish	2020-05-19 15:58:04 +09:00
neuecc	cc165a6897	2.0.6-rc3	2020-05-19 04:14:23 +09:00
neuecc	f99910d802	Add TaskTracker to AsyncLINQ	2020-05-19 04:13:46 +09:00
neuecc	997b0b3710	Merge remote-tracking branch 'origin/unitask2' into unitask2	2020-05-19 03:43:09 +09:00
neuecc	ec7064083a	Add TaskTracker to Channel	2020-05-19 03:43:06 +09:00
neuecc	07cccfddd6	docs: update TOC	2020-05-18 18:34:05 +00:00
neuecc	f07527cd06	ECS?	2020-05-19 03:33:44 +09:00
neuecc	7b273c4bd1	Add UniTask.Defer	2020-05-19 03:10:37 +09:00
neuecc	d36e7987b3	Add SkipUntilCanceled, TakeUntilCanceled	2020-05-19 02:41:45 +09:00
neuecc	bbd5686816	Add UniTask.WaitUntilCanceled	2020-05-19 01:35:16 +09:00
neuecc	fb1152d8f4	IAsyncReadOnlyReactiveProperty -> IReadOnlyAsyncReactiveProperty, .Dipose retrurns MoveNext -> false	2020-05-19 01:20:20 +09:00
neuecc	7a306118f5	AsyncTrigger returns MoveNext -> false when destroyed	2020-05-19 01:19:46 +09:00
neuecc	efaf3ee8f5	IAsyncReadOnlyReactiveProperty.WithoutCurrent	2020-05-18 23:36:26 +09:00
neuecc	2e4fe90956	Fix ChannelReader.Completion throws UnobservedException when not touched	2020-05-18 23:33:13 +09:00
neuecc	e33d572104	2.0.5-rc2	2020-05-18 11:33:24 +09:00
neuecc	2b2af9e455	meta	2020-05-18 11:31:23 +09:00
neuecc	d003597662	Changed AsyncReactiveProperty produce current value at first, Add AsyncReactiveProperty.WithoutCurrent	2020-05-18 11:30:49 +09:00
neuecc	ec0a8f5a8b	Add IUniTaskAsyncEnumerable.Queue	2020-05-18 11:30:04 +09:00
neuecc	49ba57f20a	Fix IUniTaskAsyncEnumerable.Take	2020-05-18 11:29:35 +09:00
neuecc	6f4d1183cc	Add BindTo<TSource, TObject>(Action<TObject, TSource> bindAction)	2020-05-18 02:35:13 +09:00
neuecc	dd18c9fff8	Add Channel.CreateSingleConsumerUnbounded	2020-05-18 02:34:29 +09:00
neuecc	21f5f78ff1	Merge remote-tracking branch 'origin/unitask2' into unitask2	2020-05-17 16:51:20 +09:00
neuecc	1729f389db	fix ReactiveProperty implements IAsyncReactiveProperty	2020-05-17 16:51:10 +09:00
neuecc	6d37bb7bac	docs: update TOC	2020-05-17 07:50:05 +00:00
neuecc	957adfad7a	fix Await UniTaskAsyncEnumerable.Timer is not over. #76	2020-05-17 16:49:44 +09:00
neuecc	3ef889e17d	no artifact name?	2020-05-17 03:02:55 +09:00
neuecc	c73af7390f	removed manifestjson	2020-05-17 02:51:51 +09:00
neuecc	c5b4376486	gh-actions	2020-05-17 02:43:54 +09:00