feat: Update package.json to 2.2.1

Ver 2.2.0

.github/workflows/build-debug.yml

@@ -3,16 +3,16 @@ name: Build-Debug
 on:
   push:
     branches:
-      - "**"
+      - "master"
     tags:
       - "!*" # not a tag push
   pull_request:
-    types:
-      - opened
-      - synchronize
+    branches:
+      - "master"
 
 jobs:
   build-dotnet:
+    if: "!(contains(github.event.head_commit.message, '[skip ci]') || contains(github.event.head_commit.message, '[ci skip]'))"
     runs-on: ubuntu-latest
     env:
       DOTNET_CLI_TELEMETRY_OPTOUT: 1
@@ -22,52 +22,65 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: 3.1.101
+          dotnet-version: 3.1.x
       - run: dotnet test -c Debug ./src/UniTask.NetCoreTests/UniTask.NetCoreTests.csproj
 
   build-unity:
+    if: "!(contains(github.event.head_commit.message, '[skip ci]') || contains(github.event.head_commit.message, '[ci skip]')) && ((github.event_name == 'push' && github.repository_owner == 'Cysharp') || startsWith(github.event.pull_request.head.label, 'Cysharp:'))"
     strategy:
       matrix:
-        unity: ['2019.3.9f1', '2020.1.0b5']
+        unity: ["2019.3.9f1", "2019.4.13f1", "2020.1.12f1"]
         include:
           - unity: 2019.3.9f1
-            license: UNITY_2019_3
-          - unity: 2020.1.0b5
-            license: UNITY_2020_1
+            license: UNITY_LICENSE_2019
+          - unity: 2019.4.13f1
+            license: UNITY_LICENSE_2019
+          - unity: 2020.1.12f1
+            license: UNITY_LICENSE_2020
     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
+      # Execute scripts: RuntimeUnitTestToolkit
+      # /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend mono /BuildTarget StandaloneLinux64
+      - name: Build UnitTest(Linux64, mono)
+        uses: game-ci/unity-builder@v2.0-alpha-6
         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
+        with:
+          projectPath: src/UniTask
+          unityVersion: ${{ matrix.unity }}
+          targetPlatform: StandaloneLinux64
+          buildMethod: UnitTestBuilder.BuildUnitTest
+          customParameters: /headless /ScriptBackend mono
+          versioning: None
       - name: Execute UnitTest
         run: ./src/UniTask/bin/UnitTest/StandaloneLinux64_Mono2x/test
 
       # Execute scripts: Export Package
+      #  /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
       - name: Export unitypackage
-        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+        uses: game-ci/unity-builder@v2.0-alpha-6
+        env:
+          UNITY_LICENSE: ${{ secrets[matrix.license] }}
+        with:
+          projectPath: src/UniTask
+          unityVersion: ${{ matrix.unity }}
+          targetPlatform: StandaloneLinux64
+          buildMethod: PackageExporter.Export
+          versioning: None
+
+      - name: check all .meta is commited
+        run: |
+          if git ls-files --others --exclude-standard -t | grep --regexp='[.]meta$'; then
+            echo "Detected .meta file generated. Do you forgot commit a .meta file?"
+            exit 1
+          else
+            echo "Great, all .meta files are commited."
+          fi
         working-directory: src/UniTask
 
-      # Store artifacts.      
+      # Store artifacts.
       - uses: actions/upload-artifact@v2
         with:
-          name: UniTask.unitypackage.zip
-          path: ./src/UniTask/*.unitypackage
+          name: UniTask.unitypackage-${{ matrix.unity }}.zip
+          path: ./src/UniTask/*.unitypackage

.github/workflows/build-docs.yml

@@ -0,0 +1,31 @@
+name: build-docs
+
+on:
+  push:
+    branches:
+      - master
+      - feature/docs
+
+jobs:
+  run-docfx:
+    if: "!(contains(github.event.head_commit.message, '[skip ci]') || contains(github.event.head_commit.message, '[ci skip]'))"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/checkout@v2
+        with:
+          repository: Cysharp/DocfxTemplate
+          path: docs/_DocfxTemplate
+      - uses: Kirbyrawr/docfx-action@master
+        name: Docfx metadata
+        with:
+          args: metadata docs/docfx.json
+      - uses: Kirbyrawr/docfx-action@master
+        name: Docfx build
+        with:
+          args: build docs/docfx.json
+      - name: Publish to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: docs/_site

.github/workflows/build-release.yml

@@ -1,108 +1,181 @@
-name: Build-Release
+name: build-release
 
 on:
-  push:
-    tags:
-      - "[0-9]+.[0-9]+.[0-9]+*"
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "tag: git tag you want create. (sample 1.0.0)"
+        required: true
+      dry_run:
+        description: "dry_run: true will never create relase/nuget."
+        required: true
+        default: "false"
+
+env:
+  GIT_TAG: ${{ github.event.inputs.tag }}
+  DRY_RUN: ${{ github.event.inputs.dry_run }}
+  DRY_RUN_BRANCH_PREFIX: "test_release"
+  DOTNET_SDK_VERISON_3: 3.1.x
 
 jobs:
-  build-dotnet:
+  update-packagejson:
     runs-on: ubuntu-latest
+    env:
+      TARGET_FILE: ./src/UniTask/Assets/Plugins/UniTask/package.json
+    outputs:
+      sha: ${{ steps.commit.outputs.sha }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: before
+        run: cat ${{ env.TARGET_FILE}}
+      - name: update package.json to version ${{ env.GIT_TAG }}
+        run: sed -i -e "s/\(\"version\":\) \"\(.*\)\",/\1 \"${{ env.GIT_TAG }}\",/" ${{ env.TARGET_FILE }}
+      - name: after
+        run: cat ${{ env.TARGET_FILE}}
+      - name: Commit files
+        id: commit
+        run: |
+          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git commit -m "feat: Update package.json to ${{ env.GIT_TAG }}" -a
+          echo "::set-output name=sha::$(git rev-parse HEAD)"
+      - name: check sha
+        run: echo "SHA ${SHA}"
+        env:
+          SHA: ${{ steps.commit.outputs.sha }}
+      - name: tag
+        run: git tag ${{ env.GIT_TAG }}
+        if: env.DRY_RUN == 'false'
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ github.ref }}
+          tags: true
+        if: env.DRY_RUN == 'false'
+      - name: Push changes (dry_run)
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ env.DRY_RUN_BRANCH_PREFIX }}-${{ env.GIT_TAG }}
+          tags: false
+        if: env.DRY_RUN == 'true'
+
+  build-dotnet:
+    needs: [update-packagejson]
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
     env:
       DOTNET_CLI_TELEMETRY_OPTOUT: 1
       DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
       NUGET_XMLDOC_MODE: skip
     steps:
+      - run: echo ${{ needs.update-packagejson.outputs.sha }}
       - uses: actions/checkout@v2
+        with:
+          ref: ${{ needs.update-packagejson.outputs.sha }}
       - 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 CommandTools first (use dotnet run command in ZLogger.csproj)
-      - run: dotnet build -c Release ./tools/CommandTools/CommandTools.csproj
+          dotnet-version: "${{ env.DOTNET_SDK_VERSION_3 }}"
+      # build and pack
       - run: dotnet build -c Release -p:Version=${{ env.GIT_TAG }}
       - run: dotnet test -c Release --no-build
-      - run: dotnet pack ./src/ZLogger/ZLogger.csproj -c Release --no-build -p:Version=${{ env.GIT_TAG }}
-
+      - run: dotnet pack ./src/UniTask.NetCore/UniTask.NetCore.csproj -c Release --no-build -p:Version=${{ env.GIT_TAG }} -o ./publish
       # Store artifacts.
       - uses: actions/upload-artifact@v1
         with:
           name: nuget
-          path: ./src/ZLogger/bin/Release/ZLogger.${{ env.GIT_TAG }}.nupkg
-      
+          path: ./publish/
+
   build-unity:
+    needs: [update-packagejson]
     strategy:
       matrix:
-        unity: ['2019.3.9f1']
+        unity: ["2019.3.9f1"]
         include:
           - unity: 2019.3.9f1
-            license: UNITY_2019_3
+            license: UNITY_LICENSE_2019
     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
+    timeout-minutes: 15
     steps:
-      - run: apt update && apt install git -y
+      - run: echo ${{ needs.update-packagejson.outputs.sha }}
       - uses: actions/checkout@v2
-      - run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
+        with:
+          ref: ${{ needs.update-packagejson.outputs.sha }}
+      # Execute scripts: Export Package
+      # /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+      - name: Export unitypackage
+        uses: game-ci/unity-builder@v2.0-alpha-6
         env:
           UNITY_LICENSE: ${{ secrets[matrix.license] }}
-      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
+        with:
+          projectPath: src/UniTask
+          unityVersion: ${{ matrix.unity }}
+          targetPlatform: StandaloneLinux64
+          buildMethod: PackageExporter.Export
+          versioning: None
 
-      # 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/ZLogger.Unity
-        env:
-          UNITY_PACKAGE_VERSION: ${{ env.GIT_TAG }}
+      - name: check all .meta is commited
+        run: |
+          if git ls-files --others --exclude-standard -t | grep --regexp='[.]meta$'; then
+            echo "Detected .meta file generated. Do you forgot commit a .meta file?"
+            exit 1
+          else
+            echo "Great, all .meta files are commited."
+          fi
+        working-directory: src/UniTask
 
       # Store artifacts.
-      - uses: actions/upload-artifact@v1
+      - uses: actions/upload-artifact@v2
         with:
-          name: ZLogger.Unity.${{ env.GIT_TAG }}.unitypackage
-          path: ./src/ZLogger.Unity/ZLogger.Unity.${{ env.GIT_TAG }}.unitypackage
+          name: UniTask.${{ env.GIT_TAG }}.unitypackage
+          path: ./src/UniTask/UniTask.${{ env.GIT_TAG }}.unitypackage
 
   create-release:
-    needs: [build-dotnet, build-unity]
+    if: github.event.inputs.dry_run == 'false'
+    needs: [update-packagejson, 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/}
+      # setup dotnet for nuget push
+      - uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: "${{ env.DOTNET_SDK_VERSION_3 }}"
+      # Create Releases
+      - uses: actions/create-release@v1
+        id: create_release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ env.GIT_TAG }}
+          release_name: Ver.${{ env.GIT_TAG }}
+          commitish: ${{ needs.update-packagejson.outputs.sha }}
+          draft: true
+          prerelease: false
+      # Download(All) Artifacts to current directory
+      - uses: actions/download-artifact@v2
+      # Upload to NuGet
+      - run: dotnet nuget push "./nuget/*.nupkg" --skip-duplicate -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
 
-    # 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: ./ZLogger.Unity.${{ env.GIT_TAG }}.unitypackage/ZLogger.Unity.${{ env.GIT_TAG }}.unitypackage
-        asset_name: ZLogger.Unity.${{ env.GIT_TAG }}.unitypackage
-        asset_content_type: application/octet-stream
+  cleanup:
+    if: github.event.inputs.dry_run == 'true'
+    needs: [build-dotnet, build-unity]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Delete branch
+        uses: dawidd6/action-delete-branch@v3
+        with:
+          github_token: ${{ github.token }}
+          branches: ${{ env.DRY_RUN_BRANCH_PREFIX }}-${{ env.GIT_TAG }}

.github/workflows/stale.yml

@@ -0,0 +1,24 @@
+name: "Close stale issues"
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          # enable issue
+          stale-issue-message: "This issue is stale because it has been open 90 days with no activity. Remove stale label or comment or this will be closed in 7 days."
+          stale-issue-label: "stale"
+          # enable pr
+          stale-pr-message: "This PR is stale because it has been open 90 days with no activity. Remove stale label or comment or this will be closed in 7 days."
+          stale-pr-label: "stale"
+          days-before-stale: 90
+          days-before-close: 7
+          exempt-issue-labels: "wip"
+          exempt-pr-labels: "wip"
+          remove-stale-when-updated: true

.gitignore

@@ -157,3 +157,107 @@ src/UniTask/UniTask.Tests.csproj
 src/UniTask/UniTask.Tests.Editor.csproj
 
 src/UniTask/UniTask.*.unitypackage
+
+src/UniTask/UniTask.Linq.csproj
+
+src/UniTask/DOTween.Modules.csproj
+
+src/UniTask/Unity.Addressables.csproj
+
+src/UniTask/Unity.Addressables.Editor.csproj
+
+src/UniTask/Unity.Analytics.DataPrivacy.csproj
+
+src/UniTask/Unity.Recorder.csproj
+
+src/UniTask/Unity.Recorder.Editor.csproj
+
+src/UniTask/Unity.ResourceManager.csproj
+
+src/UniTask/Unity.Rider.Editor.csproj
+
+src/UniTask/Unity.ScriptableBuildPipeline.csproj
+
+src/UniTask/Unity.ScriptableBuildPipeline.Editor.csproj
+
+src/UniTask/Unity.TextMeshPro.csproj
+
+src/UniTask/Unity.TextMeshPro.Editor.csproj
+
+src/UniTask/Unity.Timeline.csproj
+
+src/UniTask/Unity.Timeline.Editor.csproj
+
+src/UniTask/Unity.VisualStudio.Editor.csproj
+
+src/UniTask/Unity.VSCode.Editor.csproj
+
+src/UniTask/UnityEditor.CacheServer.csproj
+
+src/UniTask/UnityEditor.TestRunner.csproj
+
+src/UniTask/UnityEditor.UI.csproj
+
+src/UniTask/UnityEngine.Advertisements.csproj
+
+src/UniTask/UnityEngine.Monetization.csproj
+
+src/UniTask/UnityEngine.TestRunner.csproj
+
+src/UniTask/UnityEngine.UI.csproj
+
+src/UniTask/TempAsm.csproj
+
+src/UniTask/UniTask.Addressables.csproj
+
+src/UniTask/UniTask.DOTween.csproj
+
+src/UniTask/UniTask.TextMeshPro.csproj
+
+src/UniTask/RuntimeUnitTestToolkit.Player.csproj
+
+src/UniTask/TempAsm.Player.csproj
+
+src/UniTask/UniTask.Addressables.Player.csproj
+
+src/UniTask/UniTask.DOTween.Player.csproj
+
+src/UniTask/UniTask.Linq.Player.csproj
+
+src/UniTask/UniTask.Player.csproj
+
+src/UniTask/UniTask.Tests.Player.csproj
+
+src/UniTask/UniTask.TextMeshPro.Player.csproj
+
+src/UniTask/Unity.Addressables.Player.csproj
+
+src/UniTask/Unity.Analytics.DataPrivacy.Player.csproj
+
+src/UniTask/Unity.ResourceManager.Player.csproj
+
+src/UniTask/Unity.ScriptableBuildPipeline.Player.csproj
+
+src/UniTask/Unity.TextMeshPro.Player.csproj
+
+src/UniTask/Unity.Timeline.Player.csproj
+
+src/UniTask/UnityEngine.Advertisements.Player.csproj
+
+src/UniTask/UnityEngine.Monetization.Player.csproj
+
+src/UniTask/UnityEngine.TestRunner.Player.csproj
+
+src/UniTask/UnityEngine.UI.Player.csproj
+
+src/UniTask/DOTween.Modules.Player.csproj
+
+src/UniTask/Assembly-CSharp.Player.csproj
+
+src/UniTask/Unity.EditorCoroutines.Editor.csproj
+
+src/UniTask/.vsconfig
+
+src/UniTask/Logs/ApiUpdaterCheck.txt
+
+src/UniTask/Assembly-CSharp-firstpass.csproj

docs/.gitignore

@@ -0,0 +1,10 @@
+###############
+#    folder   #
+###############
+/**/DROP/
+/**/TEMP/
+/**/packages/
+/**/bin/
+/**/obj/
+_site
+_DocfxTemplate

docs/api/.gitignore

@@ -0,0 +1,5 @@
+###############
+#  temp file  #
+###############
+*.yml
+.manifest

docs/docfx.json

@@ -0,0 +1,70 @@
+{
+  "metadata": [
+    {
+      "src": [
+        {
+          "files": [
+            "UniTask/Assets/Plugins/UniTask/Runtime/**/*.cs"
+          ],
+          "src": "../src"
+        }
+      ],
+      "dest": "api",
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false
+    }
+  ],
+  "build": {
+    "globalMetadata": {
+      "_disableContribution": true,
+      "_appTitle": "UniTask"
+    },
+    "content": [
+      {
+        "files": [
+          "api/**.yml",
+          "api/index.md"
+        ]
+      },
+      {
+        "files": [
+          "articles/**.md",
+          "articles/**/toc.yml",
+          "toc.yml",
+          "*.md"
+        ]
+      }
+    ],
+    "resource": [
+      {
+        "files": [
+          "images/**"
+        ]
+      }
+    ],
+    "overwrite": [
+      {
+        "files": [
+          "apidoc/**.md"
+        ],
+        "exclude": [
+          "obj/**",
+          "_site/**"
+        ]
+      }
+    ],
+    "dest": "_site",
+
+    "globalMetadataFiles": [],
+    "fileMetadataFiles": [],
+    "template": [
+      "_DocfxTemplate/templates/default-v2.5.2",
+      "_DocfxTemplate/templates/cysharp"
+    ],
+    "postProcessors": [],
+    "markdownEngineName": "markdig",
+    "noLangKeyword": false,
+    "keepFileLink": false,
+    "cleanupCacheHistory": false
+  }
+}

docs/index.md

@@ -0,0 +1,8 @@
+---
+title: Home
+---
+# UniTask
+
+Provides an efficient async/await integration to Unity.
+
+https://github.com/Cysharp/UniTask

docs/toc.yml

@@ -0,0 +1,11 @@
+- name: API Documentation
+  href: api/
+  homepage: api/Cysharp.Threading.Tasks.html
+
+- name: Repository
+  href: https://github.com/Cysharp/UniTask
+  homepage: https://github.com/Cysharp/UniTask
+
+- name: Releases
+  href: https://github.com/Cysharp/UniTask/releases
+  homepage: https://github.com/Cysharp/UniTask/releases

src/UniTask.NetCore/NetCore/AsyncEnumerableExtensions.cs

@@ -0,0 +1,101 @@
+#if !NETSTANDARD2_0
+
+#pragma warning disable 0649
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Threading.Tasks.Sources;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class AsyncEnumerableExtensions
+    {
+        public static IUniTaskAsyncEnumerable<T> AsUniTaskAsyncEnumerable<T>(this IAsyncEnumerable<T> source)
+        {
+            return new AsyncEnumerableToUniTaskAsyncEnumerable<T>(source);
+        }
+
+        public static IAsyncEnumerable<T> AsAsyncEnumerable<T>(this IUniTaskAsyncEnumerable<T> source)
+        {
+            return new UniTaskAsyncEnumerableToAsyncEnumerable<T>(source);
+        }
+
+        sealed class AsyncEnumerableToUniTaskAsyncEnumerable<T> : IUniTaskAsyncEnumerable<T>
+        {
+            readonly IAsyncEnumerable<T> source;
+
+            public AsyncEnumerableToUniTaskAsyncEnumerable(IAsyncEnumerable<T> source)
+            {
+                this.source = source;
+            }
+
+            public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+            {
+                return new Enumerator(source.GetAsyncEnumerator(cancellationToken));
+            }
+
+            sealed class Enumerator : IUniTaskAsyncEnumerator<T>
+            {
+                readonly IAsyncEnumerator<T> enumerator;
+
+                public Enumerator(IAsyncEnumerator<T> enumerator)
+                {
+                    this.enumerator = enumerator;
+                }
+
+                public T Current => enumerator.Current;
+
+                public async UniTask DisposeAsync()
+                {
+                    await enumerator.DisposeAsync();
+                }
+
+                public async UniTask<bool> MoveNextAsync()
+                {
+                    return await enumerator.MoveNextAsync();
+                }
+            }
+        }
+
+        sealed class UniTaskAsyncEnumerableToAsyncEnumerable<T> : IAsyncEnumerable<T>
+        {
+            readonly IUniTaskAsyncEnumerable<T> source;
+
+            public UniTaskAsyncEnumerableToAsyncEnumerable(IUniTaskAsyncEnumerable<T> source)
+            {
+                this.source = source;
+            }
+
+            public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+            {
+                return new Enumerator(source.GetAsyncEnumerator(cancellationToken));
+            }
+
+            sealed class Enumerator : IAsyncEnumerator<T>
+            {
+                readonly IUniTaskAsyncEnumerator<T> enumerator;
+
+                public Enumerator(IUniTaskAsyncEnumerator<T> enumerator)
+                {
+                    this.enumerator = enumerator;
+                }
+
+                public T Current => enumerator.Current;
+
+                public ValueTask DisposeAsync()
+                {
+                    return enumerator.DisposeAsync();
+                }
+
+                public ValueTask<bool> MoveNextAsync()
+                {
+                    return enumerator.MoveNextAsync();
+                }
+            }
+        }
+    }
+}
+
+#endif

src/UniTask.NetCore/NetCore/UniTask.AsValueTask.cs

@@ -1,7 +1,6 @@
 #pragma warning disable 0649
 
 using System;
-using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using System.Threading.Tasks.Sources;
 
@@ -9,115 +8,90 @@ 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);
+#if NETSTANDARD2_0
+            return new ValueTask(new UniTaskValueTaskSource(task), 0);
+#else
+            return task;
+#endif
         }
 
-        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);
+#if NETSTANDARD2_0
+            return new ValueTask<T>(new UniTaskValueTaskSource<T>(task), 0);
+#else
+            return task;
+#endif
         }
 
-        struct UniTaskToValueTask
+        public static async UniTask<T> AsUniTask<T>(this ValueTask<T> task)
         {
-            public IUniTaskSource source;
-            public short token;
+            return await task;
         }
 
+        public static async UniTask AsUniTask(this ValueTask task)
+        {
+            await task;
+        }
+
+#if NETSTANDARD2_0
+
         class UniTaskValueTaskSource : IValueTaskSource
         {
-            readonly IUniTaskSource source;
+            readonly UniTask task;
+            readonly UniTask.Awaiter awaiter;
 
-            public UniTaskValueTaskSource(IUniTaskSource source)
+            public UniTaskValueTaskSource(UniTask task)
             {
-                this.source = source;
+                this.task = task;
+                this.awaiter = task.GetAwaiter();
             }
 
             public void GetResult(short token)
             {
-                source.GetResult(token);
+                awaiter.GetResult();
             }
 
             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;
-                }
+                return (ValueTaskSourceStatus)task.Status;
             }
 
             public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
             {
-                source.OnCompleted(continuation, state, token);
+                awaiter.SourceOnCompleted(continuation, state);
             }
         }
 
-        struct UniTaskToValueTask<T>
-        {
-            public IUniTaskSource<T> source;
-            public T result;
-            public short token;
-        }
-
         class UniTaskValueTaskSource<T> : IValueTaskSource<T>
         {
-            readonly IUniTaskSource<T> source;
+            readonly UniTask<T> task;
+            readonly UniTask<T>.Awaiter awaiter;
 
-            public UniTaskValueTaskSource(IUniTaskSource<T> source)
+            public UniTaskValueTaskSource(UniTask<T> task)
             {
-                this.source = source;
+                this.task = task;
+                this.awaiter = task.GetAwaiter();
             }
 
             public T GetResult(short token)
             {
-                return source.GetResult(token);
+                return awaiter.GetResult();
             }
 
             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;
-                }
+                return (ValueTaskSourceStatus)task.Status;
             }
 
             public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
             {
-                source.OnCompleted(continuation, state, token);
+                awaiter.SourceOnCompleted(continuation, state);
             }
         }
+
+#endif
     }
 }

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();
+//            }
+//        }
+//    }
+//}

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,48 @@ namespace Cysharp.Threading.Tasks
                     ((Action)state).Invoke();
                 }
             }
+
+#if NETCOREAPP3_1
+
+            sealed class ThreadPoolWorkItem : IThreadPoolWorkItem, ITaskPoolNode<ThreadPoolWorkItem>
+            {
+                static TaskPool<ThreadPoolWorkItem> pool;
+                ThreadPoolWorkItem nextNode;
+                public ref ThreadPoolWorkItem NextNode => ref nextNode;
+
+                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
         }
     }
 }

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;netstandard2.0</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="
@@ -17,17 +36,18 @@
 ..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\DiagnosticsExtensions.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\PlayerLoopRunner.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\ContinuationQueue.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\UnityWebRequestExtensions.cs;
   
+..\UniTask\Assets\Plugins\UniTask\Runtime\UniTaskSynchronizationContext.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\CancellationTokenSourceExtensions.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\EnumeratorAsyncExtensions.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\TimeoutController.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\PlayerLoopHelper.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Delay.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Run.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Bridge.cs;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.WaitUntil.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.uGUI.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.MonoBehaviour.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.*;
 ..\UniTask\Assets\Plugins\UniTask\Runtime\UnityBindingExtensions.cs;
 " />
     </ItemGroup>

src/UniTask.NetCoreSandbox/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();
+    }
+}

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();
+    }
+}

src/UniTask.NetCoreSandbox/Program.cs

@@ -1,4 +1,6 @@
-using Cysharp.Threading.Tasks;
+#pragma warning disable CS1998
+
+using Cysharp.Threading.Tasks;
 
 using System.Linq;
 using System;
@@ -15,12 +17,150 @@ 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
+    {
+
+    }
+
+    class Foo
+    {
+        public async UniTask MethodFooAsync()
+        {
+            await MethodBarAsync();
+        }
+
+        private async UniTask MethodBarAsync()
+
+        {
+            Throw();
+        }
+
+        private void Throw()
+        {
+            throw new 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,21 +226,116 @@ namespace NetCoreSandbox
             await Task.Delay(10, cancellationToken);
         }
 
-
-
-        static void Main(string[] args)
+        public class MyDisposable : IDisposable
         {
+            public void Dispose()
+            {
 
-            var channel = Channel.CreateSingleConsumerUnbounded<int>();
+            }
+        }
+
+        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
+
+            var e = UniTaskAsyncEnumerable.Create<int>(async (writer, token) =>
+            {
+                for (int i = 0; i < 5; i++)
+                {
+                    Console.WriteLine($"Start {i}");
+                    await writer.YieldAsync(i);
+                    Console.WriteLine($"End {i}");
+                }
+            });
+
+            var ee = e.GetAsyncEnumerator();
+            while (await ee.MoveNextAsync())
+            {
+                Console.WriteLine("ForEach " + ee.Current);
+            }
+
 
 
         }
 
+        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()
         {

src/UniTask.NetCoreSandbox/QueueCheck.cs

@@ -0,0 +1,473 @@
+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();
+    RefNode refNode1 = new RefNode();
+    RefNode refNode2 = new RefNode();
+    Queue<Node> q1 = new Queue<Node>();
+    Stack<Node> s1 = new Stack<Node>();
+    ConcurrentQueue<Node> cq = new ConcurrentQueue<Node>();
+    ConcurrentStack<Node> cs = new ConcurrentStack<Node>();
+    static TaskPool<Node> pool;
+    static TaskPoolRefNode<RefNode> poolRefNode;
+    static TaskPoolEqualNull<Node> poolEqualNull;
+    static TaskPoolClass<Node> poolClass = new TaskPoolClass<Node>();
+    static TaskPoolWithoutSize<Node> poolWithoutSize;
+    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 TaskPoolRefNode()
+    {
+        poolRefNode.TryPush(refNode1);
+        poolRefNode.TryPush(refNode2);
+        poolRefNode.TryPop(out _);
+        poolRefNode.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; }
+}
+
+public sealed class RefNode :ITaskPoolRefNode<RefNode>
+{
+    RefNode nextNode;
+    public ref RefNode NextNode => ref nextNode;
+}
+
+public interface ITaskPoolRefNode<T>
+{
+    ref T NextNode { get; }
+}
+
+
+// mutable struct, don't mark readonly.
+[StructLayout(LayoutKind.Auto)]
+public struct TaskPoolWithoutLock<T>
+    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 TaskPoolRefNode<T>
+    where T : class, ITaskPoolRefNode<T>
+{
+    int gate;
+    int size;
+    T root;
+
+    public int Size => size;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPop(out T result)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            var v = root;
+            if (!(v is null))
+            {
+                ref var nextNode = ref v.NextNode;
+                root = nextNode;
+                nextNode = null;
+                size--;
+                result = v;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+
+            Volatile.Write(ref gate, 0);
+        }
+        result = default;
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool TryPush(T item)
+    {
+        if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
+        {
+            //if (size < TaskPool.MaxPoolSize)
+            {
+                item.NextNode = root;
+                root = item;
+                size++;
+                Volatile.Write(ref gate, 0);
+                return true;
+            }
+            //else
+            {
+                //  Volatile.Write(ref gate, 0);
+            }
+        }
+        return false;
+    }
+}
+
+[StructLayout(LayoutKind.Auto)]
+public struct TaskPoolEqualNull<T>
+    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;
+    }
+}

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>

src/UniTask.NetCoreTests/AsyncLazyTest.cs

@@ -0,0 +1,167 @@
+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 AsyncLazyTest
+    {
+        [Fact]
+        public async Task LazyLazy()
+        {
+            {
+                var l = UniTask.Lazy(() => After());
+                var a = AwaitAwait(l.Task);
+                var b = AwaitAwait(l.Task);
+                var c = AwaitAwait(l.Task);
+
+                await a;
+                await b;
+                await c;
+            }
+            {
+                var l = UniTask.Lazy(() => AfterException());
+                var a = AwaitAwait(l.Task);
+                var b = AwaitAwait(l.Task);
+                var c = AwaitAwait(l.Task);
+
+                await Assert.ThrowsAsync<TaskTestException>(async () => await a);
+                await Assert.ThrowsAsync<TaskTestException>(async () => await b);
+                await Assert.ThrowsAsync<TaskTestException>(async () => await c);
+            }
+        }
+
+        [Fact]
+        public async Task LazyImmediate()
+        {
+            {
+                var l = UniTask.Lazy(() => UniTask.FromResult(1).AsUniTask());
+                var a = AwaitAwait(l.Task);
+                var b = AwaitAwait(l.Task);
+                var c = AwaitAwait(l.Task);
+
+                await a;
+                await b;
+                await c;
+            }
+            {
+                var l = UniTask.Lazy(() => UniTask.FromException(new TaskTestException()));
+                var a = AwaitAwait(l.Task);
+                var b = AwaitAwait(l.Task);
+                var c = AwaitAwait(l.Task);
+
+                await Assert.ThrowsAsync<TaskTestException>(async () => await a);
+                await Assert.ThrowsAsync<TaskTestException>(async () => await b);
+                await Assert.ThrowsAsync<TaskTestException>(async () => await c);
+            }
+        }
+
+        static async UniTask AwaitAwait(UniTask t)
+        {
+            await t;
+        }
+
+
+        async UniTask After()
+        {
+            await UniTask.Yield();
+            Thread.Sleep(TimeSpan.FromSeconds(1));
+            await UniTask.Yield();
+            await UniTask.Yield();
+        }
+
+        async UniTask AfterException()
+        {
+            await UniTask.Yield();
+            Thread.Sleep(TimeSpan.FromSeconds(1));
+            await UniTask.Yield();
+            throw new TaskTestException();
+        }
+    }
+
+    public class AsyncLazyTest2
+    {
+        [Fact]
+        public async Task LazyLazy()
+        {
+            {
+                var l = UniTask.Lazy(() => After());
+                var a = AwaitAwait(l.Task);
+                var b = AwaitAwait(l.Task);
+                var c = AwaitAwait(l.Task);
+
+                var a2 = await a;
+                var b2 = await b;
+                var c2 = await c;
+                (a2, b2, c2).Should().Be((10, 10, 10));
+            }
+            {
+                var l = UniTask.Lazy(() => AfterException());
+                var a = AwaitAwait(l.Task);
+                var b = AwaitAwait(l.Task);
+                var c = AwaitAwait(l.Task);
+
+                await Assert.ThrowsAsync<TaskTestException>(async () => await a);
+                await Assert.ThrowsAsync<TaskTestException>(async () => await b);
+                await Assert.ThrowsAsync<TaskTestException>(async () => await c);
+            }
+        }
+
+        [Fact]
+        public async Task LazyImmediate()
+        {
+            {
+                var l = UniTask.Lazy(() => UniTask.FromResult(1));
+                var a = AwaitAwait(l.Task);
+                var b = AwaitAwait(l.Task);
+                var c = AwaitAwait(l.Task);
+
+                var a2 = await a;
+                var b2 = await b;
+                var c2 = await c;
+                (a2, b2, c2).Should().Be((1, 1, 1));
+            }
+            {
+                var l = UniTask.Lazy(() => UniTask.FromException<int>(new TaskTestException()));
+                var a = AwaitAwait(l.Task);
+                var b = AwaitAwait(l.Task);
+                var c = AwaitAwait(l.Task);
+
+                await Assert.ThrowsAsync<TaskTestException>(async () => await a);
+                await Assert.ThrowsAsync<TaskTestException>(async () => await b);
+                await Assert.ThrowsAsync<TaskTestException>(async () => await c);
+            }
+        }
+
+        static async UniTask<int> AwaitAwait(UniTask<int> t)
+        {
+            return await t;
+        }
+
+
+        async UniTask<int> After()
+        {
+            await UniTask.Yield();
+            Thread.Sleep(TimeSpan.FromSeconds(1));
+            await UniTask.Yield();
+            await UniTask.Yield();
+            return 10;
+        }
+
+        async UniTask<int> AfterException()
+        {
+            await UniTask.Yield();
+            Thread.Sleep(TimeSpan.FromSeconds(1));
+            await UniTask.Yield();
+            throw new TaskTestException();
+        }
+    }
+}

src/UniTask.NetCoreTests/AsyncReactivePropertyTest.cs

@@ -51,6 +51,146 @@ namespace NetCoreTests
 
             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);
+        }
+
+        [Fact]
+        public async Task WaitAsyncTest()
+        {
+            var rp = new AsyncReactiveProperty<int>(128);
+
+            var f = await rp.FirstAsync();
+            f.Should().Be(128);
+
+            {
+                var t = rp.WaitAsync();
+                rp.Value = 99;
+                rp.Value = 100;
+                var v = await t;
+
+                v.Should().Be(99);
+            }
+
+            {
+                var t = rp.WaitAsync();
+                rp.Value = 99;
+                rp.Value = 100;
+                var v = await t;
+
+                v.Should().Be(99);
+            }
+        }
+
+
+        [Fact]
+        public async Task WaitAsyncCancellationTest()
+        {
+            var cts = new CancellationTokenSource();
+
+            var rp = new AsyncReactiveProperty<int>(128);
+
+            var t = rp.WaitAsync(cts.Token);
+
+            cts.Cancel();
+
+            rp.Value = 99;
+            rp.Value = 100;
+
+            await Assert.ThrowsAsync<OperationCanceledException>(async () => { await t; });
+        }
+
+
+        [Fact]
+        public async Task ReadOnlyWaitAsyncTest()
+        {
+            var rp = new AsyncReactiveProperty<int>(128);
+            var rrp = rp.ToReadOnlyAsyncReactiveProperty(CancellationToken.None);
+
+            var t = rrp.WaitAsync();
+            rp.Value = 99;
+            rp.Value = 100;
+            var v = await t;
+
+            v.Should().Be(99);
+        }
+
+
+        [Fact]
+        public async Task ReadOnlyWaitAsyncCancellationTest()
+        {
+            var cts = new CancellationTokenSource();
+
+            var rp = new AsyncReactiveProperty<int>(128);
+            var rrp = rp.ToReadOnlyAsyncReactiveProperty(CancellationToken.None);
+
+            var t = rrp.WaitAsync(cts.Token);
+
+            cts.Cancel();
+
+            rp.Value = 99;
+            rp.Value = 100;
+
+            await Assert.ThrowsAsync<OperationCanceledException>(async () => { await t; });
+        }
+
     }
 
 

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();
+        }
+    }
+
+
+}

src/UniTask.NetCoreTests/CompletionSourceTest.cs

@@ -0,0 +1,590 @@
+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 CompletionSourceTest
+    {
+        [Fact]
+        public async Task SetFirst()
+        {
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                tcs.TrySetResult();
+                await tcs.Task; // ok.
+                await tcs.Task; // ok.
+                tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                tcs.TrySetException(new TestException());
+
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+
+                tcs.Task.Status.Should().Be(UniTaskStatus.Faulted);
+            }
+
+            var cts = new CancellationTokenSource();
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                tcs.TrySetException(new OperationCanceledException(cts.Token));
+
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                tcs.TrySetCanceled(cts.Token);
+
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+        }
+
+        [Fact]
+        public async Task SingleOnFirst()
+        {
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+
+                tcs.TrySetResult();
+                await a;
+                await tcs.Task; // ok.
+                tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+
+                tcs.TrySetException(new TestException());
+                await Assert.ThrowsAsync<TestException>(async () => await a);
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Faulted);
+            }
+
+            var cts = new CancellationTokenSource();
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+
+                tcs.TrySetException(new OperationCanceledException(cts.Token));
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+
+                tcs.TrySetCanceled(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+        }
+
+        [Fact]
+        public async Task MultiOne()
+        {
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                tcs.TrySetResult();
+                await a;
+                await b;
+                await tcs.Task; // ok.
+                tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+
+                tcs.TrySetException(new TestException());
+                await Assert.ThrowsAsync<TestException>(async () => await a);
+                await Assert.ThrowsAsync<TestException>(async () => await b);
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Faulted);
+            }
+
+            var cts = new CancellationTokenSource();
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+
+                tcs.TrySetException(new OperationCanceledException(cts.Token));
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await b)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+
+                tcs.TrySetCanceled(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await b)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+        }
+
+        [Fact]
+        public async Task MultiTwo()
+        {
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                var c = Await();
+                tcs.TrySetResult();
+                await a;
+                await b;
+                await c;
+                await tcs.Task; // ok.
+                tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                var c = Await();
+
+                tcs.TrySetException(new TestException());
+                await Assert.ThrowsAsync<TestException>(async () => await a);
+                await Assert.ThrowsAsync<TestException>(async () => await b);
+                await Assert.ThrowsAsync<TestException>(async () => await c);
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Faulted);
+            }
+
+            var cts = new CancellationTokenSource();
+
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                var c = Await();
+
+                tcs.TrySetException(new OperationCanceledException(cts.Token));
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await b)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await c)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+            {
+                var tcs = new UniTaskCompletionSource();
+
+                async UniTask Await()
+                {
+                    await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                var c = Await();
+
+                tcs.TrySetCanceled(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await b)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await c)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+        }
+
+        class TestException : Exception
+        {
+
+        }
+    }
+
+    public class CompletionSourceTest2
+    {
+        [Fact]
+        public async Task SetFirst()
+        {
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                tcs.TrySetResult(10);
+                var a = await tcs.Task; // ok.
+                var b = await tcs.Task; // ok.
+                a.Should().Be(10);
+                b.Should().Be(10);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                tcs.TrySetException(new TestException());
+
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+
+                tcs.Task.Status.Should().Be(UniTaskStatus.Faulted);
+            }
+
+            var cts = new CancellationTokenSource();
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                tcs.TrySetException(new OperationCanceledException(cts.Token));
+
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                tcs.TrySetCanceled(cts.Token);
+
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+        }
+
+        [Fact]
+        public async Task SingleOnFirst()
+        {
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+
+                tcs.TrySetResult(10);
+                var r1 = await a;
+                var r2 = await tcs.Task; // ok.
+                r1.Should().Be(10);
+                r2.Should().Be(10);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+
+                tcs.TrySetException(new TestException());
+                await Assert.ThrowsAsync<TestException>(async () => await a);
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Faulted);
+            }
+
+            var cts = new CancellationTokenSource();
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+
+                tcs.TrySetException(new OperationCanceledException(cts.Token));
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+
+                tcs.TrySetCanceled(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+        }
+
+        [Fact]
+        public async Task MultiOne()
+        {
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                tcs.TrySetResult(10);
+                var r1 = await a;
+                var r2 = await b;
+                var r3 = await tcs.Task; // ok.
+                (r1, r2, r3).Should().Be((10, 10, 10));
+                tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+
+                tcs.TrySetException(new TestException());
+                await Assert.ThrowsAsync<TestException>(async () => await a);
+                await Assert.ThrowsAsync<TestException>(async () => await b);
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Faulted);
+            }
+
+            var cts = new CancellationTokenSource();
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+
+                tcs.TrySetException(new OperationCanceledException(cts.Token));
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await b)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+
+                tcs.TrySetCanceled(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await b)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+        }
+
+        [Fact]
+        public async Task MultiTwo()
+        {
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                var c = Await();
+                tcs.TrySetResult(10);
+                var r1 = await a;
+                var r2 = await b;
+                var r3 = await c;
+                var r4 = await tcs.Task; // ok.
+                (r1, r2, r3, r4).Should().Be((10, 10, 10, 10));
+                tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded);
+            }
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                var c = Await();
+
+                tcs.TrySetException(new TestException());
+                await Assert.ThrowsAsync<TestException>(async () => await a);
+                await Assert.ThrowsAsync<TestException>(async () => await b);
+                await Assert.ThrowsAsync<TestException>(async () => await c);
+                await Assert.ThrowsAsync<TestException>(async () => await tcs.Task);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Faulted);
+            }
+
+            var cts = new CancellationTokenSource();
+
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                var c = Await();
+
+                tcs.TrySetException(new OperationCanceledException(cts.Token));
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await b)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await c)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+            {
+                var tcs = new UniTaskCompletionSource<int>();
+
+                async UniTask<int> Await()
+                {
+                    return await tcs.Task;
+                }
+
+                var a = Await();
+                var b = Await();
+                var c = Await();
+
+                tcs.TrySetCanceled(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await a)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await b)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await c)).CancellationToken.Should().Be(cts.Token);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token);
+                tcs.Task.Status.Should().Be(UniTaskStatus.Canceled);
+            }
+        }
+
+        class TestException : Exception
+        {
+
+        }
+    }
+}

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();
+        }
+    }
+
+
+}

src/UniTask.NetCoreTests/Linq/CreateTest.cs

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

src/UniTask.NetCoreTests/Linq/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
+        {
+
+        }
     }
 }

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);
+        }
+
+
+    }
+}

src/UniTask.NetCoreTests/Linq/TakeInfinityTest.cs

@@ -4,6 +4,7 @@ using FluentAssertions;
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -40,5 +41,125 @@ namespace NetCoreTests.Linq
 
             (await xs).Should().BeEquivalentTo(1, 2, 3, 4);
         }
+
+        [Fact]
+        public async Task TakeUntilCanceled()
+        {
+            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 SkipUntilCanceled()
+        {
+            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[] { 20, 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.
+            }
+        }
+
+        [Fact]
+        public async Task TakeUntil()
+        {
+            var cts = new AsyncReactiveProperty<int>(0);
+
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.TakeUntil(cts.WaitAsync()).ToArrayAsync();
+
+            var c = CancelAsync();
+
+            await c;
+            var foo = await xs;
+
+            foo.Should().BeEquivalentTo(new[] { 1, 10, 20 });
+
+            async Task CancelAsync()
+            {
+                rp.Value = 10;
+                await Task.Yield();
+                rp.Value = 20;
+                await Task.Yield();
+                cts.Value = 9999;
+                rp.Value = 30;
+                await Task.Yield();
+                rp.Value = 40;
+            }
+        }
+
+        [Fact]
+        public async Task SkipUntil()
+        {
+            var cts = new AsyncReactiveProperty<int>(0);
+
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.SkipUntil(cts.WaitAsync()).ToArrayAsync();
+
+            var c = CancelAsync();
+
+            await c;
+            var foo = await xs;
+
+            foo.Should().BeEquivalentTo(new[] { 20, 30, 40 });
+
+            async Task CancelAsync()
+            {
+                rp.Value = 10;
+                await Task.Yield();
+                rp.Value = 20;
+                await Task.Yield();
+                cts.Value = 9999;
+                rp.Value = 30;
+                await Task.Yield();
+                rp.Value = 40;
+
+                rp.Dispose(); // complete.
+            }
+        }
     }
 }

src/UniTask.NetCoreTests/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);
+        }
+    }
+}

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();
+        }
+    }
+
+
+}

src/UniTask.NetCoreTests/WithCancellationTest.cs

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

src/UniTask/Assets/Editor/EditorRunnerChecker.cs

@@ -0,0 +1,31 @@
+#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));
+        await UniTask.Yield();
+
+        Debug.Log("End");
+    }
+}
+
+#endif

src/UniTask/Assets/Editor/EditorRunnerChecker.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: fcb1f7467a3e2b64c8a016c8aee2f9b4
+guid: e51b78c06cb410f42b36e0af9de3b065
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

src/UniTask/Assets/Plugins/UniTask/Editor/UniTask.Editor.asmdef

@@ -10,7 +10,7 @@
     "allowUnsafeCode": false,
     "overrideReferences": false,
     "precompiledReferences": [],
-    "autoReferenced": true,
+    "autoReferenced": false,
     "defineConstraints": [],
     "versionDefines": [],
     "noEngineReferences": false

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

@@ -7,113 +7,239 @@ namespace Cysharp.Threading.Tasks
 {
     public class AsyncLazy
     {
-        Func<UniTask> valueFactory;
-        UniTask target;
+        static Action<object> continuation = SetCompletionSource;
+
+        Func<UniTask> taskFactory;
+        UniTaskCompletionSource completionSource;
+        UniTask.Awaiter awaiter;
+
         object syncLock;
         bool initialized;
 
-        public AsyncLazy(Func<UniTask> valueFactory)
+        public AsyncLazy(Func<UniTask> taskFactory)
         {
-            this.valueFactory = valueFactory;
-            this.target = default;
+            this.taskFactory = taskFactory;
+            this.completionSource = new UniTaskCompletionSource();
             this.syncLock = new object();
             this.initialized = false;
         }
 
-        internal AsyncLazy(UniTask value)
+        internal AsyncLazy(UniTask task)
         {
-            this.valueFactory = null;
-            this.target = value;
+            this.taskFactory = null;
+            this.completionSource = new UniTaskCompletionSource();
             this.syncLock = null;
             this.initialized = true;
+
+            var awaiter = task.GetAwaiter();
+            if (awaiter.IsCompleted)
+            {
+                SetCompletionSource(awaiter);
+            }
+            else
+            {
+                this.awaiter = awaiter;
+                awaiter.SourceOnCompleted(continuation, this);
+            }
         }
 
-        public UniTask Task => EnsureInitialized();
+        public UniTask Task
+        {
+            get
+            {
+                EnsureInitialized();
+                return completionSource.Task;
+            }
+        }
 
-        public UniTask.Awaiter GetAwaiter() => EnsureInitialized().GetAwaiter();
 
-        UniTask EnsureInitialized()
+        public UniTask.Awaiter GetAwaiter() => Task.GetAwaiter();
+
+        void EnsureInitialized()
         {
             if (Volatile.Read(ref initialized))
             {
-                return target;
+                return;
             }
 
-            return EnsureInitializedCore();
+            EnsureInitializedCore();
         }
 
-        UniTask EnsureInitializedCore()
+        void EnsureInitializedCore()
         {
             lock (syncLock)
             {
                 if (!Volatile.Read(ref initialized))
                 {
-                    var f = Interlocked.Exchange(ref valueFactory, null);
+                    var f = Interlocked.Exchange(ref taskFactory, null);
                     if (f != null)
                     {
-                        target = f().Preserve(); // with preserve(allow multiple await).
+                        var task = f();
+                        var awaiter = task.GetAwaiter();
+                        if (awaiter.IsCompleted)
+                        {
+                            SetCompletionSource(awaiter);
+                        }
+                        else
+                        {
+                            this.awaiter = awaiter;
+                            awaiter.SourceOnCompleted(continuation, this);
+                        }
+
                         Volatile.Write(ref initialized, true);
                     }
                 }
             }
+        }
 
-            return target;
+        void SetCompletionSource(in UniTask.Awaiter awaiter)
+        {
+            try
+            {
+                awaiter.GetResult();
+                completionSource.TrySetResult();
+            }
+            catch (Exception ex)
+            {
+                completionSource.TrySetException(ex);
+            }
+        }
+
+        static void SetCompletionSource(object state)
+        {
+            var self = (AsyncLazy)state;
+            try
+            {
+                self.awaiter.GetResult();
+                self.completionSource.TrySetResult();
+            }
+            catch (Exception ex)
+            {
+                self.completionSource.TrySetException(ex);
+            }
+            finally
+            {
+                self.awaiter = default;
+            }
         }
     }
 
     public class AsyncLazy<T>
     {
-        Func<UniTask<T>> valueFactory;
-        UniTask<T> target;
+        static Action<object> continuation = SetCompletionSource;
+
+        Func<UniTask<T>> taskFactory;
+        UniTaskCompletionSource<T> completionSource;
+        UniTask<T>.Awaiter awaiter;
+
         object syncLock;
         bool initialized;
 
-        public AsyncLazy(Func<UniTask<T>> valueFactory)
+        public AsyncLazy(Func<UniTask<T>> taskFactory)
         {
-            this.valueFactory = valueFactory;
-            this.target = default;
+            this.taskFactory = taskFactory;
+            this.completionSource = new UniTaskCompletionSource<T>();
             this.syncLock = new object();
             this.initialized = false;
         }
 
-        internal AsyncLazy(UniTask<T> value)
+        internal AsyncLazy(UniTask<T> task)
         {
-            this.valueFactory = null;
-            this.target = value;
+            this.taskFactory = null;
+            this.completionSource = new UniTaskCompletionSource<T>();
             this.syncLock = null;
             this.initialized = true;
+
+            var awaiter = task.GetAwaiter();
+            if (awaiter.IsCompleted)
+            {
+                SetCompletionSource(awaiter);
+            }
+            else
+            {
+                this.awaiter = awaiter;
+                awaiter.SourceOnCompleted(continuation, this);
+            }
         }
 
-        public UniTask<T> Task => EnsureInitialized();
+        public UniTask<T> Task
+        {
+            get
+            {
+                EnsureInitialized();
+                return completionSource.Task;
+            }
+        }
 
-        public UniTask<T>.Awaiter GetAwaiter() => EnsureInitialized().GetAwaiter();
 
-        UniTask<T> EnsureInitialized()
+        public UniTask<T>.Awaiter GetAwaiter() => Task.GetAwaiter();
+
+        void EnsureInitialized()
         {
             if (Volatile.Read(ref initialized))
             {
-                return target;
+                return;
             }
 
-            return EnsureInitializedCore();
+            EnsureInitializedCore();
         }
 
-        UniTask<T> EnsureInitializedCore()
+        void EnsureInitializedCore()
         {
             lock (syncLock)
             {
                 if (!Volatile.Read(ref initialized))
                 {
-                    var f = Interlocked.Exchange(ref valueFactory, null);
+                    var f = Interlocked.Exchange(ref taskFactory, null);
                     if (f != null)
                     {
-                        target = f().Preserve(); // with preserve(allow multiple await).
+                        var task = f();
+                        var awaiter = task.GetAwaiter();
+                        if (awaiter.IsCompleted)
+                        {
+                            SetCompletionSource(awaiter);
+                        }
+                        else
+                        {
+                            this.awaiter = awaiter;
+                            awaiter.SourceOnCompleted(continuation, this);
+                        }
+
                         Volatile.Write(ref initialized, true);
                     }
                 }
             }
+        }
 
-            return target;
+        void SetCompletionSource(in UniTask<T>.Awaiter awaiter)
+        {
+            try
+            {
+                var result = awaiter.GetResult();
+                completionSource.TrySetResult(result);
+            }
+            catch (Exception ex)
+            {
+                completionSource.TrySetException(ex);
+            }
+        }
+
+        static void SetCompletionSource(object state)
+        {
+            var self = (AsyncLazy<T>)state;
+            try
+            {
+                var result = self.awaiter.GetResult();
+                self.completionSource.TrySetResult(result);
+            }
+            catch (Exception ex)
+            {
+                self.completionSource.TrySetException(ex);
+            }
+            finally
+            {
+                self.awaiter = default;
+            }
         }
     }
 }

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

@@ -1,15 +1,16 @@
-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();
+        UniTask<T> WaitAsync(CancellationToken cancellationToken = default);
     }
 
-    public interface IAsyncReactiveProperty<T> : IAsyncReadOnlyReactiveProperty<T>
+    public interface IAsyncReactiveProperty<T> : IReadOnlyAsyncReactiveProperty<T>
     {
         new T Value { get; set; }
     }
@@ -55,10 +56,162 @@ namespace Cysharp.Threading.Tasks
 
         public void Dispose()
         {
-            triggerEvent.SetCanceled(CancellationToken.None);
+            triggerEvent.SetCompleted();
         }
 
-        class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable<T>
+        public static implicit operator T(AsyncReactiveProperty<T> value)
+        {
+            return value.Value;
+        }
+
+        public override string ToString()
+        {
+            if (isValueType) return latestValue.ToString();
+            return latestValue?.ToString();
+        }
+
+        public UniTask<T> WaitAsync(CancellationToken cancellationToken = default)
+        {
+            return new UniTask<T>(WaitAsyncSource.Create(this, cancellationToken, out var token), token);
+        }
+
+        static bool isValueType;
+
+        static AsyncReactiveProperty()
+        {
+            isValueType = typeof(T).IsValueType;
+        }
+
+        sealed class WaitAsyncSource : IUniTaskSource<T>, ITriggerHandler<T>, ITaskPoolNode<WaitAsyncSource>
+        {
+            static Action<object> cancellationCallback = CancellationCallback;
+
+            static TaskPool<WaitAsyncSource> pool;
+            WaitAsyncSource nextNode;
+            ref WaitAsyncSource ITaskPoolNode<WaitAsyncSource>.NextNode => ref nextNode;
+
+            static WaitAsyncSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(WaitAsyncSource), () => pool.Size);
+            }
+
+            AsyncReactiveProperty<T> parent;
+            CancellationToken cancellationToken;
+            CancellationTokenRegistration cancellationTokenRegistration;
+            UniTaskCompletionSourceCore<T> core;
+
+            WaitAsyncSource()
+            {
+            }
+
+            public static IUniTaskSource<T> Create(AsyncReactiveProperty<T> parent, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<T>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new WaitAsyncSource();
+                }
+
+                result.parent = parent;
+                result.cancellationToken = cancellationToken;
+
+                if (cancellationToken.CanBeCanceled)
+                {
+                    result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, result);
+                }
+
+                result.parent.triggerEvent.Add(result);
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                cancellationTokenRegistration.Dispose();
+                cancellationTokenRegistration = default;
+                parent.triggerEvent.Remove(this);
+                parent = null;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (WaitAsyncSource)state;
+                self.OnCanceled(self.cancellationToken);
+            }
+
+            // IUniTaskSource
+
+            public T GetResult(short token)
+            {
+                try
+                {
+                    return core.GetResult(token);
+                }
+                finally
+                {
+                    TryReturn();
+                }
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            // ITriggerHandler
+
+            ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }
+            ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }
+
+            public void OnCanceled(CancellationToken cancellationToken)
+            {
+                core.TrySetCanceled(cancellationToken);
+            }
+
+            public void OnCompleted()
+            {
+                // Complete as Cancel.
+                core.TrySetCanceled(CancellationToken.None);
+            }
+
+            public void OnError(Exception ex)
+            {
+                core.TrySetException(ex);
+            }
+
+            public void OnNext(T value)
+            {
+                core.TrySetResult(value);
+            }
+        }
+
+        sealed class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable<T>
         {
             readonly AsyncReactiveProperty<T> parent;
 
@@ -73,7 +226,7 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, IResolveCancelPromise<T>
+        sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, ITriggerHandler<T>
         {
             static Action<object> cancellationCallback = CancellationCallback;
 
@@ -101,6 +254,9 @@ 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.
@@ -127,17 +283,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)
@@ -147,4 +311,334 @@ 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();
+        }
+
+        public UniTask<T> WaitAsync(CancellationToken cancellationToken = default)
+        {
+            return new UniTask<T>(WaitAsyncSource.Create(this, cancellationToken, out var token), token);
+        }
+
+        static bool isValueType;
+
+        static ReadOnlyAsyncReactiveProperty()
+        {
+            isValueType = typeof(T).IsValueType;
+        }
+
+        sealed class WaitAsyncSource : IUniTaskSource<T>, ITriggerHandler<T>, ITaskPoolNode<WaitAsyncSource>
+        {
+            static Action<object> cancellationCallback = CancellationCallback;
+
+            static TaskPool<WaitAsyncSource> pool;
+            WaitAsyncSource nextNode;
+            ref WaitAsyncSource ITaskPoolNode<WaitAsyncSource>.NextNode => ref nextNode;
+
+            static WaitAsyncSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(WaitAsyncSource), () => pool.Size);
+            }
+
+            ReadOnlyAsyncReactiveProperty<T> parent;
+            CancellationToken cancellationToken;
+            CancellationTokenRegistration cancellationTokenRegistration;
+            UniTaskCompletionSourceCore<T> core;
+
+            WaitAsyncSource()
+            {
+            }
+
+            public static IUniTaskSource<T> Create(ReadOnlyAsyncReactiveProperty<T> parent, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<T>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new WaitAsyncSource();
+                }
+
+                result.parent = parent;
+                result.cancellationToken = cancellationToken;
+
+                if (cancellationToken.CanBeCanceled)
+                {
+                    result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, result);
+                }
+
+                result.parent.triggerEvent.Add(result);
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                cancellationTokenRegistration.Dispose();
+                cancellationTokenRegistration = default;
+                parent.triggerEvent.Remove(this);
+                parent = null;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (WaitAsyncSource)state;
+                self.OnCanceled(self.cancellationToken);
+            }
+
+            // IUniTaskSource
+
+            public T GetResult(short token)
+            {
+                try
+                {
+                    return core.GetResult(token);
+                }
+                finally
+                {
+                    TryReturn();
+                }
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            // ITriggerHandler
+
+            ITriggerHandler<T> ITriggerHandler<T>.Prev { get; set; }
+            ITriggerHandler<T> ITriggerHandler<T>.Next { get; set; }
+
+            public void OnCanceled(CancellationToken cancellationToken)
+            {
+                core.TrySetCanceled(cancellationToken);
+            }
+
+            public void OnCompleted()
+            {
+                // Complete as Cancel.
+                core.TrySetCanceled(CancellationToken.None);
+            }
+
+            public void OnError(Exception ex)
+            {
+                core.TrySetException(ex);
+            }
+
+            public void OnNext(T value)
+            {
+                core.TrySetResult(value);
+            }
+        }
+
+        sealed 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);
+        }
+    }
+}

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

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
@@ -8,16 +9,66 @@ namespace Cysharp.Threading.Tasks
     public static class CancellationTokenExtensions
     {
         static readonly Action<object> cancellationTokenCallback = Callback;
+        static readonly Action<object> disposeCallback = DisposeCallback;
 
-        public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cts)
+        public static CancellationToken ToCancellationToken(this UniTask task)
         {
-            if (cts.IsCancellationRequested)
+            var cts = new CancellationTokenSource();
+            ToCancellationTokenCore(task, cts).Forget();
+            return cts.Token;
+        }
+
+        public static CancellationToken ToCancellationToken(this UniTask task, CancellationToken linkToken)
+        {
+            if (linkToken.IsCancellationRequested)
             {
-                return (UniTask.FromCanceled(cts), default(CancellationTokenRegistration));
+                return linkToken;
+            }
+
+            if (!linkToken.CanBeCanceled)
+            {
+                return ToCancellationToken(task);
+            }
+
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(linkToken);
+            ToCancellationTokenCore(task, cts).Forget();
+
+            return cts.Token;
+        }
+
+        public static CancellationToken ToCancellationToken<T>(this UniTask<T> task)
+        {
+            return ToCancellationToken(task.AsUniTask());
+        }
+
+        public static CancellationToken ToCancellationToken<T>(this UniTask<T> task, CancellationToken linkToken)
+        {
+            return ToCancellationToken(task.AsUniTask(), linkToken);
+        }
+
+        static async UniTaskVoid ToCancellationTokenCore(UniTask task, CancellationTokenSource cts)
+        {
+            try
+            {
+                await task;
+            }
+            catch (Exception ex)
+            {
+                UniTaskScheduler.PublishUnobservedTaskException(ex);
+            }
+            cts.Cancel();
+            cts.Dispose();
+        }
+
+        public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                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 +77,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;
@@ -69,6 +125,58 @@ namespace Cysharp.Threading.Tasks
                 }
             }
         }
+
+        public static CancellationTokenRegistration AddTo(this IDisposable disposable, CancellationToken cancellationToken)
+        {
+            return cancellationToken.RegisterWithoutCaptureExecutionContext(disposeCallback, disposable);
+        }
+
+        static void DisposeCallback(object state)
+        {
+            var d = (IDisposable)state;
+            d.Dispose();
+        }
+    }
+
+    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);
+            }
+        }
     }
 }
 

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

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

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

@@ -91,7 +91,8 @@ namespace Cysharp.Threading.Tasks
     {
         readonly Queue<T> items;
         readonly SingleConsumerUnboundedChannelReader readerSource;
-        readonly UniTaskCompletionSource completedTask;
+        UniTaskCompletionSource completedTaskSource;
+        UniTask completedTask;
 
         Exception completionError;
         bool closed;
@@ -99,7 +100,6 @@ namespace Cysharp.Threading.Tasks
         public SingleConsumerUnboundedChannel()
         {
             items = new Queue<T>();
-            completedTask = new UniTaskCompletionSource();
             Writer = new SingleConsumerUnboundedChannelWriter(this);
             readerSource = new SingleConsumerUnboundedChannelReader(this);
             Reader = readerSource;
@@ -146,11 +146,25 @@ namespace Cysharp.Threading.Tasks
                     {
                         if (error == null)
                         {
-                            parent.completedTask.TrySetResult();
+                            if (parent.completedTaskSource != null)
+                            {
+                                parent.completedTaskSource.TrySetResult();
+                            }
+                            else
+                            {
+                                parent.completedTask = UniTask.CompletedTask;
+                            }
                         }
                         else
                         {
-                            parent.completedTask.TrySetException(error);
+                            if (parent.completedTaskSource != null)
+                            {
+                                parent.completedTaskSource.TrySetException(error);
+                            }
+                            else
+                            {
+                                parent.completedTask = UniTask.FromException(error);
+                            }
                         }
 
                         if (waiting)
@@ -179,9 +193,25 @@ namespace Cysharp.Threading.Tasks
             public SingleConsumerUnboundedChannelReader(SingleConsumerUnboundedChannel<T> parent)
             {
                 this.parent = parent;
+
+                TaskTracker.TrackActiveTask(this, 4);
             }
 
-            public override UniTask Completion => parent.completedTask.Task;
+            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)
             {
@@ -196,11 +226,25 @@ namespace Cysharp.Threading.Tasks
                         {
                             if (parent.completionError != null)
                             {
-                                parent.completedTask.TrySetException(parent.completionError);
+                                if (parent.completedTaskSource != null)
+                                {
+                                    parent.completedTaskSource.TrySetException(parent.completionError);
+                                }
+                                else
+                                {
+                                    parent.completedTask = UniTask.FromException(parent.completionError);
+                                }
                             }
                             else
                             {
-                                parent.completedTask.TrySetResult();
+                                if (parent.completedTaskSource != null)
+                                {
+                                    parent.completedTaskSource.TrySetResult();
+                                }
+                                else
+                                {
+                                    parent.completedTask = UniTask.CompletedTask;
+                                }
                             }
                         }
                     }
@@ -262,6 +306,7 @@ namespace Cysharp.Threading.Tasks
 
             public void SingalCancellation(CancellationToken cancellationToken)
             {
+                TaskTracker.RemoveTracking(this);
                 core.TrySetCanceled(cancellationToken);
             }
 
@@ -269,10 +314,12 @@ namespace Cysharp.Threading.Tasks
             {
                 if (error != null)
                 {
+                    TaskTracker.RemoveTracking(this);
                     core.TrySetException(error);
                 }
                 else
                 {
+                    TaskTracker.RemoveTracking(this);
                     core.TrySetResult(false);
                 }
             }
@@ -321,8 +368,8 @@ namespace Cysharp.Threading.Tasks
                 readonly SingleConsumerUnboundedChannelReader parent;
                 CancellationToken cancellationToken1;
                 CancellationToken cancellationToken2;
-                CancellationTokenRegistration CancellationTokenRegistration1;
-                CancellationTokenRegistration CancellationTokenRegistration2;
+                CancellationTokenRegistration cancellationTokenRegistration1;
+                CancellationTokenRegistration cancellationTokenRegistration2;
 
                 T current;
                 bool cacheValue;
@@ -348,12 +395,12 @@ namespace Cysharp.Threading.Tasks
 
                     if (this.cancellationToken1.CanBeCanceled)
                     {
-                        this.cancellationToken1.RegisterWithoutCaptureExecutionContext(CancellationCallback1Delegate, this);
+                        this.cancellationTokenRegistration1 =  this.cancellationToken1.RegisterWithoutCaptureExecutionContext(CancellationCallback1Delegate, this);
                     }
 
                     if (this.cancellationToken2.CanBeCanceled)
                     {
-                        this.cancellationToken2.RegisterWithoutCaptureExecutionContext(CancellationCallback2Delegate, this);
+                        this.cancellationTokenRegistration2 = this.cancellationToken2.RegisterWithoutCaptureExecutionContext(CancellationCallback2Delegate, this);
                     }
 
                     running = true;
@@ -381,8 +428,8 @@ namespace Cysharp.Threading.Tasks
 
                 public UniTask DisposeAsync()
                 {
-                    CancellationTokenRegistration1.Dispose();
-                    CancellationTokenRegistration2.Dispose();
+                    cancellationTokenRegistration1.Dispose();
+                    cancellationTokenRegistration2.Dispose();
                     return default;
                 }
 

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;
+        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 stateMachine, ref runnerPromise);
             }
 
-            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 stateMachine, ref runnerPromise);
             }
 
-            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;
+        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 stateMachine, ref runnerPromise);
             }
 
-            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 stateMachine, ref runnerPromise);
             }
 
-            awaiter.OnCompleted(runner.CallMoveNext);
+            awaiter.UnsafeOnCompleted(runnerPromise.MoveNext);
         }
 
         // 7. Start
         [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Start<TStateMachine>(ref TStateMachine stateMachine)
             where TStateMachine : IAsyncStateMachine
         {

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;
+        IStateMachineRunner runner;
 
         // 1. Static Create method.
         [DebuggerHidden]
@@ -33,12 +35,18 @@ namespace Cysharp.Threading.Tasks.CompilerServices
 
         // 3. SetException
         [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetException(Exception exception)
         {
             // runner is finished, return first.
             if (runner != null)
             {
+#if ENABLE_IL2CPP
+                // workaround for IL2CPP bug.
+                PlayerLoopHelper.AddContinuation(PlayerLoopTiming.LastPostLateUpdate, runner.ReturnAction);
+#else
                 runner.Return();
+#endif
                 runner = null;
             }
 
@@ -47,43 +55,51 @@ namespace Cysharp.Threading.Tasks.CompilerServices
 
         // 4. SetResult
         [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetResult()
         {
             // runner is finished, return.
             if (runner != null)
             {
+#if ENABLE_IL2CPP
+                // workaround for IL2CPP bug.
+                PlayerLoopHelper.AddContinuation(PlayerLoopTiming.LastPostLateUpdate, runner.ReturnAction);
+#else
                 runner.Return();
+#endif
                 runner = null;
             }
         }
 
         // 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 stateMachine, ref runner);
             }
 
-            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 stateMachine, ref runner);
             }
 
-            awaiter.OnCompleted(runner.CallMoveNext);
+            awaiter.UnsafeOnCompleted(runner.MoveNext);
         }
 
         // 7. Start

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;
-        }
-    }
-}
-

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

@@ -0,0 +1,380 @@
+#pragma warning disable CS1591
+
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Linq;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.CompilerServices
+{
+    // #ENABLE_IL2CPP in this file is to avoid bug of IL2CPP VM.
+    // Issue is tracked on https://issuetracker.unity3d.com/issues/il2cpp-incorrect-results-when-calling-a-method-from-outside-class-in-a-struct
+    // but currently it is labeled `Won't Fix`.
+
+    internal interface IStateMachineRunner
+    {
+        Action MoveNext { get; }
+        void Return();
+
+#if ENABLE_IL2CPP
+        Action ReturnAction { get; }
+#endif
+    }
+
+    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 static class StateMachineUtility
+    {
+        // Get AsyncStateMachine internal state to check IL2CPP bug
+        public static int GetState(IAsyncStateMachine stateMachine)
+        {
+            var info = stateMachine.GetType().GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
+                .First(x => x.Name.EndsWith("__state"));
+            return (int)info.GetValue(stateMachine);
+        }
+    }
+
+    internal sealed class AsyncUniTaskVoid<TStateMachine> : IStateMachineRunner, ITaskPoolNode<AsyncUniTaskVoid<TStateMachine>>, IUniTaskSource
+        where TStateMachine : IAsyncStateMachine
+    {
+        static TaskPool<AsyncUniTaskVoid<TStateMachine>> pool;
+
+#if ENABLE_IL2CPP
+        public Action ReturnAction { get; }
+#endif
+
+        TStateMachine stateMachine;
+
+        public Action MoveNext { get; }
+
+        public AsyncUniTaskVoid()
+        {
+            MoveNext = Run;
+#if ENABLE_IL2CPP
+            ReturnAction = Return;
+#endif
+        }
+
+        public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunner runnerFieldRef)
+        {
+            if (!pool.TryPop(out var result))
+            {
+                result = new AsyncUniTaskVoid<TStateMachine>();
+            }
+            TaskTracker.TrackActiveTask(result, 3);
+
+            runnerFieldRef = result; // set runner before copied.
+            result.stateMachine = stateMachine; // copy struct StateMachine(in release build).
+        }
+
+        static AsyncUniTaskVoid()
+        {
+            TaskPool.RegisterSizeGetter(typeof(AsyncUniTaskVoid<TStateMachine>), () => pool.Size);
+        }
+
+        AsyncUniTaskVoid<TStateMachine> nextNode;
+        public ref AsyncUniTaskVoid<TStateMachine> NextNode => ref nextNode;
+
+        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;
+
+#if ENABLE_IL2CPP
+        readonly Action returnDelegate;  
+#endif
+        public Action MoveNext { get; }
+
+        TStateMachine stateMachine;
+        UniTaskCompletionSourceCore<AsyncUnit> core;
+
+        AsyncUniTask()
+        {
+            MoveNext = Run;
+#if ENABLE_IL2CPP
+            returnDelegate = Return;
+#endif
+        }
+
+        public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunnerPromise runnerPromiseFieldRef)
+        {
+            if (!pool.TryPop(out var result))
+            {
+                result = new AsyncUniTask<TStateMachine>();
+            }
+            TaskTracker.TrackActiveTask(result, 3);
+
+            runnerPromiseFieldRef = result; // set runner before copied.
+            result.stateMachine = stateMachine; // copy struct StateMachine(in release build).
+        }
+
+        AsyncUniTask<TStateMachine> nextNode;
+        public ref AsyncUniTask<TStateMachine> NextNode => ref nextNode;
+
+        static AsyncUniTask()
+        {
+            TaskPool.RegisterSizeGetter(typeof(AsyncUniTask<TStateMachine>), () => pool.Size);
+        }
+
+        void Return()
+        {
+            TaskTracker.RemoveTracking(this);
+            core.Reset();
+            stateMachine = default;
+            pool.TryPush(this);
+        }
+
+        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
+            {
+#if ENABLE_IL2CPP
+                // workaround for IL2CPP bug.
+                PlayerLoopHelper.AddContinuation(PlayerLoopTiming.LastPostLateUpdate, returnDelegate);
+#else
+                TryReturn();
+#endif
+            }
+        }
+
+        [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);
+        }
+    }
+
+    internal sealed class AsyncUniTask<TStateMachine, T> : IStateMachineRunnerPromise<T>, IUniTaskSource<T>, ITaskPoolNode<AsyncUniTask<TStateMachine, T>>
+        where TStateMachine : IAsyncStateMachine
+    {
+        static TaskPool<AsyncUniTask<TStateMachine, T>> pool;
+
+#if ENABLE_IL2CPP
+        readonly Action returnDelegate;  
+#endif
+
+        public Action MoveNext { get; }
+
+        TStateMachine stateMachine;
+        UniTaskCompletionSourceCore<T> core;
+
+        AsyncUniTask()
+        {
+            MoveNext = Run;
+#if ENABLE_IL2CPP
+            returnDelegate = Return;
+#endif
+        }
+
+        public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunnerPromise<T> runnerPromiseFieldRef)
+        {
+            if (!pool.TryPop(out var result))
+            {
+                result = new AsyncUniTask<TStateMachine, T>();
+            }
+            TaskTracker.TrackActiveTask(result, 3);
+
+            runnerPromiseFieldRef = result; // set runner before copied.
+            result.stateMachine = stateMachine; // copy struct StateMachine(in release build).
+        }
+
+        AsyncUniTask<TStateMachine, T> nextNode;
+        public ref AsyncUniTask<TStateMachine, T> NextNode => ref nextNode;
+
+        static AsyncUniTask()
+        {
+            TaskPool.RegisterSizeGetter(typeof(AsyncUniTask<TStateMachine, T>), () => pool.Size);
+        }
+
+        void Return()
+        {
+            TaskTracker.RemoveTracking(this);
+            core.Reset();
+            stateMachine = default;
+            pool.TryPush(this);
+        }
+
+        bool TryReturn()
+        {
+            TaskTracker.RemoveTracking(this);
+            core.Reset();
+            stateMachine = default;
+            return pool.TryPush(this);
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void Run()
+        {
+            // UnityEngine.Debug.Log($"MoveNext State:" + StateMachineUtility.GetState(stateMachine));
+            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
+            {
+#if ENABLE_IL2CPP
+                // workaround for IL2CPP bug.
+                PlayerLoopHelper.AddContinuation(PlayerLoopTiming.LastPostLateUpdate, returnDelegate);
+#else
+                TryReturn();
+#endif
+            }
+        }
+
+        [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);
+        }
+    }
+}
+

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

@@ -12,27 +12,55 @@ namespace Cysharp.Threading.Tasks
 {
     public static class EnumeratorAsyncExtensions
     {
-        public static UniTask.Awaiter GetAwaiter(this IEnumerator enumerator)
+        public static UniTask.Awaiter GetAwaiter<T>(this T enumerator)
+            where T : IEnumerator
         {
-            return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, CancellationToken.None, out var token), token).GetAwaiter();
+            var e = (IEnumerator)enumerator;
+            Error.ThrowArgumentNullException(e, nameof(enumerator));
+            return new UniTask(EnumeratorPromise.Create(e, 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
+        public static UniTask ToUniTask(this IEnumerator enumerator, MonoBehaviour coroutineRunner)
         {
-            static readonly PromisePool<EnumeratorPromise> pool = new PromisePool<EnumeratorPromise>();
+            var source = AutoResetUniTaskCompletionSource.Create();
+            coroutineRunner.StartCoroutine(Core(enumerator, coroutineRunner, source));
+            return source.Task;
+        }
+
+        static IEnumerator Core(IEnumerator inner, MonoBehaviour coroutineRunner, AutoResetUniTaskCompletionSource source)
+        {
+            yield return coroutineRunner.StartCoroutine(inner);
+            source.TrySetResult();
+        }
+
+        sealed class EnumeratorPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<EnumeratorPromise>
+        {
+            static TaskPool<EnumeratorPromise> pool;
+            EnumeratorPromise nextNode;
+            public ref EnumeratorPromise NextNode => ref nextNode;
+
+            static EnumeratorPromise()
+            {
+                TaskPool.RegisterSizeGetter(typeof(EnumeratorPromise), () => pool.Size);
+            }
 
             IEnumerator innerEnumerator;
             CancellationToken cancellationToken;
+            int initialFrame;
+            bool loopRunning;
+            bool calledGetResult;
 
             UniTaskCompletionSourceCore<object> core;
 
@@ -47,16 +75,26 @@ 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);
+                result.loopRunning = true;
+                result.calledGetResult = false;
+                result.initialFrame = -1;
 
                 token = result.core.Version;
+
+                // run immediately.
+                if (result.MoveNext())
+                {
+                    PlayerLoopHelper.AddAction(timing, result);
+                }
+                
                 return result;
             }
 
@@ -64,12 +102,15 @@ namespace Cysharp.Threading.Tasks
             {
                 try
                 {
-                    TaskTracker.RemoveTracking(this);
+                    calledGetResult = true;
                     core.GetResult(token);
                 }
                 finally
                 {
-                    pool.TryReturn(this);
+                    if (!loopRunning)
+                    {
+                        TryReturn();
+                    }
                 }
             }
 
@@ -90,12 +131,38 @@ namespace Cysharp.Threading.Tasks
 
             public bool MoveNext()
             {
+                if (calledGetResult)
+                {
+                    loopRunning = false;
+                    TryReturn();
+                    return false;
+                }
+
+                if (innerEnumerator == null) // invalid status, returned but loop running?
+                {
+                    return false;
+                }
+
                 if (cancellationToken.IsCancellationRequested)
                 {
+                    loopRunning = false;
                     core.TrySetCanceled(cancellationToken);
                     return false;
                 }
 
+                if (initialFrame == -1)
+                {
+                    // Time can not touch in threadpool.
+                    if (PlayerLoopHelper.IsMainThread)
+                    {
+                        initialFrame = Time.frameCount;
+                    }
+                }
+                else if (initialFrame == Time.frameCount)
+                {
+                    return true; // already executed in first frame, skip.
+                }
+
                 try
                 {
                     if (innerEnumerator.MoveNext())
@@ -105,27 +172,24 @@ namespace Cysharp.Threading.Tasks
                 }
                 catch (Exception ex)
                 {
+                    loopRunning = false;
                     core.TrySetException(ex);
                     return false;
                 }
 
+                loopRunning = false;
                 core.TrySetResult(null);
                 return false;
             }
 
-            public void Reset()
+            bool TryReturn()
             {
+                TaskTracker.RemoveTracking(this);
                 core.Reset();
                 innerEnumerator = default;
                 cancellationToken = default;
-            }
 
-            ~EnumeratorPromise()
-            {
-                if (pool.TryReturn(this))
-                {
-                    GC.ReRegisterForFinalize(this);
-                }
+                return pool.TryPush(this);
             }
 
             // Unwrap YieldInstructions
@@ -139,11 +203,10 @@ namespace Cysharp.Threading.Tasks
                     {
                         yield return null;
                     }
-                    else if (current is CustomYieldInstruction)
+                    else if (current is CustomYieldInstruction cyi)
                     {
                         // WWW, WaitForSecondsRealtime
-                        var e2 = UnwrapWaitCustomYieldInstruction((CustomYieldInstruction)current);
-                        while (e2.MoveNext())
+                        while (cyi.keepWaiting)
                         {
                             yield return null;
                         }
@@ -169,7 +232,7 @@ namespace Cysharp.Threading.Tasks
                         }
                         else
                         {
-                            yield return null;
+                            goto WARN;
                         }
                     }
                     else if (current is IEnumerator e3)
@@ -182,17 +245,14 @@ namespace Cysharp.Threading.Tasks
                     }
                     else
                     {
-                        // WaitForEndOfFrame, WaitForFixedUpdate, others.
-                        yield return null;
+                        goto WARN;
                     }
-                }
-            }
 
-            // WWW and others as CustomYieldInstruction.
-            static IEnumerator UnwrapWaitCustomYieldInstruction(CustomYieldInstruction yieldInstruction)
-            {
-                while (yieldInstruction.keepWaiting)
-                {
+                    continue;
+
+                    WARN:
+                    // WaitForEndOfFrame, WaitForFixedUpdate, others.
+                    UnityEngine.Debug.LogWarning($"yield {current.GetType().Name} is not supported on await IEnumerator or IEnumerator.ToUniTask(), please use ToUniTask(MonoBehaviour coroutineRunner) instead.");
                     yield return null;
                 }
             }
@@ -202,12 +262,12 @@ namespace Cysharp.Threading.Tasks
             static IEnumerator UnwrapWaitForSeconds(WaitForSeconds waitForSeconds)
             {
                 var second = (float)waitForSeconds_Seconds.GetValue(waitForSeconds);
-                var startTime = DateTimeOffset.UtcNow;
+                var elapsed = 0.0f;
                 while (true)
                 {
                     yield return null;
 
-                    var elapsed = (DateTimeOffset.UtcNow - startTime).TotalSeconds;
+                    elapsed += Time.deltaTime;
                     if (elapsed >= second)
                     {
                         break;
@@ -224,5 +284,4 @@ namespace Cysharp.Threading.Tasks
             }
         }
     }
-}
-
+}

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

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

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

@@ -11,23 +11,40 @@ using UnityEngine.ResourceManagement.AsyncOperations;
 
 namespace Cysharp.Threading.Tasks
 {
-    public static class AddressableAsyncExtensions
+    public static class AddressablesAsyncExtensions
     {
 #region AsyncOperationHandle
 
-        public static AsyncOperationHandleAwaiter GetAwaiter(this AsyncOperationHandle handle)
+        public static UniTask.Awaiter GetAwaiter(this AsyncOperationHandle handle)
         {
-            return new AsyncOperationHandleAwaiter(handle);
+            return ToUniTask(handle).GetAwaiter();
         }
 
-        public static UniTask 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);
+            return ToUniTask(handle, cancellationToken: cancellationToken);
         }
 
-        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 (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken);
+
+            if (!handle.IsValid())
+            {
+                // autoReleaseHandle:true handle is invalid(immediately internal handle == null) so return completed.
+                return UniTask.CompletedTask;
+            }
+
+            if (handle.IsDone)
+            {
+                if (handle.Status == AsyncOperationStatus.Failed)
+                {
+                    return UniTask.FromException(handle.OperationException);
+                }
+                return UniTask.CompletedTask;
+            }
+
+            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellationToken, out var token), token);
         }
 
         public struct AsyncOperationHandleAwaiter : ICriticalNotifyCompletion
@@ -70,24 +87,33 @@ 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;
+            AsyncOperationHandleConfiguredSource nextNode;
+            public ref AsyncOperationHandleConfiguredSource NextNode => ref nextNode;
 
+            static AsyncOperationHandleConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource), () => pool.Size);
+            }
+
+            readonly Action<AsyncOperationHandle> continuationAction;
             AsyncOperationHandle handle;
-            IProgress<float> progress;
             CancellationToken cancellationToken;
+            IProgress<float> progress;
+            bool completed;
 
             UniTaskCompletionSourceCore<AsyncUnit> core;
 
             AsyncOperationHandleConfiguredSource()
             {
-
+                continuationAction = Continuation;
             }
 
             public static IUniTaskSource Create(AsyncOperationHandle handle, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
@@ -97,31 +123,55 @@ 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;
                 result.cancellationToken = cancellationToken;
+                result.completed = false;
 
                 TaskTracker.TrackActiveTask(result, 3);
 
                 PlayerLoopHelper.AddAction(timing, result);
 
+                handle.Completed += result.continuationAction;
+
                 token = result.core.Version;
                 return result;
             }
 
+            void Continuation(AsyncOperationHandle _)
+            {
+                handle.Completed -= continuationAction;
+
+                if (completed)
+                {
+                    TryReturn();
+                }
+                else
+                {
+                    completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                    }
+                    else if (handle.Status == AsyncOperationStatus.Failed)
+                    {
+                        core.TrySetException(handle.OperationException);
+                    }
+                    else
+                    {
+                        core.TrySetResult(AsyncUnit.Default);
+                    }
+                }
+            }
+
             public void GetResult(short token)
             {
-                try
-                {
-                    TaskTracker.RemoveTracking(this);
-                    core.GetResult(token);
-                }
-                finally
-                {
-                    pool.TryReturn(this);
-                }
+                core.GetResult(token);
             }
 
             public UniTaskStatus GetStatus(short token)
@@ -141,47 +191,35 @@ namespace Cysharp.Threading.Tasks
 
             public bool MoveNext()
             {
+                if (completed)
+                {
+                    TryReturn();
+                    return false;
+                }
+
                 if (cancellationToken.IsCancellationRequested)
                 {
+                    completed = true;
                     core.TrySetCanceled(cancellationToken);
                     return false;
                 }
 
-                if (progress != null)
+                if (progress != null && handle.IsValid())
                 {
                     progress.Report(handle.PercentComplete);
                 }
 
-                if (handle.IsDone)
-                {
-                    if (handle.Status == AsyncOperationStatus.Failed)
-                    {
-                        core.TrySetException(handle.OperationException);
-                    }
-                    else
-                    {
-                        core.TrySetResult(AsyncUnit.Default);
-                    }
-                    return false;
-                }
-
                 return true;
             }
 
-            public void Reset()
+            bool TryReturn()
             {
+                TaskTracker.RemoveTracking(this);
                 core.Reset();
                 handle = default;
                 progress = default;
                 cancellationToken = default;
-            }
-
-            ~AsyncOperationHandleConfiguredSource()
-            {
-                if (pool.TryReturn(this))
-                {
-                    GC.ReRegisterForFinalize(this);
-                }
+                return pool.TryPush(this);
             }
         }
 
@@ -189,80 +227,59 @@ namespace Cysharp.Threading.Tasks
 
 #region AsyncOperationHandle_T
 
-        public static AsyncOperationHandleAwaiter<T> GetAwaiter<T>(this AsyncOperationHandle<T> handle)
+        public static UniTask<T>.Awaiter GetAwaiter<T>(this AsyncOperationHandle<T> handle)
         {
-            return new AsyncOperationHandleAwaiter<T>(handle);
+            return ToUniTask(handle).GetAwaiter();
         }
 
-        public static UniTask<T> 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);
+            return ToUniTask(handle, cancellationToken: cancellationToken);
         }
 
-        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 (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<T>(cancellationToken);
 
-        public struct AsyncOperationHandleAwaiter<T> : ICriticalNotifyCompletion
-        {
-            AsyncOperationHandle<T> handle;
-            Action<AsyncOperationHandle> continuationAction;
-
-            public AsyncOperationHandleAwaiter(AsyncOperationHandle<T> handle)
+            if (!handle.IsValid())
             {
-                this.handle = handle;
-                this.continuationAction = null;
+                throw new Exception("Attempting to use an invalid operation handle");
             }
 
-            public bool IsCompleted => handle.IsDone;
-
-            public T GetResult()
+            if (handle.IsDone)
             {
-                if (continuationAction != null)
-                {
-                    handle.CompletedTypeless -= continuationAction;
-                    continuationAction = null;
-                }
-
                 if (handle.Status == AsyncOperationStatus.Failed)
                 {
-                    var e = handle.OperationException;
-                    handle = default;
-                    ExceptionDispatchInfo.Capture(e).Throw();
+                    return UniTask.FromException<T>(handle.OperationException);
                 }
-
-                var result = handle.Result;
-                handle = default;
-                return result;
+                return UniTask.FromResult(handle.Result);
             }
 
-            public void OnCompleted(Action continuation)
-            {
-                UnsafeOnCompleted(continuation);
-            }
-
-            public void UnsafeOnCompleted(Action continuation)
-            {
-                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
-                continuationAction = continuation.AsFuncOfT<AsyncOperationHandle>(); // allocate delegate.
-                handle.CompletedTypeless += continuationAction;
-            }
+            return new UniTask<T>(AsyncOperationHandleConfiguredSource<T>.Create(handle, timing, progress, cancellationToken, out var token), token);
         }
 
-        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;
+            AsyncOperationHandleConfiguredSource<T> nextNode;
+            public ref AsyncOperationHandleConfiguredSource<T> NextNode => ref nextNode;
 
+            static AsyncOperationHandleConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource<T>), () => pool.Size);
+            }
+
+            readonly Action<AsyncOperationHandle<T>> continuationAction;
             AsyncOperationHandle<T> handle;
-            IProgress<float> progress;
             CancellationToken cancellationToken;
+            IProgress<float> progress;
+            bool completed;
 
             UniTaskCompletionSourceCore<T> core;
 
             AsyncOperationHandleConfiguredSource()
             {
-
+                continuationAction = Continuation;
             }
 
             public static IUniTaskSource<T> Create(AsyncOperationHandle<T> handle, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
@@ -272,32 +289,55 @@ 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;
                 result.cancellationToken = cancellationToken;
+                result.completed = false;
+                result.progress = progress;
 
                 TaskTracker.TrackActiveTask(result, 3);
 
                 PlayerLoopHelper.AddAction(timing, result);
 
+                handle.Completed += result.continuationAction;
+
                 token = result.core.Version;
                 return result;
             }
 
+            void Continuation(AsyncOperationHandle<T> argHandle)
+            {
+                handle.Completed -= continuationAction;
+
+                if (completed)
+                {
+                    TryReturn();
+                }
+                else
+                {
+                    completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                    }
+                    else if (argHandle.Status == AsyncOperationStatus.Failed)
+                    {
+                        core.TrySetException(argHandle.OperationException);
+                    }
+                    else
+                    {
+                        core.TrySetResult(argHandle.Result);
+                    }
+                }
+            }
+
             public T GetResult(short token)
             {
-                try
-                {
-                    TaskTracker.RemoveTracking(this);
-
-                    return core.GetResult(token);
-                }
-                finally
-                {
-                    pool.TryReturn(this);
-                }
+                return core.GetResult(token);
             }
 
             void IUniTaskSource.GetResult(short token)
@@ -322,47 +362,35 @@ namespace Cysharp.Threading.Tasks
 
             public bool MoveNext()
             {
+                if (completed)
+                {
+                    TryReturn();
+                    return false;
+                }
+
                 if (cancellationToken.IsCancellationRequested)
                 {
+                    completed = true;
                     core.TrySetCanceled(cancellationToken);
                     return false;
                 }
 
-                if (progress != null)
+                if (progress != null && handle.IsValid())
                 {
                     progress.Report(handle.PercentComplete);
                 }
 
-                if (handle.IsDone)
-                {
-                    if (handle.Status == AsyncOperationStatus.Failed)
-                    {
-                        core.TrySetException(handle.OperationException);
-                    }
-                    else
-                    {
-                        core.TrySetResult(handle.Result);
-                    }
-                    return false;
-                }
-
                 return true;
             }
 
-            public void Reset()
+            bool TryReturn()
             {
+                TaskTracker.RemoveTracking(this);
                 core.Reset();
                 handle = default;
                 progress = default;
                 cancellationToken = default;
-            }
-
-            ~AsyncOperationHandleConfiguredSource()
-            {
-                if (pool.TryReturn(this))
-                {
-                    GC.ReRegisterForFinalize(this);
-                }
+                return pool.TryPush(this);
             }
         }
 

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

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

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

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

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

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

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

@@ -0,0 +1,458 @@
+// 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
+{
+    public enum TweenCancelBehaviour
+    {
+        Kill,
+        KillWithCompleteCallback,
+        Complete,
+        CompleteWithSeqeunceCallback,
+        CancelAwait,
+
+        // AndCancelAwait
+        KillAndCancelAwait,
+        KillWithCompleteCallbackAndCancelAwait,
+        CompleteAndCancelAwait,
+        CompleteWithSeqeunceCallbackAndCancelAwait
+    }
+
+    public static class DOTweenAsyncExtensions
+    {
+        enum CallbackType
+        {
+            Kill,
+            Complete,
+            Pause,
+            Play,
+            Rewind,
+            StepComplete
+        }
+
+        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, CallbackType.Kill, 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, CallbackType.Kill, out var token), token);
+        }
+
+        public static UniTask AwaitForComplete(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, CallbackType.Complete, out var token), token);
+        }
+
+        public static UniTask AwaitForPause(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, CallbackType.Pause, out var token), token);
+        }
+
+        public static UniTask AwaitForPlay(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, CallbackType.Play, out var token), token);
+        }
+
+        public static UniTask AwaitForRewind(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, CallbackType.Rewind, out var token), token);
+        }
+
+        public static UniTask AwaitForStepComplete(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, CallbackType.StepComplete, 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;
+            TweenConfiguredSource nextNode;
+            public ref TweenConfiguredSource NextNode => ref nextNode;
+
+            static TweenConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(TweenConfiguredSource), () => pool.Size);
+            }
+
+            static readonly TweenCallback EmptyTweenCallback = () => { };
+
+            readonly TweenCallback onCompleteCallbackDelegate;
+            readonly TweenCallback onUpdateDelegate;
+
+            Tween tween;
+            TweenCancelBehaviour cancelBehaviour;
+            CancellationToken cancellationToken;
+            CallbackType callbackType;
+            bool canceled;
+
+            TweenCallback originalUpdateAction;
+            UniTaskCompletionSourceCore<AsyncUnit> core;
+
+            TweenConfiguredSource()
+            {
+                onCompleteCallbackDelegate = OnCompleteCallbackDelegate;
+                onUpdateDelegate = OnUpdate;
+            }
+
+            public static IUniTaskSource Create(Tween tween, TweenCancelBehaviour cancelBehaviour, CancellationToken cancellationToken, CallbackType callbackType, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    DoCancelBeforeCreate(tween, cancelBehaviour);
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new TweenConfiguredSource();
+                }
+
+                result.tween = tween;
+                result.cancelBehaviour = cancelBehaviour;
+                result.cancellationToken = cancellationToken;
+                result.callbackType = callbackType;
+
+                result.originalUpdateAction = tween.onUpdate;
+                result.canceled = false;
+
+                if (result.originalUpdateAction == result.onUpdateDelegate)
+                {
+                    result.originalUpdateAction = null;
+                }
+
+                tween.onUpdate = result.onUpdateDelegate;
+
+                switch (callbackType)
+                {
+                    case CallbackType.Kill:
+                        tween.onKill = result.onCompleteCallbackDelegate;
+                        break;
+                    case CallbackType.Complete:
+                        tween.onComplete = result.onCompleteCallbackDelegate;
+                        break;
+                    case CallbackType.Pause:
+                        tween.onPause = result.onCompleteCallbackDelegate;
+                        break;
+                    case CallbackType.Play:
+                        tween.onPlay = result.onCompleteCallbackDelegate;
+                        break;
+                    case CallbackType.Rewind:
+                        tween.onRewind = result.onCompleteCallbackDelegate;
+                        break;
+                    case CallbackType.StepComplete:
+                        tween.onStepComplete = result.onCompleteCallbackDelegate;
+                        break;
+                    default:
+                        break;
+                }
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            void OnCompleteCallbackDelegate()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    if (this.cancelBehaviour == TweenCancelBehaviour.KillAndCancelAwait
+                        || this.cancelBehaviour == TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait
+                        || this.cancelBehaviour == TweenCancelBehaviour.CompleteAndCancelAwait
+                        || this.cancelBehaviour == TweenCancelBehaviour.CompleteWithSeqeunceCallbackAndCancelAwait
+                        || this.cancelBehaviour == TweenCancelBehaviour.CancelAwait)
+                    {
+                        canceled = true;
+                    }
+                }
+                if (canceled)
+                {
+                    core.TrySetCanceled(cancellationToken);
+                }
+                else
+                {
+                    core.TrySetResult(AsyncUnit.Default);
+                }
+            }
+
+            void OnUpdate()
+            {
+                originalUpdateAction?.Invoke();
+
+                if (!cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                switch (this.cancelBehaviour)
+                {
+                    case TweenCancelBehaviour.Kill:
+                    default:
+                        this.tween.Kill(false);
+                        break;
+                    case TweenCancelBehaviour.KillAndCancelAwait:
+                        this.canceled = true;
+                        this.tween.Kill(false);
+                        break;
+                    case TweenCancelBehaviour.KillWithCompleteCallback:
+                        this.tween.Kill(true);
+                        break;
+                    case TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait:
+                        this.canceled = true;
+                        this.tween.Kill(true);
+                        break;
+                    case TweenCancelBehaviour.Complete:
+                        this.tween.Complete(false);
+                        break;
+                    case TweenCancelBehaviour.CompleteAndCancelAwait:
+                        this.canceled = true;
+                        this.tween.Complete(false);
+                        break;
+                    case TweenCancelBehaviour.CompleteWithSeqeunceCallback:
+                        this.tween.Complete(true);
+                        break;
+                    case TweenCancelBehaviour.CompleteWithSeqeunceCallbackAndCancelAwait:
+                        this.canceled = true;
+                        this.tween.Complete(true);
+                        break;
+                    case TweenCancelBehaviour.CancelAwait:
+                        // replace to empty(avoid callback after Canceled(instance is returned to pool.)
+                        switch (callbackType)
+                        {
+                            case CallbackType.Kill:
+                                tween.onKill = EmptyTweenCallback;
+                                break;
+                            case CallbackType.Complete:
+                                tween.onComplete = EmptyTweenCallback;
+                                break;
+                            case CallbackType.Pause:
+                                tween.onPause = EmptyTweenCallback;
+                                break;
+                            case CallbackType.Play:
+                                tween.onPlay = EmptyTweenCallback;
+                                break;
+                            case CallbackType.Rewind:
+                                tween.onRewind = EmptyTweenCallback;
+                                break;
+                            case CallbackType.StepComplete:
+                                tween.onStepComplete = EmptyTweenCallback;
+                                break;
+                            default:
+                                break;
+                        }
+
+                        this.core.TrySetCanceled(this.cancellationToken);
+                        break;
+                }
+            }
+
+            static void DoCancelBeforeCreate(Tween tween, TweenCancelBehaviour tweenCancelBehaviour)
+            {
+
+                switch (tweenCancelBehaviour)
+                {
+                    case TweenCancelBehaviour.Kill:
+                    default:
+                        tween.Kill(false);
+                        break;
+                    case TweenCancelBehaviour.KillAndCancelAwait:
+                        tween.Kill(false);
+                        break;
+                    case TweenCancelBehaviour.KillWithCompleteCallback:
+                        tween.Kill(true);
+                        break;
+                    case TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait:
+                        tween.Kill(true);
+                        break;
+                    case TweenCancelBehaviour.Complete:
+                        tween.Complete(false);
+                        break;
+                    case TweenCancelBehaviour.CompleteAndCancelAwait:
+                        tween.Complete(false);
+                        break;
+                    case TweenCancelBehaviour.CompleteWithSeqeunceCallback:
+                        tween.Complete(true);
+                        break;
+                    case TweenCancelBehaviour.CompleteWithSeqeunceCallbackAndCancelAwait:
+                        tween.Complete(true);
+                        break;
+                    case TweenCancelBehaviour.CancelAwait:
+                        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.onUpdate = originalUpdateAction;
+
+                switch (callbackType)
+                {
+                    case CallbackType.Kill:
+                        tween.onKill = null;
+                        break;
+                    case CallbackType.Complete:
+                        tween.onComplete = null;
+                        break;
+                    case CallbackType.Pause:
+                        tween.onPause = null;
+                        break;
+                    case CallbackType.Play:
+                        tween.onPlay = null;
+                        break;
+                    case CallbackType.Rewind:
+                        tween.onRewind = null;
+                        break;
+                    case CallbackType.StepComplete:
+                        tween.onStepComplete = null;
+                        break;
+                    default:
+                        break;
+                }
+
+                tween = default;
+                cancellationToken = default;
+                originalUpdateAction = default;
+                return pool.TryPush(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

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

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 4d5a9a3e1f0f069478969f752fde29a9
+guid: 1f448d5bc5b232e4f98d89d5d1832e8e
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/UniTask/Assets/Plugins/UniTask/Runtime/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; }

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 && !NETSTANDARD2_0
+        : 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 && !NETSTANDARD2_0
+#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 && !NETSTANDARD2_0
+        , System.Threading.Tasks.Sources.IValueTaskSource<T>
+#endif
     {
         new T GetResult(short token);
+
+#if !UNITY_2018_3_OR_NEWER && !NETSTANDARD2_0
+
+        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

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

@@ -9,10 +9,10 @@ namespace Cysharp.Threading.Tasks.Internal
     {
         const int MaxArrayLength = 0X7FEFFFFF;
         const int InitialSize = 16;
-        
+
         readonly PlayerLoopTiming timing;
 
-        SpinLock gate = new SpinLock();
+        SpinLock gate = new SpinLock(false);
         bool dequing = false;
 
         int actionListCount = 0;
@@ -70,13 +70,17 @@ namespace Cysharp.Threading.Tasks.Internal
             }
         }
 
-        public void Clear()
+        public int Clear()
         {
+            var rest = actionListCount + waitingListCount;
+
             actionListCount = 0;
             actionList = new Action[InitialSize];
 
             waitingListCount = 0;
             waitingList = new Action[InitialSize];
+
+            return rest;
         }
 
         // delegate entrypoint.
@@ -128,6 +132,14 @@ namespace Cysharp.Threading.Tasks.Internal
                 case PlayerLoopTiming.LastPostLateUpdate:
                     LastPostLateUpdate();
                     break;
+#if UNITY_2020_2_OR_NEWER
+                case PlayerLoopTiming.TimeUpdate:
+                    TimeUpdate();
+                    break;
+                case PlayerLoopTiming.LastTimeUpdate:
+                    LastTimeUpdate();
+                    break;
+#endif
                 default:
                     break;
             }
@@ -150,6 +162,10 @@ namespace Cysharp.Threading.Tasks.Internal
         void LastPreLateUpdate() => RunCore();
         void PostLateUpdate() => RunCore();
         void LastPostLateUpdate() => RunCore();
+#if UNITY_2020_2_OR_NEWER
+        void TimeUpdate() => RunCore();
+        void LastTimeUpdate() => RunCore();
+#endif
 
         [System.Diagnostics.DebuggerHidden]
         void RunCore()
@@ -170,10 +186,17 @@ namespace Cysharp.Threading.Tasks.Internal
 
             for (int i = 0; i < actionListCount; i++)
             {
+
                 var action = actionList[i];
                 actionList[i] = null;
-
-                action();
+                try
+                {
+                    action();
+                }
+                catch (Exception ex)
+                {
+                    UnityEngine.Debug.LogException(ex);
+                }
             }
 
             {

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

@@ -239,7 +239,7 @@ namespace Cysharp.Threading.Tasks.Internal
             }
             else
             {
-                var fname = fi.FullName.Replace(Path.DirectorySeparatorChar, '/').Replace(Application.dataPath, "");
+                var fname = fi.FullName.Replace(Path.DirectorySeparatorChar, '/').Replace(PlayerLoopHelper.ApplicationDataPath, "");
                 var withAssetsPath = "Assets/" + fname;
                 return "<a href=\"" + withAssetsPath + "\" line=\"" + line + "\">" + withAssetsPath + ":" + line + "</a>";
             }

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

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

@@ -48,14 +48,24 @@ namespace Cysharp.Threading.Tasks.Internal
             }
         }
 
-        public void Clear()
+        public int Clear()
         {
             lock (arrayLock)
             {
+                var rest = 0;
+
                 for (var index = 0; index < loopItems.Length; index++)
                 {
+                    if (loopItems[index] != null)
+                    {
+                        rest++;
+                    }
+
                     loopItems[index] = null;
                 }
+
+                tail = 0;
+                return rest;
             }
         }
 
@@ -108,6 +118,14 @@ namespace Cysharp.Threading.Tasks.Internal
                 case PlayerLoopTiming.LastPostLateUpdate:
                     LastPostLateUpdate();
                     break;
+#if UNITY_2020_2_OR_NEWER
+                case PlayerLoopTiming.TimeUpdate:
+                    TimeUpdate();
+                    break;
+                case PlayerLoopTiming.LastTimeUpdate:
+                    LastTimeUpdate();
+                    break;
+#endif
                 default:
                     break;
             }
@@ -130,6 +148,10 @@ namespace Cysharp.Threading.Tasks.Internal
         void LastPreLateUpdate() => RunCore();
         void PostLateUpdate() => RunCore();
         void LastPostLateUpdate() => RunCore();
+#if UNITY_2020_2_OR_NEWER
+        void TimeUpdate() => RunCore();
+        void LastTimeUpdate() => RunCore();
+#endif
 
         [System.Diagnostics.DebuggerHidden]
         void RunCore()
@@ -143,7 +165,6 @@ namespace Cysharp.Threading.Tasks.Internal
             {
                 var j = tail - 1;
 
-                // eliminate array-bound check for i
                 for (int i = 0; i < loopItems.Length; i++)
                 {
                     var action = loopItems[i];

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

@@ -0,0 +1,50 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal sealed class PooledDelegate<T> : ITaskPoolNode<PooledDelegate<T>>
+    {
+        static TaskPool<PooledDelegate<T>> pool;
+
+        PooledDelegate<T> nextNode;
+        public ref PooledDelegate<T> NextNode => ref nextNode;
+
+        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();
+            }
+        }
+    }
+}

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: 

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;
-            }
-        }
-    }
-}

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", "");
+        //}
     }
 }
 

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

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

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

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

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

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

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

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

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/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();

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;
         }
     }
-
 }

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

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: 

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();
+                }
+<# } #>
+            }
+        }
+    }
+
+<# } #>
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.tt.meta

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

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

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

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

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

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

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/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();

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

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

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

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

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

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

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;
             }
         }