rc4

UniTask LINQ

.circleci/config.yml

@@ -1,114 +0,0 @@
-version: 2.1
-executors:
-  unity:
-    # https://hub.docker.com/r/gableroux/unity3d/tags
-    parameters:
-      version: {type: string}
-    docker:
-      - image: gableroux/unity3d:<< parameters.version >>
-  go:
-    docker:
-      - image: circleci/golang      
-commands:
-  unity_activate:
-    parameters:
-      unity_version: {type: string}
-      unity_license: {type: string}
-    steps:
-      # get activation file, if fail to activate unity, use this key and activate from https://license.unity3d.com/manual
-      - run: apt update && apt install libunwind8 -y
-      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -logFile -createManualActivationFile || exit 0
-      - run: cat Unity_v<< parameters.unity_version >>.alf
-      # get from UNITY_LICENSE envvar(base64 encoded(cat foo.ulf | base64 )), this file is generated from above manual activation
-      - run: echo << parameters.unity_license >> | base64 -di  >> .circleci/Unity.ulf
-      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .circleci/Unity.ulf || exit 0
-jobs:
-  build-and-test:
-    parameters:
-      unity_version: {type: string}
-      unity_license: {type: string}
-    executor:
-      name: unity
-      version: << parameters.unity_version >>
-    steps:
-      - checkout
-      - unity_activate:
-          unity_version: << parameters.unity_version >>
-          unity_license: << parameters.unity_license >>
-      - run:
-          name: Build Linux(Mono)
-          command: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend Mono2x /BuildTarget StandaloneLinux64
-          working_directory: .
-      # TODO:check unity version and packages...
-      # - run: ./bin/UnitTest/StandaloneLinux64_Mono2x/test
-  build-and-create-package:
-    parameters:
-      unity_version: {type: string}
-      unity_license: {type: string}
-    executor:
-      name: unity
-      version: << parameters.unity_version >>
-    steps:
-      - checkout
-      - unity_activate:
-          unity_version: << parameters.unity_version >>
-          unity_license: << parameters.unity_license >>
-      - run:
-          name: Export unitypackage
-          command: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
-          working_directory: .
-      - store_artifacts:
-          path: ./UniRx.Async.unitypackage
-          destination: /UniRx.Async.unitypackage
-  # upload to github by ghr
-  upload-github:
-    executor: go
-    steps:
-      - attach_workspace:
-          at: .
-      - run: go get github.com/tcnksm/ghr
-      - run: ghr -t ${GITHUB_TOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} ${CIRCLE_TAG} .
-      - store_artifacts:
-          path: UniRx.Async.unitypackage
-          destination: UniRx.Async.unitypackage          
-workflows:
-  version: 2
-  build-unity:
-    jobs:
-      # does not exists yet.
-      # - build-and-test:
-      #     unity_version: 2019.3.0a2
-      #     unity_license: ${UNITY_LICENSE_2019_3}
-      # - build-and-test:
-      #     unity_version: 2019.2.0b2
-      #     unity_license: ${UNITY_LICENSE_2019_2}
-      - build-and-test:
-          unity_version: 2019.1.2f1
-          unity_license: ${UNITY_LICENSE_2019_1}
-          filters:
-            tags:
-              only: /.*/
-      # test asmdef will not found.
-      # - build-and-test:
-      #     unity_version: 2018.4.0f1
-      #     unity_license: ${UNITY_LICENSE_2018_4}
-      # # UniTask minimum support version is 2018.3(C# 7.x)
-      # - build-and-test:
-      #     unity_version: 2018.3.12f1
-      #     unity_license: ${UNITY_LICENSE_2018_3}
-      - build-and-create-package:
-          unity_version: 2019.1.2f1
-          unity_license: ${UNITY_LICENSE_2019_1}
-          filters:
-            tags:
-              only: /^\d\.\d\.\d.*/
-            branches:
-              ignore: /.*/
-      - upload-github:
-          requires:
-            - build-and-create-package
-          filters:
-            tags:
-              only: /^\d\.\d\.\d.*/
-            branches:
-              ignore: /.*/

.github/workflows/build-debug.yml

@@ -0,0 +1,73 @@
+name: Build-Debug
+
+on:
+  push:
+    branches:
+      - "**"
+    tags:
+      - "!*" # not a tag push
+  pull_request:
+    types:
+      - opened
+      - synchronize
+
+jobs:
+  build-dotnet:
+    runs-on: ubuntu-latest
+    env:
+      DOTNET_CLI_TELEMETRY_OPTOUT: 1
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+      NUGET_XMLDOC_MODE: skip
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 3.1.101
+      - run: dotnet test -c Debug ./src/UniTask.NetCoreTests/UniTask.NetCoreTests.csproj
+
+  build-unity:
+    strategy:
+      matrix:
+        unity: ['2019.3.9f1', '2020.1.0b5']
+        include:
+          - unity: 2019.3.9f1
+            license: UNITY_2019_3
+          - unity: 2020.1.0b5
+            license: UNITY_2020_1
+    runs-on: ubuntu-latest
+    container:
+      # with linux-il2cpp. image from https://hub.docker.com/r/gableroux/unity3d/tags
+      image: gableroux/unity3d:${{ matrix.unity }}-linux-il2cpp
+    steps:
+      - run: apt update && apt install git -y
+      - uses: actions/checkout@v2
+      # create unity activation file and store to artifacts.
+      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -logFile -createManualActivationFile || exit 0
+      - uses: actions/upload-artifact@v1
+        with:
+          name: Unity_v${{ matrix.unity }}.alf
+          path: ./Unity_v${{ matrix.unity }}.alf
+      # activate Unity from manual license file(ulf)
+      - run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
+        env:
+          UNITY_LICENSE: ${{ secrets[matrix.license] }}
+      - name: Activate Unity, always returns a success. But if a subsequent run fails, the activation may have failed(if succeeded, shows `Next license update check is after` and not shows other message(like GUID != GUID). If fails not). In that case, upload the artifact's .alf file to https://license.unity3d.com/manual to get the .ulf file and set it to secrets.
+        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
+
+      # Execute scripts: RuntimeUnitTestToolkit
+      - name: Build UnitTest(Linux64, mono)
+        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend mono /BuildTarget StandaloneLinux64
+        working-directory: src/UniTask
+      - name: Execute UnitTest
+        run: ./src/UniTask/bin/UnitTest/StandaloneLinux64_Mono2x/test
+
+      # Execute scripts: Export Package
+      - name: Export unitypackage
+        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+        working-directory: src/UniTask
+
+      # Store artifacts.      
+      - uses: actions/upload-artifact@v2
+        with:
+          name: UniTask.unitypackage.zip
+          path: ./src/UniTask/*.unitypackage

.github/workflows/build-release.yml

@@ -0,0 +1,108 @@
+name: Build-Release
+
+on:
+  push:
+    tags:
+      - "[0-9]+.[0-9]+.[0-9]+*"
+
+jobs:
+  build-dotnet:
+    runs-on: ubuntu-latest
+    env:
+      DOTNET_CLI_TELEMETRY_OPTOUT: 1
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+      NUGET_XMLDOC_MODE: skip
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 3.1.101
+      # set release tag(*.*.*) to env.GIT_TAG
+      - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+
+      # build CommandTools first (use dotnet run command in ZLogger.csproj)
+      - run: dotnet build -c Release ./tools/CommandTools/CommandTools.csproj
+      - 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 }}
+
+      # Store artifacts.
+      - uses: actions/upload-artifact@v1
+        with:
+          name: nuget
+          path: ./src/ZLogger/bin/Release/ZLogger.${{ env.GIT_TAG }}.nupkg
+      
+  build-unity:
+    strategy:
+      matrix:
+        unity: ['2019.3.9f1']
+        include:
+          - unity: 2019.3.9f1
+            license: UNITY_2019_3
+    runs-on: ubuntu-latest
+    container:
+      # with linux-il2cpp. image from https://hub.docker.com/r/gableroux/unity3d/tags
+      image: gableroux/unity3d:${{ matrix.unity }}-linux-il2cpp
+    steps:
+      - run: apt update && apt install git -y
+      - uses: actions/checkout@v2
+      - run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
+        env:
+          UNITY_LICENSE: ${{ secrets[matrix.license] }}
+      - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
+
+      # set release tag(*.*.*) to env.GIT_TAG
+      - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+
+      # Execute scripts: Export Package
+      - name: Export unitypackage
+        run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
+        working-directory: src/ZLogger.Unity
+        env:
+          UNITY_PACKAGE_VERSION: ${{ env.GIT_TAG }}
+
+      # Store artifacts.
+      - uses: actions/upload-artifact@v1
+        with:
+          name: ZLogger.Unity.${{ env.GIT_TAG }}.unitypackage
+          path: ./src/ZLogger.Unity/ZLogger.Unity.${{ env.GIT_TAG }}.unitypackage
+
+  create-release:
+    needs: [build-dotnet, build-unity]
+    runs-on: ubuntu-latest
+    env:
+      DOTNET_CLI_TELEMETRY_OPTOUT: 1
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
+      NUGET_XMLDOC_MODE: skip
+    steps:
+    # setup dotnet for nuget push
+    - uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: 3.1.101
+    # set release tag(*.*.*) to env.GIT_TAG
+    - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+
+    # Create Releases
+    - uses: actions/create-release@v1
+      id: create_release
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ github.ref }}
+        release_name: Ver.${{ github.ref }}
+
+    # Download (All) Artifacts to current directory
+    - uses: actions/download-artifact@v2-preview
+
+    # Upload to NuGet
+    - run: dotnet nuget push "./nuget/*.nupkg" -s https://www.nuget.org/api/v2/package -k ${{ secrets.NUGET_KEY }}
+
+    # Upload to Releases(unitypackage)
+    - uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./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

.github/workflows/toc.yml

@@ -0,0 +1,15 @@
+name: TOC Generator
+
+on:
+  push:
+    paths:
+      - 'README.md'
+
+jobs:
+  generateTOC:
+    name: TOC Generator
+    runs-on: ubuntu-latest
+    steps:
+      - uses: technote-space/toc-generator@v2.4.0
+        with:
+          TOC_TITLE: "## Table of Contents"

.gitignore

@@ -155,3 +155,5 @@ src/UniTask/UniTask.Editor.csproj
 src/UniTask/UniTask.Tests.csproj
 
 src/UniTask/UniTask.Tests.Editor.csproj
+
+src/UniTask/UniTask.*.unitypackage

README.md

@@ -1,10 +1,29 @@
-# UniTask
-
-[![CircleCI](https://circleci.com/gh/Cysharp/UniTask.svg?style=svg)](https://circleci.com/gh/Cysharp/UniTask)
+UniTask
+===
+[![GitHub Actions](https://github.com/Cysharp/UniTask/workflows/Build-Debug/badge.svg)](https://github.com/Cysharp/UniTask/actions) [![Releases](https://img.shields.io/github/release/Cysharp/UniTask.svg)](https://github.com/Cysharp/UniTask/releases)
 
 Provides an efficient async/await integration to Unity.
 
-> UniTask was included in UniRx before v7 but now completely separated, it no dependent each other.
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+## Table of Contents
+
+- [Getting started](#getting-started)
+- [`UniTask<T>`](#unitaskt)
+- [Cancellation and Exception handling](#cancellation-and-exception-handling)
+- [Progress](#progress)
+- [UniTaskTracker](#unitasktracker)
+- [Reusable Promises](#reusable-promises)
+- [awaitable Events](#awaitable-events)
+- [async void vs async UniTask/UniTaskVoid](#async-void-vs-async-unitaskunitaskvoid)
+- [For Unit Testing](#for-unit-testing)
+- [Method List](#method-list)
+- [UPM Package](#upm-package)
+- [ECS, PlayerLoop](#ecs-playerloop)
+- [License](#license)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
 
 Getting started
 ---
@@ -354,6 +373,15 @@ or add `"com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=Asse
 
 If you want to set a target version, UniTask is using `*.*.*` release tag so you can specify a version like `#1.3.0`. For example `https://github.com/Cysharp/UniTask.git?path=Assets/UniRx.Async#1.3.1`.
 
+ECS, PlayerLoop
+---
+TODO:
+
+```csharp
+var loop = PlayerLoop.GetCurrentPlayerLoop();
+PlayerLoopHelper.Initialize(ref loop);
+```
+
 License
 ---
 This library is under the MIT License.

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

@@ -0,0 +1,123 @@
+#pragma warning disable 0649
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using System.Threading.Tasks.Sources;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class UniTaskValueTaskExtensions
+    {
+        public static ValueTask AsValueTask(this UniTask task)
+        {
+            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);
+        }
+
+        public static ValueTask<T> AsValueTask<T>(this 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);
+        }
+
+        struct UniTaskToValueTask
+        {
+            public IUniTaskSource source;
+            public short token;
+        }
+
+        class UniTaskValueTaskSource : IValueTaskSource
+        {
+            readonly IUniTaskSource source;
+
+            public UniTaskValueTaskSource(IUniTaskSource source)
+            {
+                this.source = source;
+            }
+
+            public void GetResult(short token)
+            {
+                source.GetResult(token);
+            }
+
+            public ValueTaskSourceStatus GetStatus(short token)
+            {
+                var status = source.GetStatus(token);
+                switch (status)
+                {
+                    case UniTaskStatus.Pending:
+                        return ValueTaskSourceStatus.Pending;
+                    case UniTaskStatus.Succeeded:
+                        return ValueTaskSourceStatus.Succeeded;
+                    case UniTaskStatus.Faulted:
+                        return ValueTaskSourceStatus.Faulted;
+                    case UniTaskStatus.Canceled:
+                        return ValueTaskSourceStatus.Canceled;
+                    default:
+                        return (ValueTaskSourceStatus)status;
+                }
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
+            {
+                source.OnCompleted(continuation, state, token);
+            }
+        }
+
+        struct UniTaskToValueTask<T>
+        {
+            public IUniTaskSource<T> source;
+            public T result;
+            public short token;
+        }
+
+        class UniTaskValueTaskSource<T> : IValueTaskSource<T>
+        {
+            readonly IUniTaskSource<T> source;
+
+            public UniTaskValueTaskSource(IUniTaskSource<T> source)
+            {
+                this.source = source;
+            }
+
+            public T GetResult(short token)
+            {
+                return source.GetResult(token);
+            }
+
+            public ValueTaskSourceStatus GetStatus(short token)
+            {
+                var status = source.GetStatus(token);
+                switch (status)
+                {
+                    case UniTaskStatus.Pending:
+                        return ValueTaskSourceStatus.Pending;
+                    case UniTaskStatus.Succeeded:
+                        return ValueTaskSourceStatus.Succeeded;
+                    case UniTaskStatus.Faulted:
+                        return ValueTaskSourceStatus.Faulted;
+                    case UniTaskStatus.Canceled:
+                        return ValueTaskSourceStatus.Canceled;
+                    default:
+                        return (ValueTaskSourceStatus)status;
+                }
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
+            {
+                source.OnCompleted(continuation, state, token);
+            }
+        }
+    }
+}

src/UniTask.NetCore/NetCore/UniTask.Run.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public partial struct UniTask
+    {
+        /// <summary>Run action on the threadPool and return to current SynchronizationContext if configureAwait = true.</summary>
+        public static async UniTask Run(Action action, bool configureAwait = true)
+        {
+            if (configureAwait)
+            {
+                var current = SynchronizationContext.Current;
+                await UniTask.SwitchToThreadPool();
+                try
+                {
+                    action();
+                }
+                finally
+                {
+                    if (current != null)
+                    {
+                        await UniTask.SwitchToSynchronizationContext(current);
+                    }
+                }
+            }
+            else
+            {
+                await UniTask.SwitchToThreadPool();
+                action();
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to current SynchronizationContext if configureAwait = true.</summary>
+        public static async UniTask Run(Action<object> action, object state, bool configureAwait = true)
+        {
+            if (configureAwait)
+            {
+                var current = SynchronizationContext.Current;
+                await UniTask.SwitchToThreadPool();
+                try
+                {
+                    action(state);
+                }
+                finally
+                {
+                    if (current != null)
+                    {
+                        await UniTask.SwitchToSynchronizationContext(current);
+                    }
+                }
+            }
+            else
+            {
+                await UniTask.SwitchToThreadPool();
+                action(state);
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to current SynchronizationContext if configureAwait = true.</summary>
+        public static async UniTask<T> Run<T>(Func<T> func, bool configureAwait = true)
+        {
+            if (configureAwait)
+            {
+                var current = SynchronizationContext.Current;
+                await UniTask.SwitchToThreadPool();
+                try
+                {
+                    return func();
+                }
+                finally
+                {
+                    if (current != null)
+                    {
+                        await UniTask.SwitchToSynchronizationContext(current);
+                    }
+                }
+            }
+            else
+            {
+                await UniTask.SwitchToThreadPool();
+                return func();
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to current SynchronizationContext if configureAwait = true.</summary>
+        public static async UniTask<T> Run<T>(Func<object, T> func, object state, bool configureAwait = true)
+        {
+            if (configureAwait)
+            {
+                var current = SynchronizationContext.Current;
+                await UniTask.SwitchToThreadPool();
+                try
+                {
+                    return func(state);
+                }
+                finally
+                {
+                    if (current != null)
+                    {
+                        await UniTask.SwitchToSynchronizationContext(current);
+                    }
+                }
+            }
+            else
+            {
+                await UniTask.SwitchToThreadPool();
+                return func(state);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public partial struct UniTask
+    {
+        public static UniTask.YieldAwaitable Yield()
+        {
+            return default;
+        }
+
+        public readonly struct YieldAwaitable
+        {
+            public Awaiter GetAwaiter()
+            {
+                return default;
+            }
+
+            public readonly struct Awaiter : ICriticalNotifyCompletion
+            {
+                static readonly SendOrPostCallback SendOrPostCallbackDelegate = Continuation;
+                static readonly WaitCallback WaitCallbackDelegate = Continuation;
+
+                public bool IsCompleted => false;
+
+                public void GetResult() { }
+
+                public void OnCompleted(Action continuation)
+                {
+                    UnsafeOnCompleted(continuation);
+                }
+
+                public void UnsafeOnCompleted(Action continuation)
+                {
+                    var syncContext = SynchronizationContext.Current;
+                    if (syncContext != null)
+                    {
+                        syncContext.Post(SendOrPostCallbackDelegate, continuation);
+                    }
+                    else
+                    {
+                        ThreadPool.UnsafeQueueUserWorkItem(WaitCallbackDelegate, continuation);
+                    }
+                }
+
+                static void Continuation(object state)
+                {
+                    ((Action)state).Invoke();
+                }
+            }
+        }
+    }
+}

src/UniTask.NetCore/UniTask.NetCore.csproj

@@ -7,25 +7,33 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <Compile Include="..\UniTask\Assets\Plugins\UniTask\**\*.cs"
-                 Exclude="..\UniTask\Assets\Plugins\UniTask\Triggers\*.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\Editor\*.cs;
-                          
-                          ..\UniTask\Assets\Plugins\UniTask\Internal\UnityEqualityComparer.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\Internal\DiagnosticsExtensions.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\Internal\PlayerLoopRunner.cs;
-                          
-                          ..\UniTask\Assets\Plugins\UniTask\CancellationTokenSourceExtensions.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\EnumeratorAsyncExtensions.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\PlayerLoopHelper.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\UniTask.Delay.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\UniTask.Run.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\UniTask.Bridge.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\UniTask.WaitUntil.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\UnityAsyncExtensions.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\UnityAsyncExtensions.uGUI.cs;
-                          ..\UniTask\Assets\Plugins\UniTask\UnityAsyncExtensions.MonoBehaviour.cs;
-                 "/>
+        <Compile Include="..\UniTask\Assets\Plugins\UniTask\Runtime\**\*.cs"
+                 Exclude="
+..\UniTask\Assets\Plugins\UniTask\Editor\*.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\Triggers\*.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\Linq\UnityExtensions\*.cs;
+  
+..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\UnityEqualityComparer.cs;
+..\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\CancellationTokenSourceExtensions.cs;
+..\UniTask\Assets\Plugins\UniTask\Runtime\EnumeratorAsyncExtensions.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\UnityBindingExtensions.cs;
+" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
     </ItemGroup>
 
 </Project>

src/UniTask.NetCoreSandbox/Program.cs

@@ -1,38 +1,280 @@
 using Cysharp.Threading.Tasks;
+
+using System.Linq;
 using System;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
+using System.Collections;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Runtime.CompilerServices;
+using Cysharp.Threading.Tasks.Linq;
+using System.Reactive.Linq;
+using System.Reactive.Concurrency;
 
 namespace NetCoreSandbox
 {
+    public class Text
+    {
+
+        public string text { get; set; }
+    }
+
+    public static partial class UnityUIComponentExtensions
+    {
+        public static void BindTo(this IUniTaskAsyncEnumerable<string> source, Text text)
+        {
+            AAAACORECORE(source, text).Forget();
+
+            async UniTaskVoid AAAACORECORE(IUniTaskAsyncEnumerable<string> source2, Text text2)
+            {
+                var e = source2.GetAsyncEnumerator();
+                try
+                {
+                    while (await e.MoveNextAsync())
+                    {
+                        text2.text = e.Current;
+                        // action(e.Current);
+                    }
+                }
+                finally
+                {
+                    if (e != null)
+                    {
+                        await e.DisposeAsync();
+                    }
+                }
+            }
+        }
+
+        //public static IDisposable SubscribeToText<T>(this IObservable<T> source, Text text)
+        //{
+        //    return source.SubscribeWithState(text, (x, t) => t.text = x.ToString());
+        //}
+
+        //public static IDisposable SubscribeToText<T>(this IObservable<T> source, Text text, Func<T, string> selector)
+        //{
+        //    return source.SubscribeWithState2(text, selector, (x, t, s) => t.text = s(x));
+        //}
+
+        //public static IDisposable SubscribeToInteractable(this IObservable<bool> source, Selectable selectable)
+        //{
+        //    return source.SubscribeWithState(selectable, (x, s) => s.interactable = x);
+        //}
+    }
+
     class Program
     {
-        static async Task Main(string[] args)
+        static string FlattenGenArgs(Type type)
         {
-            Console.WriteLine("Foo");
-            var v = await outer().AsTask();
-
-            Console.WriteLine("Bar:" + v);
+            if (type.IsGenericType)
+            {
+                var t = string.Join(", ", type.GetGenericArguments().Select(x => FlattenGenArgs(x)));
+                return Regex.Replace(type.Name, "`.+", "") + "<" + t + ">";
+            }
+            //x.ReturnType.GetGenericArguments()
+            else
+            {
+                return type.Name;
+            }
         }
 
-        static async UniTask<int> outer()
+        static async IAsyncEnumerable<int> FooAsync([EnumeratorCancellation]CancellationToken cancellationToken = default)
         {
-            var v = await DoAsync();
-            return v;
+            yield return 1;
+            await Task.Delay(10, cancellationToken);
         }
 
 
-        static async UniTask<int> DoAsync()
+
+        static void Main(string[] args)
         {
-            var tcs = new UniTaskCompletionSource<int>();
 
-            tcs.TrySetResult(100);
+            var channel = Channel.CreateSingleConsumerUnbounded<int>();
+
+
+
 
 
-            var v = await tcs.Task;
 
-            return v;
         }
 
 
+
+        void Foo()
+        {
+
+            // AsyncEnumerable.Range(1,10).Do(
+
+            // AsyncEnumerable.t
+
+            var sb = new StringBuilder();
+            sb.AppendLine(@"using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+");
+
+
+
+            var chako = typeof(AsyncEnumerable).GetMethods()
+                .OrderBy(x => x.Name)
+                .Select(x =>
+                {
+                    var ret = FlattenGenArgs(x.ReturnType);
+
+
+                    var generics = string.Join(", ", x.GetGenericArguments().Select(x => x.Name));
+
+                    if (x.GetParameters().Length == 0) return "";
+
+                    var self = x.GetParameters().First();
+                    if (x.GetCustomAttributes(typeof(ExtensionAttribute), true).Length == 0)
+                    {
+                        return "";
+                    }
+
+                    var arg1Type = FlattenGenArgs(x.GetParameters().First().ParameterType);
+
+                    var others = string.Join(", ", x.GetParameters().Skip(1).Select(y => FlattenGenArgs(y.ParameterType) + " " + y.Name));
+
+                    if (!string.IsNullOrEmpty(others))
+                    {
+                        others = ", " + others;
+                    }
+
+                    var template = $"public static {ret} {x.Name}<{generics}>(this {arg1Type} {self.Name}{others})";
+
+
+
+                    return template.Replace("ValueTask", "UniTask").Replace("IAsyncEnumerable", "IUniTaskAsyncEnumerable").Replace("<>", "");
+                })
+                .Where(x => x != "")
+                .Select(x => x + "\r\n{\r\n    throw new NotImplementedException();\r\n}")
+                .ToArray();
+
+            var huga = string.Join("\r\n\r\n", chako);
+
+
+
+
+            foreach (var item in typeof(AsyncEnumerable).GetMethods().Select(x => x.Name).Distinct())
+            {
+                if (item.EndsWith("AwaitAsync") || item.EndsWith("AwaitWithCancellationAsync") || item.EndsWith("WithCancellation"))
+                {
+                    continue;
+                }
+
+                var item2 = item.Replace("Async", "");
+                item2 = item2.Replace("Await", "");
+
+                var format = @"
+    internal sealed class {0}
+    {{
+    }}
+";
+
+                sb.Append(string.Format(format, item2));
+
+            }
+
+            sb.Append("}");
+
+
+            Console.WriteLine(sb.ToString());
+
+
+
+
+        }
+
+
+        public static async IAsyncEnumerable<int> AsyncGen()
+        {
+            await UniTask.SwitchToThreadPool();
+            yield return 10;
+            await UniTask.SwitchToThreadPool();
+            yield return 100;
+        }
     }
+
+    class MyEnumerable : IEnumerable<int>
+    {
+        public IEnumerator<int> GetEnumerator()
+        {
+            return new MyEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    class MyEnumerator : IEnumerator<int>
+    {
+        public int Current => throw new NotImplementedException();
+
+        object IEnumerator.Current => throw new NotImplementedException();
+
+        public void Dispose()
+        {
+            Console.WriteLine("Called Dispose");
+        }
+
+        public bool MoveNext()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Reset()
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+
+
+    public class MyClass<T>
+    {
+        public CustomAsyncEnumerator<T> GetAsyncEnumerator()
+        {
+            //IAsyncEnumerable
+            return new CustomAsyncEnumerator<T>();
+        }
+    }
+
+
+    public struct CustomAsyncEnumerator<T>
+    {
+        int count;
+
+        public T Current
+        {
+            get
+            {
+                return default;
+            }
+        }
+
+        public UniTask<bool> MoveNextAsync()
+        {
+            if (count++ == 3)
+            {
+                return UniTask.FromResult(false);
+                //return false;
+            }
+            return UniTask.FromResult(true);
+        }
+
+        public UniTask DisposeAsync()
+        {
+            return default;
+        }
+    }
+
+
+
 }

src/UniTask.NetCoreSandbox/UniTask.NetCoreSandbox.csproj

@@ -6,6 +6,11 @@
     <RootNamespace>NetCoreSandbox</RootNamespace>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.Interactive.Async" Version="4.1.1" />
+    <PackageReference Include="System.Reactive" Version="4.4.1" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\UniTask.NetCore\UniTask.NetCore.csproj" />
   </ItemGroup>

src/UniTask.NetCoreTests/AsyncReactivePropertyTest.cs

@@ -0,0 +1,57 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using Cysharp.Threading.Tasks.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests
+{
+    public class AsyncReactivePropertyTest
+    {
+        [Fact]
+        public async Task Iteration()
+        {
+            var rp = new AsyncReactiveProperty<int>(99);
+
+            var f = await rp.FirstAsync();
+            f.Should().Be(99);
+
+            var array = rp.Take(5).ToArrayAsync();
+
+            rp.Value = 100;
+            rp.Value = 100;
+            rp.Value = 100;
+            rp.Value = 131;
+
+            var ar = await array;
+
+            ar.Should().BeEquivalentTo(new[] { 99, 100, 100, 100, 131 });
+        }
+
+        [Fact]
+        public async Task WithoutCurrent()
+        {
+            var rp = new AsyncReactiveProperty<int>(99);
+
+            var array = rp.WithoutCurrent().Take(5).ToArrayAsync();
+
+            rp.Value = 100;
+            rp.Value = 100;
+            rp.Value = 100;
+            rp.Value = 131;
+            rp.Value = 191;
+
+            var ar = await array;
+
+            ar.Should().BeEquivalentTo(new[] { 100, 100, 100, 131, 191 });
+        }
+    }
+
+
+}

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/ChannelTest.cs

@@ -0,0 +1,370 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using Cysharp.Threading.Tasks.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests
+{
+    public class ChannelTest
+    {
+        (System.Threading.Channels.Channel<int>, Cysharp.Threading.Tasks.Channel<int>) CreateChannel()
+        {
+            var reference = System.Threading.Channels.Channel.CreateUnbounded<int>(new UnboundedChannelOptions
+            {
+                AllowSynchronousContinuations = true,
+                SingleReader = true,
+                SingleWriter = false
+            });
+
+            var channel = Cysharp.Threading.Tasks.Channel.CreateSingleConsumerUnbounded<int>();
+
+            return (reference, channel);
+        }
+
+        [Fact]
+        public async Task SingleWriteSingleRead()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                var t1 = reference.Reader.WaitToReadAsync();
+                var t2 = channel.Reader.WaitToReadAsync();
+
+                t1.IsCompleted.Should().BeFalse();
+                t2.Status.IsCompleted().Should().BeFalse();
+
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+
+                (await t1).Should().BeTrue();
+                (await t2).Should().BeTrue();
+
+                reference.Reader.TryRead(out var refitem).Should().BeTrue();
+                channel.Reader.TryRead(out var chanitem).Should().BeTrue();
+                refitem.Should().Be(item);
+                chanitem.Should().Be(item);
+            }
+        }
+
+        [Fact]
+        public async Task MultiWrite()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                var t1 = reference.Reader.WaitToReadAsync();
+                var t2 = channel.Reader.WaitToReadAsync();
+
+                t1.IsCompleted.Should().BeFalse();
+                t2.Status.IsCompleted().Should().BeFalse();
+
+                foreach (var i in Enumerable.Range(1, 3))
+                {
+                    reference.Writer.TryWrite(item * i);
+                    channel.Writer.TryWrite(item * i);
+                }
+
+                (await t1).Should().BeTrue();
+                (await t2).Should().BeTrue();
+
+                foreach (var i in Enumerable.Range(1, 3))
+                {
+                    (await reference.Reader.WaitToReadAsync()).Should().BeTrue();
+                    (await channel.Reader.WaitToReadAsync()).Should().BeTrue();
+
+                    reference.Reader.TryRead(out var refitem).Should().BeTrue();
+                    channel.Reader.TryRead(out var chanitem).Should().BeTrue();
+                    refitem.Should().Be(item * i);
+                    chanitem.Should().Be(item * i);
+                }
+            }
+        }
+
+        [Fact]
+        public async Task CompleteOnEmpty()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+                reference.Reader.TryRead(out var refitem);
+                channel.Reader.TryRead(out var chanitem);
+            }
+
+            // Empty.
+
+            var completion1 = reference.Reader.Completion;
+            var wait1 = reference.Reader.WaitToReadAsync();
+
+            var completion2 = channel.Reader.Completion;
+            var wait2 = channel.Reader.WaitToReadAsync();
+
+            reference.Writer.TryComplete();
+            channel.Writer.TryComplete();
+
+            completion1.Status.Should().Be(TaskStatus.RanToCompletion);
+            completion2.Status.Should().Be(UniTaskStatus.Succeeded);
+
+            (await wait1).Should().BeFalse();
+            (await wait2).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task CompleteErrorOnEmpty()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+                reference.Reader.TryRead(out var refitem);
+                channel.Reader.TryRead(out var chanitem);
+            }
+
+            // Empty.
+
+            var completion1 = reference.Reader.Completion;
+            var wait1 = reference.Reader.WaitToReadAsync();
+
+            var completion2 = channel.Reader.Completion;
+            var wait2 = channel.Reader.WaitToReadAsync();
+
+            var ex = new Exception();
+            reference.Writer.TryComplete(ex);
+            channel.Writer.TryComplete(ex);
+
+            completion1.Status.Should().Be(TaskStatus.Faulted);
+            completion2.Status.Should().Be(UniTaskStatus.Faulted);
+
+            (await Assert.ThrowsAsync<Exception>(async () => await wait1)).Should().Be(ex);
+            (await Assert.ThrowsAsync<Exception>(async () => await wait2)).Should().Be(ex);
+        }
+
+        [Fact]
+        public async Task CompleteWithRest()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+            }
+
+            // Three Item2.
+
+            var completion1 = reference.Reader.Completion;
+            var wait1 = reference.Reader.WaitToReadAsync();
+
+            var completion2 = channel.Reader.Completion;
+            var wait2 = channel.Reader.WaitToReadAsync();
+
+            reference.Writer.TryComplete();
+            channel.Writer.TryComplete();
+
+            // completion1.Status.Should().Be(TaskStatus.WaitingForActivation);
+            completion2.Status.Should().Be(UniTaskStatus.Pending);
+
+            (await wait1).Should().BeTrue();
+            (await wait2).Should().BeTrue();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Reader.TryRead(out var i1).Should().BeTrue();
+                channel.Reader.TryRead(out var i2).Should().BeTrue();
+                i1.Should().Be(item);
+                i2.Should().Be(item);
+            }
+
+            (await reference.Reader.WaitToReadAsync()).Should().BeFalse();
+            (await channel.Reader.WaitToReadAsync()).Should().BeFalse();
+
+            completion1.Status.Should().Be(TaskStatus.RanToCompletion);
+            completion2.Status.Should().Be(UniTaskStatus.Succeeded);
+        }
+
+
+        [Fact]
+        public async Task CompleteErrorWithRest()
+        {
+            var (reference, channel) = CreateChannel();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+            }
+
+            // Three Item2.
+
+            var completion1 = reference.Reader.Completion;
+            var wait1 = reference.Reader.WaitToReadAsync();
+
+            var completion2 = channel.Reader.Completion;
+            var wait2 = channel.Reader.WaitToReadAsync();
+
+            var ex = new Exception();
+            reference.Writer.TryComplete(ex);
+            channel.Writer.TryComplete(ex);
+
+            // completion1.Status.Should().Be(TaskStatus.WaitingForActivation);
+            completion2.Status.Should().Be(UniTaskStatus.Pending);
+
+            (await wait1).Should().BeTrue();
+            (await wait2).Should().BeTrue();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Reader.TryRead(out var i1).Should().BeTrue();
+                channel.Reader.TryRead(out var i2).Should().BeTrue();
+                i1.Should().Be(item);
+                i2.Should().Be(item);
+            }
+
+            wait1 = reference.Reader.WaitToReadAsync();
+            wait2 = channel.Reader.WaitToReadAsync();
+
+            (await Assert.ThrowsAsync<Exception>(async () => await wait1)).Should().Be(ex);
+            (await Assert.ThrowsAsync<Exception>(async () => await wait2)).Should().Be(ex);
+
+            completion1.Status.Should().Be(TaskStatus.Faulted);
+            completion2.Status.Should().Be(UniTaskStatus.Faulted);
+        }
+
+        [Fact]
+        public async Task Cancellation()
+        {
+            var (reference, channel) = CreateChannel();
+
+            var cts = new CancellationTokenSource();
+
+            var wait1 = reference.Reader.WaitToReadAsync(cts.Token);
+            var wait2 = channel.Reader.WaitToReadAsync(cts.Token);
+
+            cts.Cancel();
+
+            (await Assert.ThrowsAsync<OperationCanceledException>(async () => await wait1)).CancellationToken.Should().Be(cts.Token);
+            (await Assert.ThrowsAsync<OperationCanceledException>(async () => await wait2)).CancellationToken.Should().Be(cts.Token);
+        }
+
+        [Fact]
+        public async Task AsyncEnumerator()
+        {
+            var (reference, channel) = CreateChannel();
+
+            var ta1 = reference.Reader.ReadAllAsync().ToArrayAsync();
+            var ta2 = channel.Reader.ReadAllAsync().ToArrayAsync();
+
+            foreach (var item in new[] { 10, 20, 30 })
+            {
+                reference.Writer.TryWrite(item);
+                channel.Writer.TryWrite(item);
+            }
+
+            reference.Writer.TryComplete();
+            channel.Writer.TryComplete();
+
+            (await ta1).Should().BeEquivalentTo(new[] { 10, 20, 30 });
+            (await ta2).Should().BeEquivalentTo(new[] { 10, 20, 30 });
+        }
+
+        [Fact]
+        public async Task AsyncEnumeratorCancellation()
+        {
+            // Token1, Token2 and Cancel1
+            {
+                var cts1 = new CancellationTokenSource();
+                var cts2 = new CancellationTokenSource();
+
+                var (reference, channel) = CreateChannel();
+
+                var ta1 = reference.Reader.ReadAllAsync(cts1.Token).ToArrayAsync(cts2.Token);
+                var ta2 = channel.Reader.ReadAllAsync(cts1.Token).ToArrayAsync(cts2.Token);
+
+                foreach (var item in new[] { 10, 20, 30 })
+                {
+                    reference.Writer.TryWrite(item);
+                    channel.Writer.TryWrite(item);
+                }
+
+                cts1.Cancel();
+
+                await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta1);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta2)).CancellationToken.Should().Be(cts1.Token);
+            }
+            // Token1, Token2 and Cancel2
+            {
+                var cts1 = new CancellationTokenSource();
+                var cts2 = new CancellationTokenSource();
+
+                var (reference, channel) = CreateChannel();
+
+                var ta1 = reference.Reader.ReadAllAsync(cts1.Token).ToArrayAsync(cts2.Token);
+                var ta2 = channel.Reader.ReadAllAsync(cts1.Token).ToArrayAsync(cts2.Token);
+
+                foreach (var item in new[] { 10, 20, 30 })
+                {
+                    reference.Writer.TryWrite(item);
+                    channel.Writer.TryWrite(item);
+                }
+
+                cts2.Cancel();
+
+                await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta1);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta2)).CancellationToken.Should().Be(cts2.Token);
+            }
+            // Token1 and Cancel1
+            {
+                var cts1 = new CancellationTokenSource();
+
+                var (reference, channel) = CreateChannel();
+
+                var ta1 = reference.Reader.ReadAllAsync(cts1.Token).ToArrayAsync();
+                var ta2 = channel.Reader.ReadAllAsync(cts1.Token).ToArrayAsync();
+
+                foreach (var item in new[] { 10, 20, 30 })
+                {
+                    reference.Writer.TryWrite(item);
+                    channel.Writer.TryWrite(item);
+                }
+
+                cts1.Cancel();
+
+                await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta1);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta2)).CancellationToken.Should().Be(cts1.Token);
+            }
+            // Token2 and Cancel2
+            {
+                var cts2 = new CancellationTokenSource();
+
+                var (reference, channel) = CreateChannel();
+
+                var ta1 = reference.Reader.ReadAllAsync().ToArrayAsync(cts2.Token);
+                var ta2 = channel.Reader.ReadAllAsync().ToArrayAsync(cts2.Token);
+
+                foreach (var item in new[] { 10, 20, 30 })
+                {
+                    reference.Writer.TryWrite(item);
+                    channel.Writer.TryWrite(item);
+                }
+
+                cts2.Cancel();
+
+                await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta1);
+                (await Assert.ThrowsAsync<OperationCanceledException>(async () => await ta2)).CancellationToken.Should().Be(cts2.Token);
+            }
+        }
+    }
+}

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/Aggregate.cs

@@ -0,0 +1,496 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class Aggregate
+    {
+        [Theory]
+        [InlineData(0, 10)]
+        [InlineData(0, 1)]
+        [InlineData(10, 0)]
+        [InlineData(1, 11)]
+        public async Task Sum(int start, int count)
+        {
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(start, count).SumAsync();
+                var ys = Enumerable.Range(start, count).Sum();
+                xs.Should().Be(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(start, count).SumAsync(x => x * 2);
+                var ys = Enumerable.Range(start, count).Sum(x => x * 2);
+                xs.Should().Be(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(start, count).SumAwaitAsync(x => UniTask.Run(() => x));
+                var ys = Enumerable.Range(start, count).Sum(x => x);
+                xs.Should().Be(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(start, count).SumAwaitWithCancellationAsync((x, _) => UniTask.Run(() => x));
+                var ys = Enumerable.Range(start, count).Sum(x => x);
+                xs.Should().Be(ys);
+            }
+        }
+
+        public static IEnumerable<object[]> array1 = new object[][]
+        {
+            new object[]{new int[] { 1, 10, 100 } },
+            new object[]{new int?[] { 1, null, 100 } },
+            new object[]{new float[] { 1, 10, 100 } },
+            new object[]{new float?[] { 1, null, 100 } },
+            new object[]{new double[] { 1, 10, 100 } },
+            new object[]{new double?[] { 1, null, 100 } },
+            new object[]{new decimal[] { 1, 10, 100 } },
+            new object[]{new decimal?[] { 1, null, 100 } },
+        };
+
+        [Theory]
+        [MemberData(nameof(array1))]
+        public async Task Average<T>(T arr)
+        {
+            switch (arr)
+            {
+                case int[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().AverageAsync();
+                        var ys = array.Average();
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                case int?[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().AverageAsync();
+                        var ys = array.Average();
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                case float[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().AverageAsync();
+                        var ys = array.Average();
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                case float?[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().AverageAsync();
+                        var ys = array.Average();
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                case double[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().AverageAsync();
+                        var ys = array.Average();
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                case double?[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().AverageAsync();
+                        var ys = array.Average();
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                case decimal[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().AverageAsync();
+                        var ys = array.Average();
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                case decimal?[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().AverageAsync();
+                        var ys = array.Average();
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+
+        public static IEnumerable<object[]> array2 = new object[][]
+        {
+            new object[]{new int[] { } },
+            new object[]{new int[] { 5 } },
+            new object[]{new int[] { 5, 10, 100 } },
+            new object[]{new int[] { 10, 5,100 } },
+            new object[]{new int[] { 100, 10, 5 } },
+
+            new object[]{new int?[] { } },
+            new object[]{new int?[] { 5 } },
+            new object[]{new int?[] { null, null, null } },
+            new object[]{new int?[] { null, 5, 10, 100 } },
+            new object[]{new int?[] { 10, 5,100, null } },
+            new object[]{new int?[] { 100, 10, 5 } },
+
+            new object[]{new X[] { } },
+            new object[]{new X[] { new X(5) } },
+            new object[]{new X[] { new X(5), new X(10), new X(100) } },
+            new object[]{new X[] { new X(10),new X( 5),new X(100) } },
+            new object[]{new X[] { new X(100), new X(10),new X(5) } },
+
+            new object[]{new XX[] { } },
+            new object[]{new XX[] { new XX(new X(5)) } },
+            new object[]{new XX[] { new XX(new X(5)), new XX(new X(10)), new XX(new X(100)) } },
+            new object[]{new XX[] { new XX(new X(10)),new XX(new X( 5)),new XX(new X(100)) } },
+            new object[]{new XX[] { new XX(new X(100)), new XX(new X(10)),new XX(new X(5)) } },
+        };
+
+        [Theory]
+        [MemberData(nameof(array2))]
+        public async Task Min<T>(T arr)
+        {
+            switch (arr)
+            {
+                case int[] array:
+                    {
+                        {
+                            if (array.Length == 0)
+                            {
+                                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().MinAsync());
+                                Assert.Throws<InvalidOperationException>(() => array.Min());
+                            }
+                            else
+                            {
+                                var xs = await array.ToUniTaskAsyncEnumerable().MinAsync();
+                                var ys = array.Min();
+                                xs.Should().Be(ys);
+                            }
+                        }
+                        {
+                            if (array.Length == 0)
+                            {
+                                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().MinAsync(x => x * 2));
+                                Assert.Throws<InvalidOperationException>(() => array.Min(x => x * 2));
+                            }
+                            else
+                            {
+                                var xs = await array.ToUniTaskAsyncEnumerable().MinAsync(x => x * 2);
+                                var ys = array.Min(x => x * 2);
+                                xs.Should().Be(ys);
+                            }
+                        }
+                    }
+                    break;
+                case int?[] array:
+                    {
+                        {
+                            var xs = await array.ToUniTaskAsyncEnumerable().MinAsync();
+                            var ys = array.Min();
+                            xs.Should().Be(ys);
+                        }
+                        {
+                            var xs = await array.ToUniTaskAsyncEnumerable().MinAsync(x => x);
+                            var ys = array.Min(x => x);
+                            xs.Should().Be(ys);
+                        }
+                    }
+                    break;
+                case X[] array:
+                    {
+                        {
+                            var xs = await array.ToUniTaskAsyncEnumerable().MinAsync();
+                            var ys = array.Min();
+                            xs.Should().Be(ys);
+                        }
+                        {
+
+                            if (array.Length == 0)
+                            {
+                                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().MinAsync(x => x.Value));
+                                Assert.Throws<InvalidOperationException>(() => array.Min(x => x.Value));
+                            }
+                            else
+                            {
+                                var xs = await array.ToUniTaskAsyncEnumerable().MinAsync(x => x.Value);
+                                var ys = array.Min(x => x.Value);
+                                xs.Should().Be(ys);
+                            }
+                        }
+                    }
+                    break;
+                case XX[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().MinAsync(x => x.Value);
+                        var ys = array.Min(x => x.Value);
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+
+
+        [Theory]
+        [MemberData(nameof(array2))]
+        public async Task Max<T>(T arr)
+        {
+            switch (arr)
+            {
+                case int[] array:
+                    {
+                        {
+                            if (array.Length == 0)
+                            {
+                                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().MaxAsync());
+                                Assert.Throws<InvalidOperationException>(() => array.Max());
+                            }
+                            else
+                            {
+                                var xs = await array.ToUniTaskAsyncEnumerable().MaxAsync();
+                                var ys = array.Max();
+                                xs.Should().Be(ys);
+                            }
+                        }
+                        {
+                            if (array.Length == 0)
+                            {
+                                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().MaxAsync(x => x * 2));
+                                Assert.Throws<InvalidOperationException>(() => array.Max(x => x * 2));
+                            }
+                            else
+                            {
+                                var xs = await array.ToUniTaskAsyncEnumerable().MaxAsync(x => x * 2);
+                                var ys = array.Max(x => x * 2);
+                                xs.Should().Be(ys);
+                            }
+                        }
+                    }
+                    break;
+                case int?[] array:
+                    {
+                        {
+                            var xs = await array.ToUniTaskAsyncEnumerable().MaxAsync();
+                            var ys = array.Max();
+                            xs.Should().Be(ys);
+                        }
+                        {
+                            var xs = await array.ToUniTaskAsyncEnumerable().MaxAsync(x => x);
+                            var ys = array.Max(x => x);
+                            xs.Should().Be(ys);
+                        }
+                    }
+                    break;
+                case X[] array:
+                    {
+                        {
+                            var xs = await array.ToUniTaskAsyncEnumerable().MaxAsync();
+                            var ys = array.Max();
+                            xs.Should().Be(ys);
+                        }
+                        {
+
+                            if (array.Length == 0)
+                            {
+                                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().MaxAsync(x => x.Value));
+                                Assert.Throws<InvalidOperationException>(() => array.Max(x => x.Value));
+                            }
+                            else
+                            {
+                                var xs = await array.ToUniTaskAsyncEnumerable().MaxAsync(x => x.Value);
+                                var ys = array.Max(x => x.Value);
+                                xs.Should().Be(ys);
+                            }
+                        }
+                    }
+                    break;
+                case XX[] array:
+                    {
+                        var xs = await array.ToUniTaskAsyncEnumerable().MaxAsync(x => x.Value);
+                        var ys = array.Max(x => x.Value);
+                        xs.Should().Be(ys);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        public class XX
+        {
+            public readonly X Value;
+
+            public XX(X value)
+            {
+                this.Value = value;
+            }
+        }
+
+        public class X : IComparable<X>
+        {
+            public readonly int Value;
+
+            public X(int value)
+            {
+                Value = value;
+            }
+
+            public int CompareTo([AllowNull] X other)
+            {
+                return Comparer<int>.Default.Compare(Value, other.Value);
+            }
+        }
+
+
+        [Theory]
+        [InlineData(0, 10)]
+        [InlineData(0, 1)]
+        [InlineData(10, 0)]
+        [InlineData(1, 11)]
+        public async Task Count(int start, int count)
+        {
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(start, count).CountAsync();
+                var ys = Enumerable.Range(start, count).Count();
+                xs.Should().Be(ys);
+            }
+
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(start, count).CountAsync(x => x % 2 == 0);
+                var ys = Enumerable.Range(start, count).Count(x => x % 2 == 0);
+                xs.Should().Be(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(start, count).LongCountAsync();
+                var ys = Enumerable.Range(start, count).LongCount();
+                xs.Should().Be(ys);
+            }
+
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(start, count).LongCountAsync(x => x % 2 == 0);
+                var ys = Enumerable.Range(start, count).LongCount(x => x % 2 == 0);
+                xs.Should().Be(ys);
+            }
+        }
+
+
+        [Fact]
+        public async Task AggregateTest1()
+        {
+            // 0
+            await Assert.ThrowsAsync<InvalidOperationException>(async () => await new int[] { }.ToUniTaskAsyncEnumerable().AggregateAsync((x, y) => x + y));
+            Assert.Throws<InvalidOperationException>(() => new int[] { }.Aggregate((x, y) => x + y));
+
+            // 1
+            {
+                var a = await Enumerable.Range(1, 1).ToUniTaskAsyncEnumerable().AggregateAsync((x, y) => x + y);
+                var b = Enumerable.Range(1, 1).Aggregate((x, y) => x + y);
+                a.Should().Be(b);
+            }
+
+            // 2
+            {
+                var a = await Enumerable.Range(1, 2).ToUniTaskAsyncEnumerable().AggregateAsync((x, y) => x + y);
+                var b = Enumerable.Range(1, 2).Aggregate((x, y) => x + y);
+                a.Should().Be(b);
+            }
+
+            // 10
+            {
+                var a = await Enumerable.Range(1, 10).ToUniTaskAsyncEnumerable().AggregateAsync((x, y) => x + y);
+                var b = Enumerable.Range(1, 10).Aggregate((x, y) => x + y);
+                a.Should().Be(b);
+            }
+        }
+
+        [Fact]
+        public async Task AggregateTest2()
+        {
+            // 0
+            {
+                var a = await Enumerable.Range(1, 1).ToUniTaskAsyncEnumerable().AggregateAsync(1000, (x, y) => x + y);
+                var b = Enumerable.Range(1, 1).Aggregate(1000, (x, y) => x + y);
+                a.Should().Be(b);
+            }
+
+            // 1
+            {
+                var a = await Enumerable.Range(1, 1).ToUniTaskAsyncEnumerable().AggregateAsync(1000, (x, y) => x + y);
+                var b = Enumerable.Range(1, 1).Aggregate(1000, (x, y) => x + y);
+                a.Should().Be(b);
+            }
+
+            // 2
+            {
+                var a = await Enumerable.Range(1, 2).ToUniTaskAsyncEnumerable().AggregateAsync(1000, (x, y) => x + y);
+                var b = Enumerable.Range(1, 2).Aggregate(1000, (x, y) => x + y);
+                a.Should().Be(b);
+            }
+
+            // 10
+            {
+                var a = await Enumerable.Range(1, 10).ToUniTaskAsyncEnumerable().AggregateAsync(1000, (x, y) => x + y);
+                var b = Enumerable.Range(1, 10).Aggregate(1000, (x, y) => x + y);
+                a.Should().Be(b);
+            }
+        }
+
+        [Fact]
+        public async Task AggregateTest3()
+        {
+            // 0
+            {
+                var a = await Enumerable.Range(1, 1).ToUniTaskAsyncEnumerable().AggregateAsync(1000, (x, y) => x + y, x => (x * 99).ToString());
+                var b = Enumerable.Range(1, 1).Aggregate(1000, (x, y) => x + y, x => (x * 99).ToString());
+                a.Should().Be(b);
+            }
+
+            // 1
+            {
+                var a = await Enumerable.Range(1, 1).ToUniTaskAsyncEnumerable().AggregateAsync(1000, (x, y) => x + y, x => (x * 99).ToString());
+                var b = Enumerable.Range(1, 1).Aggregate(1000, (x, y) => x + y, x => (x * 99).ToString());
+                a.Should().Be(b);
+            }
+
+            // 2
+            {
+                var a = await Enumerable.Range(1, 2).ToUniTaskAsyncEnumerable().AggregateAsync(1000, (x, y) => x + y, x => (x * 99).ToString());
+                var b = Enumerable.Range(1, 2).Aggregate(1000, (x, y) => x + y, x => (x * 99).ToString());
+                a.Should().Be(b);
+            }
+
+            // 10
+            {
+                var a = await Enumerable.Range(1, 10).ToUniTaskAsyncEnumerable().AggregateAsync(1000, (x, y) => x + y, x => (x * 99).ToString());
+                var b = Enumerable.Range(1, 10).Aggregate(1000, (x, y) => x + y, x => (x * 99).ToString());
+                a.Should().Be(b);
+            }
+        }
+
+        [Fact]
+        public async Task ForEach()
+        {
+            var list = new List<int>();
+            await Enumerable.Range(1, 10).ToUniTaskAsyncEnumerable().ForEachAsync(x =>
+            {
+                list.Add(x);
+            });
+
+            list.Should().BeEquivalentTo(Enumerable.Range(1, 10));
+
+            var list2 = new List<(int, int)>();
+            await Enumerable.Range(5, 10).ToUniTaskAsyncEnumerable().ForEachAsync((index, x) =>
+            {
+                list2.Add((index, x));
+            });
+
+            var list3 = Enumerable.Range(5, 10).Select((index, x) => (index, x)).ToArray();
+            list2.Should().BeEquivalentTo(list3);
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/AllAny.cs

@@ -0,0 +1,112 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+
+namespace NetCoreTests.Linq
+{
+    public class AllAny
+    {
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(1, 1)]
+        [InlineData(1, 2)]
+        [InlineData(1, 3)]
+        [InlineData(0, 10)]
+        [InlineData(0, 11)]
+        public async Task AllTest(int start, int count)
+        {
+            var range = Enumerable.Range(start, count);
+            var x = await range.ToUniTaskAsyncEnumerable().AllAsync(x => x % 2 == 0);
+            var y = range.All(x => x % 2 == 0);
+
+            x.Should().Be(y);
+        }
+
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(1, 1)]
+        [InlineData(1, 2)]
+        [InlineData(1, 3)]
+        [InlineData(0, 10)]
+        [InlineData(0, 11)]
+        public async Task AnyTest(int start, int count)
+        {
+            var range = Enumerable.Range(start, count);
+            {
+                var x = await range.ToUniTaskAsyncEnumerable().AnyAsync();
+                var y = range.Any();
+
+                x.Should().Be(y);
+            }
+            {
+                var x = await range.ToUniTaskAsyncEnumerable().AnyAsync(x => x % 2 == 0);
+                var y = range.Any(x => x % 2 == 0);
+
+                x.Should().Be(y);
+            }
+        }
+
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(1, 1)]
+        [InlineData(1, 2)]
+        [InlineData(1, 3)]
+        [InlineData(0, 10)]
+        [InlineData(0, 11)]
+        public async Task ContainsTest(int start, int count)
+        {
+            var range = Enumerable.Range(start, count);
+            foreach (var c in Enumerable.Range(0, 15))
+            {
+                var x = await range.ToUniTaskAsyncEnumerable().ContainsAsync(c);
+                var y = range.Contains(c);
+                x.Should().Be(y);
+            }
+        }
+
+        [Fact]
+        public async Task SequenceEqual()
+        {
+            // empty and empty
+            (await new int[0].ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[0].ToUniTaskAsyncEnumerable())).Should().BeTrue();
+            (new int[0].SequenceEqual(new int[0])).Should().BeTrue();
+
+            // empty and exists
+            (await new int[0].ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[] { 1 }.ToUniTaskAsyncEnumerable())).Should().BeFalse();
+            (new int[0].SequenceEqual(new int[] { 1 })).Should().BeFalse();
+
+            // exists and empty
+            (await new int[] { 1 }.ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[0].ToUniTaskAsyncEnumerable())).Should().BeFalse();
+            (new int[] { 1 }.SequenceEqual(new int[] { })).Should().BeFalse();
+
+            // samelength same value
+            (await new int[] { 1, 2, 3 }.ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[] { 1, 2, 3 }.ToUniTaskAsyncEnumerable())).Should().BeTrue();
+            (new int[] { 1, 2, 3 }.SequenceEqual(new int[] { 1, 2, 3 })).Should().BeTrue();
+
+            // samelength different value(first)
+            (await new int[] { 5, 2, 3 }.ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[] { 1, 2, 3 }.ToUniTaskAsyncEnumerable())).Should().BeFalse();
+
+            // samelength different value(middle)
+            (await new int[] { 1, 2, 3 }.ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[] { 1, 5, 3 }.ToUniTaskAsyncEnumerable())).Should().BeFalse();
+
+            // samelength different value(last)
+            (await new int[] { 1, 2, 3 }.ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[] { 1, 2, 5 }.ToUniTaskAsyncEnumerable())).Should().BeFalse();
+
+            // left is long
+            (await new int[] { 1, 2, 3, 4 }.ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[] { 1, 2, 3 }.ToUniTaskAsyncEnumerable())).Should().BeFalse();
+            (new int[] { 1, 2, 3, 4 }.SequenceEqual(new int[] { 1, 2, 3 })).Should().BeFalse();
+
+            // right is long
+            (await new int[] { 1, 2, 3 }.ToUniTaskAsyncEnumerable().SequenceEqualAsync(new int[] { 1, 2, 3, 4 }.ToUniTaskAsyncEnumerable())).Should().BeFalse();
+            (new int[] { 1, 2, 3 }.SequenceEqual(new int[] { 1, 2, 3, 4 })).Should().BeFalse();
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/Concat.cs

@@ -0,0 +1,144 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+
+namespace NetCoreTests.Linq
+{
+    public class Concat
+    {
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(0, 2)]
+        [InlineData(0, 10)]
+        public async Task Append(int start, int count)
+        {
+            var xs = await Enumerable.Range(start, count).ToUniTaskAsyncEnumerable().Append(99).ToArrayAsync();
+            var ys = Enumerable.Range(start, count).Append(99).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task AppendThrow()
+        {
+            var xs = UniTaskTestException.ThrowImmediate().Append(99).ToArrayAsync();
+            await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+
+            var ys = UniTaskTestException.ThrowAfter().Append(99).ToArrayAsync();
+            await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+
+            var zs = UniTaskTestException.ThrowInMoveNext().Append(99).ToArrayAsync();
+            await Assert.ThrowsAsync<UniTaskTestException>(async () => await zs);
+        }
+
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(0, 2)]
+        [InlineData(0, 10)]
+        public async Task Prepend(int start, int count)
+        {
+            var xs = await Enumerable.Range(start, count).ToUniTaskAsyncEnumerable().Prepend(99).ToArrayAsync();
+            var ys = Enumerable.Range(start, count).Prepend(99).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task PrependThrow()
+        {
+            var xs = UniTaskTestException.ThrowImmediate().Prepend(99).ToArrayAsync();
+            await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+
+            var ys = UniTaskTestException.ThrowAfter().Prepend(99).ToArrayAsync();
+            await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+
+            var zs = UniTaskTestException.ThrowInMoveNext().Prepend(99).ToArrayAsync();
+            await Assert.ThrowsAsync<UniTaskTestException>(async () => await zs);
+        }
+
+        public static IEnumerable<object[]> array1 = new object[][]
+        {
+            new object[] { (0, 0), (0, 0) }, // empty + empty
+            new object[] { (0, 1), (0, 0) }, // 1 + empty
+            new object[] { (0, 0), (0, 1) }, // empty + 1
+            new object[] { (0, 5), (0, 0) }, // 5 + empty
+            new object[] { (0, 0), (0, 5) }, // empty + 5
+            new object[] { (0, 5), (0, 5) }, // 5 + 5
+        };
+
+        [Theory]
+        [MemberData(nameof(array1))]
+        public async Task ConcatTest((int, int) left, (int, int) right)
+        {
+            var l = Enumerable.Range(left.Item1, left.Item2);
+            var r = Enumerable.Range(right.Item1, right.Item2);
+
+            var xs = await l.ToUniTaskAsyncEnumerable().Concat(r.ToUniTaskAsyncEnumerable()).ToArrayAsync();
+            var ys = l.Concat(r).ToArray();
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task ConcatThrow()
+        {
+            {
+                var xs = UniTaskTestException.ThrowImmediate().Concat(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+
+                var ys = UniTaskTestException.ThrowAfter().Concat(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+
+                var zs = UniTaskTestException.ThrowInMoveNext().Concat(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await zs);
+            }
+            {
+                var xs = UniTaskAsyncEnumerable.Range(1, 10).Concat(UniTaskTestException.ThrowImmediate()).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+
+                var ys = UniTaskAsyncEnumerable.Range(1, 10).Concat(UniTaskTestException.ThrowAfter()).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+
+                var zs = UniTaskAsyncEnumerable.Range(1, 10).Concat(UniTaskTestException.ThrowInMoveNext()).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await zs);
+            }
+        }
+
+        [Fact]
+        public async Task DefaultIfEmpty()
+        {
+            {
+                var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().DefaultIfEmpty(99).ToArrayAsync();
+                var ys = Enumerable.Range(1, 0).DefaultIfEmpty(99).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await Enumerable.Range(1, 1).ToUniTaskAsyncEnumerable().DefaultIfEmpty(99).ToArrayAsync();
+                var ys = Enumerable.Range(1, 1).DefaultIfEmpty(99).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await Enumerable.Range(1, 10).ToUniTaskAsyncEnumerable().DefaultIfEmpty(99).ToArrayAsync();
+                var ys = Enumerable.Range(1, 10).DefaultIfEmpty(99).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            // Throw
+            {
+                foreach (var item in UniTaskTestException.Throws())
+                {
+                    var xs = item.DefaultIfEmpty().ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+            }
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/Convert.cs

@@ -0,0 +1,196 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class Convert
+    {
+        [Fact]
+        public async Task ToAsyncEnumerable()
+        {
+            {
+                var xs = await Enumerable.Range(1, 100).ToUniTaskAsyncEnumerable().ToArrayAsync();
+
+                xs.Length.Should().Be(100);
+            }
+            {
+                var xs = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().ToArrayAsync();
+
+                xs.Length.Should().Be(0);
+            }
+        }
+
+
+        [Fact]
+        public async Task ToObservable()
+        {
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, 10).ToObservable().ToArray();
+                xs.Should().BeEquivalentTo(Enumerable.Range(1, 10));
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, 0).ToObservable().ToArray();
+                xs.Should().BeEquivalentTo(Enumerable.Range(1, 0));
+            }
+        }
+
+
+        [Fact]
+        public async Task ToAsyncEnumerableTask()
+        {
+            var t = Task.FromResult(100);
+            var xs = await t.ToUniTaskAsyncEnumerable().ToArrayAsync();
+
+            xs.Length.Should().Be(1);
+            xs[0].Should().Be(100);
+        }
+
+        [Fact]
+        public async Task ToAsyncEnumerableUniTask()
+        {
+            var t = UniTask.FromResult(100);
+            var xs = await t.ToUniTaskAsyncEnumerable().ToArrayAsync();
+
+            xs.Length.Should().Be(1);
+            xs[0].Should().Be(100);
+        }
+
+        [Fact]
+        public async Task ToAsyncEnumerableObservable()
+        {
+            {
+                var xs = await Observable.Range(1, 100).ToUniTaskAsyncEnumerable().ToArrayAsync();
+                var ys = await Observable.Range(1, 100).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+
+            {
+                var xs = await Observable.Range(1, 100, ThreadPoolScheduler.Instance).ToUniTaskAsyncEnumerable().ToArrayAsync();
+                var ys = await Observable.Range(1, 100, ThreadPoolScheduler.Instance).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+
+            {
+                var xs = await Observable.Empty<int>(ThreadPoolScheduler.Instance).ToUniTaskAsyncEnumerable().ToArrayAsync();
+                var ys = await Observable.Empty<int>(ThreadPoolScheduler.Instance).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+
+        [Fact]
+        public async Task ToDictionary()
+        {
+            {
+                var xs = await Enumerable.Range(1, 100).ToUniTaskAsyncEnumerable().ToDictionaryAsync(x => x);
+                var ys = Enumerable.Range(1, 100).ToDictionary(x => x);
+
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+            {
+                var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToDictionaryAsync(x => x);
+                var ys = Enumerable.Range(1, 0).ToDictionary(x => x);
+
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+            {
+                var xs = await Enumerable.Range(1, 100).ToUniTaskAsyncEnumerable().ToDictionaryAsync(x => x, x => x * 2);
+                var ys = Enumerable.Range(1, 100).ToDictionary(x => x, x => x * 2);
+
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+            {
+                var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToDictionaryAsync(x => x, x => x * 2);
+                var ys = Enumerable.Range(1, 0).ToDictionary(x => x, x => x * 2);
+
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+        }
+
+        [Fact]
+        public async Task ToLookup()
+        {
+            var arr = new[] { 1, 4, 10, 10, 4, 5, 10, 9 };
+            {
+                var xs = await arr.ToUniTaskAsyncEnumerable().ToLookupAsync(x => x);
+                var ys = arr.ToLookup(x => x);
+
+                xs.Count.Should().Be(ys.Count);
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                foreach (var key in xs.Select(x => x.Key))
+                {
+                    xs[key].Should().BeEquivalentTo(ys[key]);
+                }
+            }
+            {
+                var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToLookupAsync(x => x);
+                var ys = Enumerable.Range(1, 0).ToLookup(x => x);
+
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+            {
+                var xs = await arr.ToUniTaskAsyncEnumerable().ToLookupAsync(x => x, x => x * 2);
+                var ys = arr.ToLookup(x => x, x => x * 2);
+
+                xs.Count.Should().Be(ys.Count);
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                foreach (var key in xs.Select(x => x.Key))
+                {
+                    xs[key].Should().BeEquivalentTo(ys[key]);
+                }
+            }
+            {
+                var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToLookupAsync(x => x, x => x * 2);
+                var ys = Enumerable.Range(1, 0).ToLookup(x => x, x => x * 2);
+
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+        }
+
+        [Fact]
+        public async Task ToList()
+        {
+            {
+                var xs = await Enumerable.Range(1, 100).ToUniTaskAsyncEnumerable().ToListAsync();
+                var ys = Enumerable.Range(1, 100).ToList();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().ToListAsync();
+                var ys = Enumerable.Empty<int>().ToList();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+
+        [Fact]
+        public async Task ToHashSet()
+        {
+            {
+                var xs = await new[] { 1, 20, 4, 5, 20, 4, 6 }.ToUniTaskAsyncEnumerable().ToHashSetAsync();
+                var ys = new[] { 1, 20, 4, 5, 20, 4, 6 }.ToHashSet();
+
+                xs.OrderBy(x => x).Should().BeEquivalentTo(ys.OrderBy(x => x));
+            }
+            {
+                var xs = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().ToHashSetAsync();
+                var ys = Enumerable.Empty<int>().ToHashSet();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+    }
+
+
+}

src/UniTask.NetCoreTests/Linq/Factory.cs

@@ -0,0 +1,66 @@
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class Factory
+    {
+        [Theory]
+        [InlineData(0, 10)]
+        [InlineData(0, 0)]
+        [InlineData(1, 5)]
+        [InlineData(1, 0)]
+        [InlineData(0, 11)]
+        [InlineData(1, 11)]
+        public async Task RangeTest(int start, int count)
+        {
+            var xs = await UniTaskAsyncEnumerable.Range(start, count).ToArrayAsync();
+            var ys = Enumerable.Range(start, count).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Theory]
+        [InlineData("foo", 0)]
+        [InlineData("bar", 1)]
+        [InlineData("baz", 3)]
+        [InlineData("foobar", 10)]
+        [InlineData("foobarbaz", 11)]
+        public async Task RepeatTest(string value, int count)
+        {
+            var xs = await UniTaskAsyncEnumerable.Repeat(value, count).ToArrayAsync();
+            var ys = Enumerable.Repeat(value, count).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task EmptyTest()
+        {
+            var xs = await UniTaskAsyncEnumerable.Empty<int>().ToArrayAsync();
+            var ys = Enumerable.Empty<int>().ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Theory]
+        [InlineData(100)]
+        [InlineData((string)null)]
+        [InlineData("foo")]
+        public async Task ReturnTest<T>(T value)
+        {
+            var xs = await UniTaskAsyncEnumerable.Return(value).ToArrayAsync();
+
+            xs.Length.Should().Be(1);
+            xs[0].Should().Be(value);
+        }
+
+    }
+
+
+}

src/UniTask.NetCoreTests/Linq/Filtering.cs

@@ -0,0 +1,118 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+
+namespace NetCoreTests.Linq
+{
+    public class Filtering
+    {
+        [Fact]
+        public async Task Where()
+        {
+            var range = Enumerable.Range(1, 10);
+            var src = range.ToUniTaskAsyncEnumerable();
+
+            {
+                var a = await src.Where(x => x % 2 == 0).ToArrayAsync();
+                var expected = range.Where(x => x % 2 == 0).ToArray();
+                a.Should().BeEquivalentTo(expected);
+            }
+            {
+                var a = await src.Where((x, i) => (x + i) % 2 == 0).ToArrayAsync();
+                var expected = range.Where((x, i) => (x + i) % 2 == 0).ToArray();
+                a.Should().BeEquivalentTo(expected);
+            }
+            {
+                var a = await src.WhereAwait(x => UniTask.Run(() => x % 2 == 0)).ToArrayAsync();
+                var b = await src.WhereAwait(x => UniTask.FromResult(x % 2 == 0)).ToArrayAsync();
+                var expected = range.Where(x => x % 2 == 0).ToArray();
+                a.Should().BeEquivalentTo(expected);
+                b.Should().BeEquivalentTo(expected);
+            }
+            {
+                var a = await src.WhereAwait((x, i) => UniTask.Run(() => (x + i) % 2 == 0)).ToArrayAsync();
+                var b = await src.WhereAwait((x, i) => UniTask.FromResult((x + i) % 2 == 0)).ToArrayAsync();
+                var expected = range.Where((x, i) => (x + i) % 2 == 0).ToArray();
+                a.Should().BeEquivalentTo(expected);
+                b.Should().BeEquivalentTo(expected);
+            }
+        }
+
+
+        [Fact]
+        public async Task WhereException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                {
+                    var xs = item.Where(x => x % 2 == 0).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.Where((x, i) => x % 2 == 0).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.WhereAwait(x => UniTask.FromResult(x % 2 == 0)).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.WhereAwait((x, i) => UniTask.FromResult(x % 2 == 0)).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+            }
+        }
+
+        [Fact]
+        public async Task OfType()
+        {
+            var data = new object[] { 0, null, 10, 30, null, "foo", 99 };
+
+            var a = await data.ToUniTaskAsyncEnumerable().OfType<int>().ToArrayAsync();
+            var b = data.OfType<int>().ToArray();
+
+            a.Should().BeEquivalentTo(b);
+        }
+
+
+        [Fact]
+        public async Task OfTypeException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Select(x => (object)x).OfType<int>().ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+        [Fact]
+        public async Task Cast()
+        {
+            var data = new object[] { 0, 10, 30, 99 };
+
+            var a = await data.ToUniTaskAsyncEnumerable().Cast<int>().ToArrayAsync();
+            var b = data.Cast<int>().ToArray();
+
+            a.Should().BeEquivalentTo(b);
+        }
+
+
+        [Fact]
+        public async Task CastException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Select(x => (object)x).Cast<int>().ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/FirstLast.cs

@@ -0,0 +1,258 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class FirstLast
+    {
+        [Fact]
+        public async Task FirstTest()
+        {
+            {
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().FirstAsync());
+                Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<int>().First());
+
+                var x = await new[] { 99 }.ToUniTaskAsyncEnumerable().FirstAsync();
+                var y = new[] { 99 }.First();
+                x.Should().Be(y);
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().FirstAsync(x => x % 98 == 0));
+                Assert.Throws<InvalidOperationException>(() => array.First(x => x % 98 == 0));
+
+                var x = await array.ToUniTaskAsyncEnumerable().FirstAsync(x => x % 2 == 0);
+                var y = array.First(x => x % 2 == 0);
+                x.Should().Be(y);
+            }
+
+            {
+                var x = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().FirstOrDefaultAsync();
+                var y = Enumerable.Empty<int>().FirstOrDefault();
+                x.Should().Be(y);
+            }
+            {
+                var x = await new[] { 99 }.ToUniTaskAsyncEnumerable().FirstOrDefaultAsync();
+                var y = new[] { 99 }.FirstOrDefault();
+                x.Should().Be(y);
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                var x = await array.ToUniTaskAsyncEnumerable().FirstOrDefaultAsync(x => x % 98 == 0);
+                var y = array.FirstOrDefault(x => x % 98 == 0);
+                x.Should().Be(y);
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                var x = await array.ToUniTaskAsyncEnumerable().FirstAsync(x => x % 2 == 0);
+                var y = array.FirstOrDefault(x => x % 2 == 0);
+                x.Should().Be(y);
+            }
+        }
+
+        [Fact]
+        public async Task LastTest()
+        {
+            {
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().LastAsync());
+                Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<int>().Last());
+
+                var x = await new[] { 99 }.ToUniTaskAsyncEnumerable().LastAsync();
+                var y = new[] { 99 }.Last();
+                x.Should().Be(y);
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().LastAsync(x => x % 98 == 0));
+                Assert.Throws<InvalidOperationException>(() => array.Last(x => x % 98 == 0));
+
+                var x = await array.ToUniTaskAsyncEnumerable().LastAsync(x => x % 2 == 0);
+                var y = array.Last(x => x % 2 == 0);
+                x.Should().Be(y);
+            }
+
+            {
+                var x = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().LastOrDefaultAsync();
+                var y = Enumerable.Empty<int>().LastOrDefault();
+                x.Should().Be(y);
+            }
+            {
+                var x = await new[] { 99 }.ToUniTaskAsyncEnumerable().LastOrDefaultAsync();
+                var y = new[] { 99 }.LastOrDefault();
+                x.Should().Be(y);
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                var x = await array.ToUniTaskAsyncEnumerable().LastOrDefaultAsync(x => x % 98 == 0);
+                var y = array.LastOrDefault(x => x % 98 == 0);
+                x.Should().Be(y);
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                var x = await array.ToUniTaskAsyncEnumerable().LastOrDefaultAsync(x => x % 2 == 0);
+                var y = array.LastOrDefault(x => x % 2 == 0);
+                x.Should().Be(y);
+            }
+        }
+
+        [Fact]
+        public async Task SingleTest()
+        {
+            {
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().SingleAsync());
+                Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<int>().Single());
+
+                var x = await new[] { 99 }.ToUniTaskAsyncEnumerable().SingleAsync();
+                var y = new[] { 99 }.Single();
+                x.Should().Be(y);
+
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().SingleAsync());
+                Assert.Throws<InvalidOperationException>(() => array.Single());
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                // not found
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().SingleAsync(x => x % 999 == 0));
+                Assert.Throws<InvalidOperationException>(() => array.Single(x => x % 999 == 0));
+                // found multi
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().SingleAsync(x => x % 2 == 0));
+                Assert.Throws<InvalidOperationException>(() => array.Single(x => x % 2 == 0));
+
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().SingleAsync(x => x % 144 == 0);
+                    var y = array.Single(x => x % 144 == 0);
+                    x.Should().Be(y);
+                }
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().SingleAsync(x => x % 800 == 0);
+                    var y = array.Single(x => x % 800 == 0);
+                    x.Should().Be(y);
+                }
+            }
+
+            {
+                {
+                    var x = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().SingleOrDefaultAsync();
+                    var y = Enumerable.Empty<int>().SingleOrDefault();
+                    x.Should().Be(y);
+                }
+                {
+                    var x = await new[] { 99 }.ToUniTaskAsyncEnumerable().SingleOrDefaultAsync();
+                    var y = new[] { 99 }.SingleOrDefault();
+                    x.Should().Be(y);
+
+                    var array = new[] { 99, 11, 135, 10, 144, 800 };
+                    await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().SingleOrDefaultAsync());
+                    Assert.Throws<InvalidOperationException>(() => array.SingleOrDefault());
+                }
+                {
+                    var array = new[] { 99, 11, 135, 10, 144, 800 };
+                    // not found
+                    {
+                        var x = await array.ToUniTaskAsyncEnumerable().SingleOrDefaultAsync(x => x % 999 == 0);
+                        var y = array.SingleOrDefault(x => x % 999 == 0);
+                        x.Should().Be(y);
+                    }
+                    // found multi
+                    await Assert.ThrowsAsync<InvalidOperationException>(async () => await array.ToUniTaskAsyncEnumerable().SingleOrDefaultAsync(x => x % 2 == 0));
+                    Assert.Throws<InvalidOperationException>(() => array.SingleOrDefault(x => x % 2 == 0));
+
+                    // normal
+                    {
+                        var x = await array.ToUniTaskAsyncEnumerable().SingleOrDefaultAsync(x => x % 144 == 0);
+                        var y = array.SingleOrDefault(x => x % 144 == 0);
+                        x.Should().Be(y);
+                    }
+                    {
+                        var x = await array.ToUniTaskAsyncEnumerable().SingleOrDefaultAsync(x => x % 800 == 0);
+                        var y = array.SingleOrDefault(x => x % 800 == 0);
+                        x.Should().Be(y);
+                    }
+                }
+            }
+        }
+
+
+        [Fact]
+        public async Task ElementAtTest()
+        {
+            {
+                await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().ElementAtAsync(0));
+                Assert.Throws<ArgumentOutOfRangeException>(() => Enumerable.Empty<int>().ElementAt(0));
+
+                var x = await new[] { 99 }.ToUniTaskAsyncEnumerable().ElementAtAsync(0);
+                var y = new[] { 99 }.ElementAt(0);
+                x.Should().Be(y);
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await array.ToUniTaskAsyncEnumerable().ElementAtAsync(10));
+                Assert.Throws<ArgumentOutOfRangeException>(() => array.ElementAt(10));
+
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().ElementAtAsync(0);
+                    var y = array.ElementAt(0);
+                    x.Should().Be(y);
+                }
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().ElementAtAsync(3);
+                    var y = array.ElementAt(3);
+                    x.Should().Be(y);
+                }
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().ElementAtAsync(5);
+                    var y = array.ElementAt(5);
+                    x.Should().Be(y);
+                }
+            }
+
+
+            {
+                {
+                    var x = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().ElementAtOrDefaultAsync(0);
+                    var y = Enumerable.Empty<int>().ElementAtOrDefault(0);
+                    x.Should().Be(y);
+                }
+                {
+                    var x = await new[] { 99 }.ToUniTaskAsyncEnumerable().ElementAtOrDefaultAsync(0);
+                    var y = new[] { 99 }.ElementAtOrDefault(0);
+                    x.Should().Be(y);
+                }
+            }
+            {
+                var array = new[] { 99, 11, 135, 10, 144, 800 };
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().ElementAtOrDefaultAsync(10);
+                    var y = array.ElementAtOrDefault(10);
+                    x.Should().Be(y);
+                }
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().ElementAtOrDefaultAsync(0);
+                    var y = array.ElementAtOrDefault(0);
+                    x.Should().Be(y);
+                }
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().ElementAtOrDefaultAsync(3);
+                    var y = array.ElementAtOrDefault(3);
+                    x.Should().Be(y);
+                }
+                {
+                    var x = await array.ToUniTaskAsyncEnumerable().ElementAtOrDefaultAsync(5);
+                    var y = array.ElementAtOrDefault(5);
+                    x.Should().Be(y);
+                }
+            }
+        }
+    }
+
+
+}

src/UniTask.NetCoreTests/Linq/Joins.cs

@@ -0,0 +1,253 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+
+namespace NetCoreTests.Linq
+{
+    public class Joins
+    {
+        static int rd;
+
+        static UniTask<T> RandomRun<T>(T value)
+        {
+            if (Interlocked.Increment(ref rd) % 2 == 0)
+            {
+                return UniTask.Run(() => value);
+            }
+            else
+            {
+                return UniTask.FromResult(value);
+            }
+        }
+
+        [Fact]
+        public async Task Join()
+        {
+            var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 };
+            var inner = new[] { 1, 2, 1, 2, 1, 14, 2 };
+
+            var xs = await outer.ToUniTaskAsyncEnumerable().Join(inner.ToUniTaskAsyncEnumerable(), x => x, x => x, (x, y) => (x, y)).ToArrayAsync();
+            var ys = outer.Join(inner, x => x, x => x, (x, y) => (x, y)).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+
+        [Fact]
+        public async Task JoinThrow()
+        {
+            var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 };
+            var inner = new[] { 1, 2, 1, 2, 1, 14, 2 };
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = outer.ToUniTaskAsyncEnumerable().Join(item, x => x, x => x, (x, y) => x + y).ToArrayAsync();
+                var ys = item.Join(inner.ToUniTaskAsyncEnumerable(), x => x, x => x, (x, y) => x + y).ToArrayAsync();
+
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+            }
+        }
+
+        [Fact]
+        public async Task JoinAwait()
+        {
+            var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 };
+            var inner = new[] { 1, 2, 1, 2, 1, 14, 2 };
+
+            var xs = await outer.ToUniTaskAsyncEnumerable().JoinAwait(inner.ToUniTaskAsyncEnumerable(), x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun((x, y))).ToArrayAsync();
+            var ys = outer.Join(inner, x => x, x => x, (x, y) => (x, y)).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+
+        [Fact]
+        public async Task JoinAwaitThrow()
+        {
+            var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 };
+            var inner = new[] { 1, 2, 1, 2, 1, 14, 2 };
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = outer.ToUniTaskAsyncEnumerable().JoinAwait(item, x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun(x + y)).ToArrayAsync();
+                var ys = item.Join(inner.ToUniTaskAsyncEnumerable(), x => x, x => x, (x, y) => x + y).ToArrayAsync();
+
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+            }
+        }
+
+        [Fact]
+        public async Task JoinAwaitCt()
+        {
+            var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 };
+            var inner = new[] { 1, 2, 1, 2, 1, 14, 2 };
+
+            var xs = await outer.ToUniTaskAsyncEnumerable().JoinAwaitWithCancellation(inner.ToUniTaskAsyncEnumerable(), (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun((x, y))).ToArrayAsync();
+            var ys = outer.Join(inner, x => x, x => x, (x, y) => (x, y)).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+
+        [Fact]
+        public async Task JoinAwaitCtThrow()
+        {
+            var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 };
+            var inner = new[] { 1, 2, 1, 2, 1, 14, 2 };
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = outer.ToUniTaskAsyncEnumerable().JoinAwaitWithCancellation(item, (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun(x + y)).ToArrayAsync();
+                var ys = item.JoinAwaitWithCancellation(inner.ToUniTaskAsyncEnumerable(), (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun(x + y)).ToArrayAsync();
+
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+            }
+        }
+
+
+        [Fact]
+        public async Task GroupBy()
+        {
+            var arr = new[] { 1, 4, 10, 10, 4, 5, 10, 9 };
+            {
+                var xs = await arr.ToUniTaskAsyncEnumerable().GroupBy(x => x).ToArrayAsync();
+                var ys = arr.GroupBy(x => x).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+
+            {
+                var xs = await arr.ToUniTaskAsyncEnumerable().GroupBy(x => x, (key, xs) => (key, xs.ToArray())).ToArrayAsync();
+                var ys = arr.GroupBy(x => x, (key, xs) => (key, xs.ToArray())).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().BeEquivalentTo(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
+            }
+
+            {
+                var xs = await arr.ToUniTaskAsyncEnumerable().GroupByAwait(x => RandomRun(x)).ToArrayAsync();
+                var ys = arr.GroupBy(x => x).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+
+            {
+                var xs = await arr.ToUniTaskAsyncEnumerable().GroupByAwait(x => RandomRun(x), (key, xs) => RandomRun((key, xs.ToArray()))).ToArrayAsync();
+                var ys = arr.GroupBy(x => x, (key, xs) => (key, xs.ToArray())).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().BeEquivalentTo(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
+            }
+
+            {
+                var xs = await arr.ToUniTaskAsyncEnumerable().GroupByAwaitWithCancellation((x, _) => RandomRun(x)).ToArrayAsync();
+                var ys = arr.GroupBy(x => x).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+            }
+
+            {
+                var xs = await arr.ToUniTaskAsyncEnumerable().GroupByAwaitWithCancellation((x, _) => RandomRun(x), (key, xs, _) => RandomRun((key, xs.ToArray()))).ToArrayAsync();
+                var ys = arr.GroupBy(x => x, (key, xs) => (key, xs.ToArray())).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().BeEquivalentTo(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
+            }
+        }
+
+
+
+
+        [Fact]
+        public async Task GroupByThrow()
+        {
+            var arr = new[] { 1, 4, 10, 10, 4, 5, 10, 9 };
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.GroupBy(x => x).ToArrayAsync();
+                var ys = item.GroupByAwait(x => RandomRun(x)).ToArrayAsync();
+                var zs = item.GroupByAwaitWithCancellation((x, _) => RandomRun(x)).ToArrayAsync();
+
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await zs);
+            }
+        }
+
+
+
+        [Fact]
+        public async Task GroupJoin()
+        {
+            var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 };
+            var inner = new[] { 1, 2, 1, 2, 1, 14, 2 };
+            
+            {
+                var xs = await outer.ToUniTaskAsyncEnumerable().GroupJoin(inner.ToUniTaskAsyncEnumerable(), x => x, x => x, (x, y) => (x, string.Join(", ", y))).ToArrayAsync();
+                var ys = outer.GroupJoin(inner, x => x, x => x, (x, y) => (x, string.Join(", ", y))).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await outer.ToUniTaskAsyncEnumerable().GroupJoinAwait(inner.ToUniTaskAsyncEnumerable(), x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun((x, string.Join(", ", y)))).ToArrayAsync();
+                var ys = outer.GroupJoin(inner, x => x, x => x, (x, y) => (x, string.Join(", ", y))).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await outer.ToUniTaskAsyncEnumerable().GroupJoinAwaitWithCancellation(inner.ToUniTaskAsyncEnumerable(), (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun((x, string.Join(", ", y)))).ToArrayAsync();
+                var ys = outer.GroupJoin(inner, x => x, x => x, (x, y) => (x, string.Join(", ", y))).ToArray();
+
+                xs.Length.Should().Be(ys.Length);
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+
+
+        [Fact]
+        public async Task GroupJoinThrow()
+        {
+
+            var outer = new[] { 1, 2, 4, 5, 8, 10, 14, 4, 8, 1, 2, 10 }.ToUniTaskAsyncEnumerable();
+            var inner = new[] { 1, 2, 1, 2, 1, 14, 2 }.ToUniTaskAsyncEnumerable();
+
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                {
+                    var xs = item.GroupJoin(outer, x => x, x => x, (x, y) => x).ToArrayAsync();
+                    var ys = inner.GroupJoin(item, x => x, x => x, (x, y) => x).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+                }
+                {
+                    var xs = item.GroupJoinAwait(outer, x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun(x)).ToArrayAsync();
+                    var ys = inner.GroupJoinAwait(item, x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun(x)).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+                }
+                {
+                    var xs = item.GroupJoinAwaitWithCancellation(outer, (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun(x)).ToArrayAsync();
+                    var ys = inner.GroupJoinAwaitWithCancellation(item, (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun(x)).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+                }
+            }
+        }
+
+
+    }
+}

src/UniTask.NetCoreTests/Linq/Paging.cs

@@ -0,0 +1,285 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+
+namespace NetCoreTests.Linq
+{
+    public class Paging
+    {
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(9, 0)]
+        [InlineData(9, 1)]
+        [InlineData(9, 5)]
+        [InlineData(9, 9)]
+        [InlineData(9, 15)]
+        public async Task Skip(int collection, int skipCount)
+        {
+            var xs = await UniTaskAsyncEnumerable.Range(1, collection).Skip(skipCount).ToArrayAsync();
+            var ys = Enumerable.Range(1, collection).Skip(skipCount).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task SkipException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Skip(5).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(9, 0)]
+        [InlineData(9, 1)]
+        [InlineData(9, 5)]
+        [InlineData(9, 9)]
+        [InlineData(9, 15)]
+        public async Task SkipLast(int collection, int skipCount)
+        {
+            var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipLast(skipCount).ToArrayAsync();
+            var ys = Enumerable.Range(1, collection).SkipLast(skipCount).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task SkipLastException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SkipLast(5).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(9, 0)]
+        [InlineData(9, 1)]
+        [InlineData(9, 5)]
+        [InlineData(9, 9)]
+        [InlineData(9, 15)]
+        public async Task TakeLast(int collection, int takeCount)
+        {
+            var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeLast(takeCount).ToArrayAsync();
+            var ys = Enumerable.Range(1, collection).TakeLast(takeCount).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task TakeLastException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.TakeLast(5).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(9, 0)]
+        [InlineData(9, 1)]
+        [InlineData(9, 5)]
+        [InlineData(9, 9)]
+        [InlineData(9, 15)]
+        public async Task Take(int collection, int takeCount)
+        {
+            var xs = await UniTaskAsyncEnumerable.Range(1, collection).Take(takeCount).ToArrayAsync();
+            var ys = Enumerable.Range(1, collection).Take(takeCount).ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task TakeException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Take(5).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(9, 0)]
+        [InlineData(9, 1)]
+        [InlineData(9, 5)]
+        [InlineData(9, 9)]
+        [InlineData(9, 15)]
+        public async Task SkipWhile(int collection, int skipCount)
+        {
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhile(x => x < skipCount).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).SkipWhile(x => x < skipCount).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhile((x, i) => x < (skipCount - i)).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).SkipWhile((x, i) => x < (skipCount - i)).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhileAwait(x => UniTask.Run(() => x < skipCount)).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).SkipWhile(x => x < skipCount).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhileAwait((x, i) => UniTask.Run(() => x < (skipCount - i))).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).SkipWhile((x, i) => x < (skipCount - i)).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < skipCount)).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).SkipWhile(x => x < skipCount).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < (skipCount - i))).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).SkipWhile((x, i) => x < (skipCount - i)).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+
+        [Fact]
+        public async Task SkipWhileException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SkipWhile(x => x < 2).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SkipWhile((x, i) => x < 2).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SkipWhileAwait((x) => UniTask.Run(() => x < 2)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SkipWhileAwait((x, i) => UniTask.Run(() => x < 2)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SkipWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < 2)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SkipWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < 2)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(9, 0)]
+        [InlineData(9, 1)]
+        [InlineData(9, 5)]
+        [InlineData(9, 9)]
+        [InlineData(9, 15)]
+        public async Task TakeWhile(int collection, int skipCount)
+        {
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhile(x => x < skipCount).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).TakeWhile(x => x < skipCount).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhile((x, i) => x < (skipCount - i)).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).TakeWhile((x, i) => x < (skipCount - i)).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhileAwait(x => UniTask.Run(() => x < skipCount)).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).TakeWhile(x => x < skipCount).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhileAwait((x, i) => UniTask.Run(() => x < (skipCount - i))).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).TakeWhile((x, i) => x < (skipCount - i)).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < skipCount)).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).TakeWhile(x => x < skipCount).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < (skipCount - i))).ToArrayAsync();
+                var ys = Enumerable.Range(1, collection).TakeWhile((x, i) => x < (skipCount - i)).ToArray();
+
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+
+        [Fact]
+        public async Task TakeWhileException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.TakeWhile(x => x < 5).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.TakeWhile((x, i) => x < 5).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.TakeWhileAwait((x) => UniTask.Run(() => x < 5)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.TakeWhileAwait((x, i) => UniTask.Run(() => x < 5)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.TakeWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < 5)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.TakeWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < 5)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/Projection.cs

@@ -0,0 +1,323 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+
+namespace NetCoreTests.Linq
+{
+    public class Projection
+    {
+        [Theory]
+        [InlineData(0, 0)]
+        [InlineData(0, 1)]
+        [InlineData(0, 2)]
+        [InlineData(0, 10)]
+        public async Task Reverse(int start, int count)
+        {
+            var xs = await Enumerable.Range(start, count).ToUniTaskAsyncEnumerable().Reverse().ToArrayAsync();
+            var ys = Enumerable.Range(start, count).Reverse().ToArray();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task ReverseException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Reverse().ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(9)]
+        public async Task Select(int count)
+        {
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, count).Select(x => x * x).ToArrayAsync();
+                var ys = Enumerable.Range(1, count).Select(x => x * x).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+
+                var zs = await UniTaskAsyncEnumerable.Range(1, count).SelectAwait((x) => UniTask.Run(() => x * x)).ToArrayAsync();
+                zs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, count).Select((x, i) => x * x * i).ToArrayAsync();
+                var ys = Enumerable.Range(1, count).Select((x, i) => x * x * i).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+
+                var zs = await UniTaskAsyncEnumerable.Range(1, count).SelectAwait((x, i) => UniTask.Run(() => x * x * i)).ToArrayAsync();
+                zs.Should().BeEquivalentTo(ys);
+            }
+        }
+
+
+        [Fact]
+        public async Task SelectException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Select(x => UniTaskAsyncEnumerable.Range(0, 1)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+
+            // await
+
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SelectAwait(x => UniTask.Run(() => UniTaskAsyncEnumerable.Range(0, 1))).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+
+            // cancel
+
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SelectAwaitWithCancellation((x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(0, 1))).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+
+        [Theory]
+        [InlineData(0, 9)] // empty + exists
+        [InlineData(9, 0)] // exists + empty
+        [InlineData(9, 9)] // exists + exists
+        public async Task SelectMany(int leftCount, int rightCount)
+        {
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectMany(x => UniTaskAsyncEnumerable.Range(99, rightCount * x)).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectMany((i, x) => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x)).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectMany(x => UniTaskAsyncEnumerable.Range(99, rightCount * x), (x, y) => x * y).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x), (x, y) => x * y).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectMany((i, x) => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x), (x, y) => x * y).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x), (x, y) => x * y).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+
+            // await
+
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwait(x => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99, rightCount * x))).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwait((i, x) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x))).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwait(x => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99, rightCount * x)), (x, y) => UniTask.Run(() => x * y)).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x), (x, y) => x * y).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwait((i, x) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x)), (x, y) => UniTask.Run(() => x * y)).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x), (x, y) => x * y).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+
+            // with cancel
+
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99, rightCount * x))).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwaitWithCancellation((i, x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x))).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99, rightCount * x)), (x, y, _) => UniTask.Run(() => x * y)).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x), (x, y) => x * y).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwaitWithCancellation((i, x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x)), (x, y, _) => UniTask.Run(() => x * y)).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x), (x, y) => x * y).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+
+        [Fact]
+        public async Task SelectManyException()
+        {
+            // error + exists
+            // exists + error
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SelectMany(x => UniTaskAsyncEnumerable.Range(0, 1)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectMany(x => item).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+
+            // await
+
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SelectManyAwait(x => UniTask.Run(() => UniTaskAsyncEnumerable.Range(0, 1))).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectManyAwait(x => UniTask.Run(() => item)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+
+            // with c
+
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(0, 1))).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => item)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+
+
+        [Theory]
+        [InlineData(0, 9)] // empty + exists
+        [InlineData(9, 0)] // exists + empty
+        [InlineData(9, 9)] // same
+        [InlineData(9, 4)] // leftlong
+        [InlineData(4, 9)] // rightlong
+        public async Task Zip(int leftCount, int rightCount)
+        {
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).Zip(UniTaskAsyncEnumerable.Range(99, rightCount)).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).Zip(Enumerable.Range(99, rightCount)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).ZipAwait(UniTaskAsyncEnumerable.Range(99, rightCount), (x, y) => UniTask.Run(() => (x, y))).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).Zip(Enumerable.Range(99, rightCount)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).ZipAwaitWithCancellation(UniTaskAsyncEnumerable.Range(99, rightCount), (x, y, _) => UniTask.Run(() => (x, y))).ToArrayAsync();
+                var ys = Enumerable.Range(1, leftCount).Zip(Enumerable.Range(99, rightCount)).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+        [Fact]
+        public async Task ZipException()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Zip(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Range(1, 10).Zip(item).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+
+            // a
+
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.ZipAwait(UniTaskAsyncEnumerable.Range(1, 10), (x, y) => UniTask.Run(() => (x, y))).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Range(1, 10).ZipAwait(item, (x, y) => UniTask.Run(() => (x, y))).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+
+            // c
+
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.ZipAwaitWithCancellation(UniTaskAsyncEnumerable.Range(1, 10), (x, y, c) => UniTask.Run(() => (x, y))).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Range(1, 10).ZipAwaitWithCancellation(item, (x, y, c) => UniTask.Run(() => (x, y))).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+        [Theory]
+        // [InlineData(0, 0)]
+        [InlineData(0, 3)]
+        [InlineData(9, 1)]
+        [InlineData(9, 2)]
+        [InlineData(9, 3)]
+        [InlineData(17, 3)]
+        [InlineData(17, 16)]
+        [InlineData(17, 17)]
+        [InlineData(17, 27)]
+        public async Task Buffer(int rangeCount, int bufferCount)
+        {
+            var xs = await UniTaskAsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount).Select(x => string.Join(",", x)).ToArrayAsync();
+            var ys = await AsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount).Select(x => string.Join(",", x)).ToArrayAsync();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Theory]
+        // [InlineData(0, 0)]
+        [InlineData(0, 3, 2)]
+        [InlineData(9, 1, 1)]
+        [InlineData(9, 2, 3)]
+        [InlineData(9, 3, 4)]
+        [InlineData(17, 3, 3)]
+        [InlineData(17, 16, 5)]
+        [InlineData(17, 17, 19)]
+        public async Task BufferSkip(int rangeCount, int bufferCount, int skipCount)
+        {
+            var xs = await UniTaskAsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount, skipCount).Select(x => string.Join(",", x)).ToArrayAsync();
+            var ys = await AsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount, skipCount).Select(x => string.Join(",", x)).ToArrayAsync();
+
+            xs.Should().BeEquivalentTo(ys);
+        }
+
+        [Fact]
+        public async Task BufferError()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Buffer(3).ToArrayAsync();
+                var ys = item.Buffer(3, 2).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await ys);
+            }
+        }
+    }
+}

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/QueueTest.cs

@@ -0,0 +1,29 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class QueueTest
+    {
+        [Fact]
+        public async Task Q()
+        {
+            var rp = new AsyncReactiveProperty<int>(100);
+
+            var l = new List<int>();
+            await rp.Take(10).Queue().ForEachAsync(x =>
+            {
+                rp.Value += 10;
+                l.Add(x);
+            });
+
+            l.Should().BeEquivalentTo(100, 110, 120, 130, 140, 150, 160, 170, 180, 190);
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/Sets.cs

@@ -0,0 +1,193 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+
+namespace NetCoreTests.Linq
+{
+    public class Sets
+    {
+        public static IEnumerable<object[]> array1 = new object[][]
+        {
+            new object[] { new int[] { } }, // empty
+            new object[] { new int[] { 1, 2, 3 } }, // no dup
+            new object[] { new int[] { 1, 2, 3, 3, 4, 5, 2 } }, // dup
+        };
+
+        public static IEnumerable<object[]> array2 = new object[][]
+        {
+            new object[] { new int[] { } }, // empty
+            new object[] { new int[] { 1, 2 } },
+            new object[] { new int[] { 1, 2, 4, 5, 9 } }, // dup
+        };
+
+        [Theory]
+        [MemberData(nameof(array1))]
+        public async Task Distinct(int[] array)
+        {
+            var ys = array.Distinct().ToArray();
+            {
+                (await array.ToUniTaskAsyncEnumerable().Distinct().ToArrayAsync()).Should().BeEquivalentTo(ys);
+                (await array.ToUniTaskAsyncEnumerable().Distinct(x => x).ToArrayAsync()).Should().BeEquivalentTo(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctAwait(x => UniTask.Run(() => x)).ToArrayAsync()).Should().BeEquivalentTo(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync()).Should().BeEquivalentTo(ys);
+            }
+        }
+
+        [Fact]
+        public async Task DistinctThrow()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                {
+                    var xs = item.Distinct().ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.Distinct(x => x).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.DistinctAwait(x => UniTask.Run(() => x)).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.DistinctAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(array1))]
+        public async Task DistinctUntilChanged(int[] array)
+        {
+            var ys = await array.ToAsyncEnumerable().DistinctUntilChanged().ToArrayAsync();
+            {
+                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChanged().ToArrayAsync()).Should().BeEquivalentTo(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChanged(x => x).ToArrayAsync()).Should().BeEquivalentTo(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChangedAwait(x => UniTask.Run(() => x)).ToArrayAsync()).Should().BeEquivalentTo(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChangedAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync()).Should().BeEquivalentTo(ys);
+            }
+        }
+
+        [Fact]
+        public async Task DistinctUntilChangedThrow()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                {
+                    var xs = item.DistinctUntilChanged().ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.DistinctUntilChanged(x => x).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.DistinctUntilChangedAwait(x => UniTask.Run(() => x)).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+                {
+                    var xs = item.DistinctUntilChangedAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync();
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+                }
+            }
+        }
+
+
+        [Fact]
+        public async Task Except()
+        {
+            foreach (var a1 in array1.First().Cast<int[]>())
+            {
+                foreach (var a2 in array2.First().Cast<int[]>())
+                {
+                    var xs = await a1.ToUniTaskAsyncEnumerable().Except(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync();
+                    var ys = a1.Except(a2).ToArray();
+                    xs.Should().BeEquivalentTo(ys);
+                }
+            }
+        }
+
+        [Fact]
+        public async Task ExceptThrow()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Except(UniTaskAsyncEnumerable.Return(10)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Return(10).Except(item).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+        [Fact]
+        public async Task Intersect()
+        {
+            foreach (var a1 in array1.First().Cast<int[]>())
+            {
+                foreach (var a2 in array2.First().Cast<int[]>())
+                {
+                    var xs = await a1.ToUniTaskAsyncEnumerable().Intersect(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync();
+                    var ys = a1.Intersect(a2).ToArray();
+                    xs.Should().BeEquivalentTo(ys);
+                }
+            }
+        }
+
+        [Fact]
+        public async Task IntersectThrow()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Intersect(UniTaskAsyncEnumerable.Return(10)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Return(10).Intersect(item).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+
+        [Fact]
+        public async Task Union()
+        {
+            foreach (var a1 in array1.First().Cast<int[]>())
+            {
+                foreach (var a2 in array2.First().Cast<int[]>())
+                {
+                    var xs = await a1.ToUniTaskAsyncEnumerable().Union(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync();
+                    var ys = a1.Union(a2).ToArray();
+                    xs.Should().BeEquivalentTo(ys);
+                }
+            }
+        }
+
+        [Fact]
+        public async Task UnionThrow()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = item.Union(UniTaskAsyncEnumerable.Return(10)).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                var xs = UniTaskAsyncEnumerable.Return(10).Union(item).ToArrayAsync();
+                await Assert.ThrowsAsync<UniTaskTestException>(async () => await xs);
+            }
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/Sort.cs

@@ -0,0 +1,221 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+
+namespace NetCoreTests.Linq
+{
+    public class SortCheck
+    {
+        public int Age { get; set; }
+        public string FirstName { get; set; }
+        public string LastName { get; set; }
+
+        public override string ToString()
+        {
+            return (Age, FirstName, LastName).ToString();
+        }
+    }
+
+    public class Sort
+    {
+        static int rd;
+
+        static UniTask<T> RandomRun<T>(T value)
+        {
+            if (Interlocked.Increment(ref rd) % 2 == 0)
+            {
+                return UniTask.Run(() => value);
+            }
+            else
+            {
+                return UniTask.FromResult(value);
+            }
+        }
+        static UniTask<T> RandomRun<T>(T value, CancellationToken ct)
+        {
+            if (Interlocked.Increment(ref rd) % 2 == 0)
+            {
+                return UniTask.Run(() => value);
+            }
+            else
+            {
+                return UniTask.FromResult(value);
+            }
+        }
+
+        [Fact]
+        public async Task OrderBy()
+        {
+            var array = new[] { 1, 99, 32, 4, 536, 7, 8 };
+            {
+                var xs = await array.ToUniTaskAsyncEnumerable().OrderBy(x => x).ToArrayAsync();
+                var ys = array.OrderBy(x => x).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x).ToArrayAsync();
+                var ys = array.OrderByDescending(x => x).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await array.ToUniTaskAsyncEnumerable().OrderByAwait(RandomRun).ToArrayAsync();
+                var ys = array.OrderBy(x => x).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(RandomRun).ToArrayAsync();
+                var ys = array.OrderByDescending(x => x).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await array.ToUniTaskAsyncEnumerable().OrderByAwaitWithCancellation(RandomRun).ToArrayAsync();
+                var ys = array.OrderBy(x => x).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+            {
+                var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation(RandomRun).ToArrayAsync();
+                var ys = array.OrderByDescending(x => x).ToArray();
+                xs.Should().BeEquivalentTo(ys);
+            }
+        }
+
+        [Fact]
+        public async Task ThenBy()
+        {
+            var array = new[]
+            {
+                new SortCheck { Age = 99, FirstName = "ABC", LastName = "DEF" },
+                new SortCheck { Age = 49, FirstName = "ABC", LastName = "DEF" },
+                new SortCheck { Age = 49, FirstName = "ABC", LastName = "ZKH" },
+                new SortCheck { Age = 12, FirstName = "ABC", LastName = "DEF" },
+                new SortCheck { Age = 49, FirstName = "ABC", LastName = "MEF" },
+                new SortCheck { Age = 12, FirstName = "QQQ", LastName = "DEF" },
+                new SortCheck { Age = 19, FirstName = "ZKN", LastName = "DEF" },
+                new SortCheck { Age = 39, FirstName = "APO", LastName = "REF" },
+                new SortCheck { Age = 59, FirstName = "ABC", LastName = "DEF" },
+                new SortCheck { Age = 99, FirstName = "DBC", LastName = "DEF" },
+                new SortCheck { Age = 99, FirstName = "DBC", LastName = "MEF" },
+            };
+            {
+                var a = array.OrderBy(x => x.Age).ThenBy(x => x.FirstName).ThenBy(x => x.LastName).ToArray();
+                var b = array.OrderBy(x => x.Age).ThenBy(x => x.FirstName).ThenByDescending(x => x.LastName).ToArray();
+                var c = array.OrderBy(x => x.Age).ThenByDescending(x => x.FirstName).ThenBy(x => x.LastName).ToArray();
+                var d = array.OrderBy(x => x.Age).ThenByDescending(x => x.FirstName).ThenByDescending(x => x.LastName).ToArray();
+                var e = array.OrderByDescending(x => x.Age).ThenBy(x => x.FirstName).ThenBy(x => x.LastName).ToArray();
+                var f = array.OrderByDescending(x => x.Age).ThenBy(x => x.FirstName).ThenByDescending(x => x.LastName).ToArray();
+                var g = array.OrderByDescending(x => x.Age).ThenByDescending(x => x.FirstName).ThenBy(x => x.LastName).ToArray();
+                var h = array.OrderByDescending(x => x.Age).ThenByDescending(x => x.FirstName).ThenByDescending(x => x.LastName).ToArray();
+
+                {
+                    var a2 = await array.ToUniTaskAsyncEnumerable().OrderBy(x => x.Age).ThenBy(x => x.FirstName).ThenBy(x => x.LastName).ToArrayAsync();
+                    var b2 = await array.ToUniTaskAsyncEnumerable().OrderBy(x => x.Age).ThenBy(x => x.FirstName).ThenByDescending(x => x.LastName).ToArrayAsync();
+                    var c2 = await array.ToUniTaskAsyncEnumerable().OrderBy(x => x.Age).ThenByDescending(x => x.FirstName).ThenBy(x => x.LastName).ToArrayAsync();
+                    var d2 = await array.ToUniTaskAsyncEnumerable().OrderBy(x => x.Age).ThenByDescending(x => x.FirstName).ThenByDescending(x => x.LastName).ToArrayAsync();
+                    var e2 = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x.Age).ThenBy(x => x.FirstName).ThenBy(x => x.LastName).ToArrayAsync();
+                    var f2 = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x.Age).ThenBy(x => x.FirstName).ThenByDescending(x => x.LastName).ToArrayAsync();
+                    var g2 = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x.Age).ThenByDescending(x => x.FirstName).ThenBy(x => x.LastName).ToArrayAsync();
+                    var h2 = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x.Age).ThenByDescending(x => x.FirstName).ThenByDescending(x => x.LastName).ToArrayAsync();
+
+                    a.Should().BeEquivalentTo(a2);
+                    b.Should().BeEquivalentTo(b2);
+                    c.Should().BeEquivalentTo(c2);
+                    d.Should().BeEquivalentTo(d2);
+                    e.Should().BeEquivalentTo(e2);
+                    f.Should().BeEquivalentTo(f2);
+                    g.Should().BeEquivalentTo(g2);
+                    h.Should().BeEquivalentTo(h2);
+                }
+                {
+                    var a2 = await array.ToUniTaskAsyncEnumerable().OrderByAwait(x => RandomRun(x.Age)).ThenByAwait(x => RandomRun(x.FirstName)).ThenByAwait(x => RandomRun(x.LastName)).ToArrayAsync();
+                    var b2 = await array.ToUniTaskAsyncEnumerable().OrderByAwait(x => RandomRun(x.Age)).ThenByAwait(x => RandomRun(x.FirstName)).ThenByDescendingAwait(x => RandomRun(x.LastName)).ToArrayAsync();
+                    var c2 = await array.ToUniTaskAsyncEnumerable().OrderByAwait(x => RandomRun(x.Age)).ThenByDescendingAwait(x => RandomRun(x.FirstName)).ThenByAwait(x => RandomRun(x.LastName)).ToArrayAsync();
+                    var d2 = await array.ToUniTaskAsyncEnumerable().OrderByAwait(x => RandomRun(x.Age)).ThenByDescendingAwait(x => RandomRun(x.FirstName)).ThenByDescendingAwait(x => RandomRun(x.LastName)).ToArrayAsync();
+                    var e2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(x => RandomRun(x.Age)).ThenByAwait(x => RandomRun(x.FirstName)).ThenByAwait(x => RandomRun(x.LastName)).ToArrayAsync();
+                    var f2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(x => RandomRun(x.Age)).ThenByAwait(x => RandomRun(x.FirstName)).ThenByDescendingAwait(x => RandomRun(x.LastName)).ToArrayAsync();
+                    var g2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(x => RandomRun(x.Age)).ThenByDescendingAwait(x => RandomRun(x.FirstName)).ThenByAwait(x => RandomRun(x.LastName)).ToArrayAsync();
+                    var h2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(x => RandomRun(x.Age)).ThenByDescendingAwait(x => RandomRun(x.FirstName)).ThenByDescendingAwait(x => RandomRun(x.LastName)).ToArrayAsync();
+
+                    a.Should().BeEquivalentTo(a2);
+                    b.Should().BeEquivalentTo(b2);
+                    c.Should().BeEquivalentTo(c2);
+                    d.Should().BeEquivalentTo(d2);
+                    e.Should().BeEquivalentTo(e2);
+                    f.Should().BeEquivalentTo(f2);
+                    g.Should().BeEquivalentTo(g2);
+                    h.Should().BeEquivalentTo(h2);
+                }
+                {
+                    var a2 = await array.ToUniTaskAsyncEnumerable().OrderByAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
+                    var b2 = await array.ToUniTaskAsyncEnumerable().OrderByAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
+                    var c2 = await array.ToUniTaskAsyncEnumerable().OrderByAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
+                    var d2 = await array.ToUniTaskAsyncEnumerable().OrderByAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
+                    var e2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
+                    var f2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
+                    var g2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
+                    var h2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
+
+                    a.Should().BeEquivalentTo(a2);
+                    b.Should().BeEquivalentTo(b2);
+                    c.Should().BeEquivalentTo(c2);
+                    d.Should().BeEquivalentTo(d2);
+                    e.Should().BeEquivalentTo(e2);
+                    f.Should().BeEquivalentTo(f2);
+                    g.Should().BeEquivalentTo(g2);
+                    h.Should().BeEquivalentTo(h2);
+                }
+            }
+        }
+
+
+        [Fact]
+        public async Task Throws()
+        {
+            foreach (var item in UniTaskTestException.Throws())
+            {
+                {
+                    var a = item.OrderBy(x => x).ToArrayAsync();
+                    var b = item.OrderByDescending(x => x).ToArrayAsync();
+                    var c = item.OrderBy(x => x).ThenBy(x => x).ToArrayAsync();
+                    var d = item.OrderBy(x => x).ThenByDescending(x => x).ToArrayAsync();
+
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await a);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await b);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await c);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await d);
+                }
+                {
+                    var a = item.OrderByAwait(RandomRun).ToArrayAsync();
+                    var b = item.OrderByDescendingAwait(RandomRun).ToArrayAsync();
+                    var c = item.OrderByAwait(RandomRun).ThenByAwait(RandomRun).ToArrayAsync();
+                    var d = item.OrderByAwait(RandomRun).ThenByDescendingAwait(RandomRun).ToArrayAsync();
+
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await a);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await b);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await c);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await d);
+                }
+                {
+                    var a = item.OrderByAwaitWithCancellation(RandomRun).ToArrayAsync();
+                    var b = item.OrderByDescendingAwaitWithCancellation(RandomRun).ToArrayAsync();
+                    var c = item.OrderByAwaitWithCancellation(RandomRun).ThenByAwaitWithCancellation(RandomRun).ToArrayAsync();
+                    var d = item.OrderByAwaitWithCancellation(RandomRun).ThenByDescendingAwaitWithCancellation(RandomRun).ToArrayAsync();
+
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await a);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await b);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await c);
+                    await Assert.ThrowsAsync<UniTaskTestException>(async () => await d);
+                }
+            }
+
+        }
+    }
+}

src/UniTask.NetCoreTests/Linq/TakeInfinityTest.cs

@@ -0,0 +1,106 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace NetCoreTests.Linq
+{
+    public class TakeInfinityTest
+    {
+        [Fact]
+        public async Task Take()
+        {
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.Take(5).ToArrayAsync();
+
+            rp.Value = 2;
+            rp.Value = 3;
+            rp.Value = 4;
+            rp.Value = 5;
+
+            (await xs).Should().BeEquivalentTo(1, 2, 3, 4, 5);
+        }
+
+        [Fact]
+        public async Task TakeWhile()
+        {
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.TakeWhile(x => x != 5).ToArrayAsync();
+
+            rp.Value = 2;
+            rp.Value = 3;
+            rp.Value = 4;
+            rp.Value = 5;
+
+            (await xs).Should().BeEquivalentTo(1, 2, 3, 4);
+        }
+
+        [Fact]
+        public async Task TakeUntil()
+        {
+            var cts = new CancellationTokenSource();
+
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.TakeUntilCanceled(cts.Token).ToArrayAsync();
+
+            var c = CancelAsync();
+
+            await c;
+            var foo = await xs;
+
+            foo.Should().BeEquivalentTo(new[] { 1, 10, 20 });
+
+            async Task CancelAsync()
+            {
+                rp.Value = 10;
+                await Task.Yield();
+                rp.Value = 20;
+                await Task.Yield();
+                cts.Cancel();
+                rp.Value = 30;
+                await Task.Yield();
+                rp.Value = 40;
+            }
+        }
+
+        [Fact]
+        public async Task SkipUntil()
+        {
+            var cts = new CancellationTokenSource();
+
+            var rp = new AsyncReactiveProperty<int>(1);
+
+            var xs = rp.SkipUntilCanceled(cts.Token).ToArrayAsync();
+
+            var c = CancelAsync();
+
+            await c;
+            var foo = await xs;
+
+            foo.Should().BeEquivalentTo(new[] { 30, 40 });
+
+            async Task CancelAsync()
+            {
+                rp.Value = 10;
+                await Task.Yield();
+                rp.Value = 20;
+                await Task.Yield();
+                cts.Cancel();
+                rp.Value = 30;
+                await Task.Yield();
+                rp.Value = 40;
+
+                rp.Dispose(); // complete.
+            }
+        }
+
+    }
+}

src/UniTask.NetCoreTests/Linq/_Exception.cs

@@ -0,0 +1,126 @@
+using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks.Linq;
+using System;
+using System.Collections.Generic;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+
+namespace NetCoreTests.Linq
+{
+    public class UniTaskTestException : Exception
+    {
+        public static IUniTaskAsyncEnumerable<int> ThrowImmediate()
+        {
+            return UniTaskAsyncEnumerable.Throw<int>(new UniTaskTestException());
+        }
+        public static IUniTaskAsyncEnumerable<int> ThrowAfter()
+        {
+            return new ThrowAfter<int>(new UniTaskTestException());
+        }
+        public static IUniTaskAsyncEnumerable<int> ThrowInMoveNext()
+        {
+            return new ThrowIn<int>(new UniTaskTestException());
+        }
+
+
+        public static IEnumerable<IUniTaskAsyncEnumerable<int>> Throws(int count = 3)
+        {
+            yield return ThrowImmediate();
+            yield return ThrowAfter();
+            yield return ThrowInMoveNext();
+            yield return UniTaskAsyncEnumerable.Range(1, count).Concat(ThrowImmediate());
+            yield return UniTaskAsyncEnumerable.Range(1, count).Concat(ThrowAfter());
+            yield return UniTaskAsyncEnumerable.Range(1, count).Concat(ThrowInMoveNext());
+        }
+    }
+
+    internal class ThrowIn<TValue> : IUniTaskAsyncEnumerable<TValue>
+    {
+        readonly Exception exception;
+
+        public ThrowIn(Exception exception)
+        {
+            this.exception = exception;
+        }
+
+        public IUniTaskAsyncEnumerator<TValue> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new Enumerator(exception, cancellationToken);
+        }
+
+        class Enumerator : IUniTaskAsyncEnumerator<TValue>
+        {
+            readonly Exception exception;
+            CancellationToken cancellationToken;
+
+            public Enumerator(Exception exception, CancellationToken cancellationToken)
+            {
+                this.exception = exception;
+                this.cancellationToken = cancellationToken;
+            }
+
+            public TValue Current => default;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                ExceptionDispatchInfo.Capture(exception).Throw();
+                return new UniTask<bool>(false);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return default;
+            }
+        }
+    }
+
+    internal class ThrowAfter<TValue> : IUniTaskAsyncEnumerable<TValue>
+    {
+        readonly Exception exception;
+
+        public ThrowAfter(Exception exception)
+        {
+            this.exception = exception;
+        }
+
+        public IUniTaskAsyncEnumerator<TValue> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new Enumerator(exception, cancellationToken);
+        }
+
+        class Enumerator : IUniTaskAsyncEnumerator<TValue>
+        {
+            readonly Exception exception;
+            CancellationToken cancellationToken;
+
+            public Enumerator(Exception exception, CancellationToken cancellationToken)
+            {
+                this.exception = exception;
+                this.cancellationToken = cancellationToken;
+            }
+
+            public TValue Current => default;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var tcs = new UniTaskCompletionSource<bool>();
+
+                var awaiter = UniTask.Yield().GetAwaiter();
+                awaiter.UnsafeOnCompleted(() =>
+                {
+                    Thread.Sleep(1);
+                    tcs.TrySetException(exception);
+                });
+
+                return tcs.Task;
+            }
+
+            public UniTask DisposeAsync()
+            {
+                return default;
+            }
+        }
+    }
+}

src/UniTask.NetCoreTests/UniTask.NetCoreTests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
@@ -9,10 +9,20 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
-    <PackageReference Include="coverlet.collector" Version="1.0.1" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
+    <PackageReference Include="System.Interactive.Async" Version="4.1.1" />
+    <PackageReference Include="System.Linq.Async" Version="4.1.1" />
+    <PackageReference Include="System.Reactive" Version="4.4.1" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\UniTask.NetCore\UniTask.NetCore.csproj" />
   </ItemGroup>
 
 </Project>

src/UniTask.NetCoreTests/UnitTest1.cs

@@ -1,14 +0,0 @@
-using System;
-using Xunit;
-
-namespace UniTask.NetCoreTests
-{
-    public class UnitTest1
-    {
-        [Fact]
-        public void Test1()
-        {
-
-        }
-    }
-}

src/UniTask/Assets/Editor/PackageExporter.cs

@@ -11,9 +11,11 @@ public static class PackageExporter
     [MenuItem("Tools/Export Unitypackage")]
     public static void Export()
     {
-        // configure
         var root = "Plugins/UniTask";
-        var exportPath = "./UniTask.unitypackage";
+        var version = GetVersion(root);
+
+        var fileName = string.IsNullOrEmpty(version) ? "UniTask.unitypackage" : $"UniTask.{version}.unitypackage";
+        var exportPath = "./" + fileName;
 
         var path = Path.Combine(Application.dataPath, root);
         var assets = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)
@@ -30,6 +32,42 @@ public static class PackageExporter
 
         UnityEngine.Debug.Log("Export complete: " + Path.GetFullPath(exportPath));
     }
+
+    static string GetVersion(string root)
+    {
+        var version = Environment.GetEnvironmentVariable("UNITY_PACKAGE_VERSION");
+        var versionJson = Path.Combine(Application.dataPath, root, "package.json");
+
+        if (File.Exists(versionJson))
+        {
+            var v = JsonUtility.FromJson<Version>(File.ReadAllText(versionJson));
+
+            if (!string.IsNullOrEmpty(version))
+            {
+                if (v.version != version)
+                {
+                    var msg = $"package.json and env version are mismatched. UNITY_PACKAGE_VERSION:{version}, package.json:{v.version}";
+
+                    if (Application.isBatchMode)
+                    {
+                        Console.WriteLine(msg);
+                        Application.Quit(1);
+                    }
+
+                    throw new Exception("package.json and env version are mismatched.");
+                }
+            }
+
+            version = v.version;
+        }
+
+        return version;
+    }
+
+    public class Version
+    {
+        public string version;
+    }
 }
 
 #endif

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

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

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

@@ -0,0 +1,159 @@
+using Cysharp.Threading.Tasks.Linq;
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public interface IReadOnlyAsyncReactiveProperty<T> : IUniTaskAsyncEnumerable<T>
+    {
+        T Value { get; }
+        IUniTaskAsyncEnumerable<T> WithoutCurrent();
+    }
+
+    public interface IAsyncReactiveProperty<T> : IReadOnlyAsyncReactiveProperty<T>
+    {
+        new T Value { get; set; }
+    }
+
+    [Serializable]
+    public class AsyncReactiveProperty<T> : IAsyncReactiveProperty<T>, IDisposable
+    {
+        TriggerEvent<T> triggerEvent;
+
+#if UNITY_2018_3_OR_NEWER
+        [UnityEngine.SerializeField]
+#endif
+        T latestValue;
+
+        public T Value
+        {
+            get
+            {
+                return latestValue;
+            }
+            set
+            {
+                this.latestValue = value;
+                triggerEvent.SetResult(value);
+            }
+        }
+
+        public AsyncReactiveProperty(T value)
+        {
+            this.latestValue = value;
+            this.triggerEvent = default;
+        }
+
+        public IUniTaskAsyncEnumerable<T> WithoutCurrent()
+        {
+            return new WithoutCurrentEnumerable(this);
+        }
+
+        public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken)
+        {
+            return new Enumerator(this, cancellationToken, true);
+        }
+
+        public void Dispose()
+        {
+            triggerEvent.SetCompleted();
+        }
+
+        class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable<T>
+        {
+            readonly AsyncReactiveProperty<T> parent;
+
+            public WithoutCurrentEnumerable(AsyncReactiveProperty<T> parent)
+            {
+                this.parent = parent;
+            }
+
+            public IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+            {
+                return new Enumerator(parent, cancellationToken, false);
+            }
+        }
+
+        sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator<T>, ITriggerHandler<T>
+        {
+            static Action<object> cancellationCallback = CancellationCallback;
+
+            readonly AsyncReactiveProperty<T> parent;
+            readonly CancellationToken cancellationToken;
+            readonly CancellationTokenRegistration cancellationTokenRegistration;
+            T value;
+            bool isDisposed;
+            bool firstCall;
+
+            public Enumerator(AsyncReactiveProperty<T> parent, CancellationToken cancellationToken, bool publishCurrentValue)
+            {
+                this.parent = parent;
+                this.cancellationToken = cancellationToken;
+                this.firstCall = publishCurrentValue;
+
+                parent.triggerEvent.Add(this);
+                TaskTracker.TrackActiveTask(this, 3);
+
+                if (cancellationToken.CanBeCanceled)
+                {
+                    cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
+                }
+            }
+
+            public T Current => value;
+
+            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();
+            }
+        }
+    }
+}

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

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

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

@@ -1,6 +1,7 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
 using System;
+using System.Runtime.CompilerServices;
 using System.Threading;
 
 namespace Cysharp.Threading.Tasks
@@ -9,15 +10,15 @@ namespace Cysharp.Threading.Tasks
     {
         static readonly Action<object> cancellationTokenCallback = Callback;
 
-        public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cts)
+        public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cancellationToken)
         {
-            if (cts.IsCancellationRequested)
+            if (cancellationToken.IsCancellationRequested)
             {
-                return (UniTask.FromCanceled(cts), default(CancellationTokenRegistration));
+                return (UniTask.FromCanceled(cancellationToken), default(CancellationTokenRegistration));
             }
 
             var promise = new UniTaskCompletionSource();
-            return (promise.Task, cts.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, promise));
+            return (promise.Task, cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, promise));
         }
 
         static void Callback(object state)
@@ -26,6 +27,11 @@ namespace Cysharp.Threading.Tasks
             promise.TrySetResult();
         }
 
+        public static CancellationTokenAwaitable WaitUntilCanceled(this CancellationToken cancellationToken)
+        {
+            return new CancellationTokenAwaitable(cancellationToken);
+        }
+
         public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action callback)
         {
             var restoreFlow = false;
@@ -70,5 +76,46 @@ namespace Cysharp.Threading.Tasks
             }
         }
     }
+
+    public struct CancellationTokenAwaitable
+    {
+        CancellationToken cancellationToken;
+
+        public CancellationTokenAwaitable(CancellationToken cancellationToken)
+        {
+            this.cancellationToken = cancellationToken;
+        }
+
+        public Awaiter GetAwaiter()
+        {
+            return new Awaiter(cancellationToken);
+        }
+
+        public struct Awaiter : ICriticalNotifyCompletion
+        {
+            CancellationToken cancellationToken;
+
+            public Awaiter(CancellationToken cancellationToken)
+            {
+                this.cancellationToken = cancellationToken;
+            }
+
+            public bool IsCompleted => !cancellationToken.CanBeCanceled || cancellationToken.IsCancellationRequested;
+
+            public void GetResult()
+            {
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                cancellationToken.RegisterWithoutCaptureExecutionContext(continuation);
+            }
+        }
+    }
 }
 

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

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

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

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

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

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public interface IUniTaskAsyncEnumerable<out T>
+    {
+        IUniTaskAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default);
+    }
+
+    public interface IUniTaskAsyncEnumerator<out T> : IUniTaskAsyncDisposable
+    {
+        T Current { get; }
+        UniTask<bool> MoveNextAsync();
+    }
+
+    public interface IUniTaskAsyncDisposable
+    {
+        UniTask DisposeAsync();
+    }
+
+    public interface IUniTaskOrderedAsyncEnumerable<TElement> : IUniTaskAsyncEnumerable<TElement>
+    {
+        IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending);
+        IUniTaskOrderedAsyncEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, UniTask<TKey>> keySelector, IComparer<TKey> comparer, bool descending);
+        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; }
+    //}
+
+    public static class UniTaskAsyncEnumerableExtensions
+    {
+        public static UniTaskCancelableAsyncEnumerable<T> WithCancellation<T>(this IUniTaskAsyncEnumerable<T> source, CancellationToken cancellationToken)
+        {
+            return new UniTaskCancelableAsyncEnumerable<T>(source, cancellationToken);
+        }
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    public readonly struct UniTaskCancelableAsyncEnumerable<T>
+    {
+        private readonly IUniTaskAsyncEnumerable<T> enumerable;
+        private readonly CancellationToken cancellationToken;
+
+        internal UniTaskCancelableAsyncEnumerable(IUniTaskAsyncEnumerable<T> enumerable, CancellationToken cancellationToken)
+        {
+            this.enumerable = enumerable;
+            this.cancellationToken = cancellationToken;
+        }
+
+        public Enumerator GetAsyncEnumerator()
+        {
+            return new Enumerator(enumerable.GetAsyncEnumerator(cancellationToken));
+        }
+
+        [StructLayout(LayoutKind.Auto)]
+        public readonly struct Enumerator
+        {
+            private readonly IUniTaskAsyncEnumerator<T> enumerator;
+
+            internal Enumerator(IUniTaskAsyncEnumerator<T> enumerator)
+            {
+                this.enumerator = enumerator;
+            }
+
+            public T Current => enumerator.Current;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                return enumerator.MoveNextAsync();
+            }
+
+
+            public UniTask DisposeAsync()
+            {
+                return enumerator.DisposeAsync();
+            }
+        }
+    }
+}

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

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

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

@@ -32,11 +32,21 @@ namespace Cysharp.Threading.Tasks.Internal
             }
         }
 
-        public static RentArray<T> CopyToRentArray<T>(IEnumerable<T> source)
+        public static RentArray<T> Materialize<T>(IEnumerable<T> source)
         {
+            if (source is T[] array)
+            {
+                return new RentArray<T>(array, array.Length, null);
+            }
+
             var defaultCount = 32;
             if (source is ICollection<T> coll)
             {
+                if (coll.Count == 0)
+                {
+                    return new RentArray<T>(Array.Empty<T>(), 0, null);
+                }
+
                 defaultCount = coll.Count;
                 var pool = ArrayPool<T>.Shared;
                 var buffer = pool.Rent(defaultCount);

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

@@ -9,6 +9,8 @@ namespace Cysharp.Threading.Tasks.Internal
     {
         const int MaxArrayLength = 0X7FEFFFFF;
         const int InitialSize = 16;
+        
+        readonly PlayerLoopTiming timing;
 
         SpinLock gate = new SpinLock();
         bool dequing = false;
@@ -19,6 +21,11 @@ namespace Cysharp.Threading.Tasks.Internal
         int waitingListCount = 0;
         Action[] waitingList = new Action[InitialSize];
 
+        public ContinuationQueue(PlayerLoopTiming timing)
+        {
+            this.timing = timing;
+        }
+
         public void Enqueue(Action continuation)
         {
             bool lockTaken = false;
@@ -72,7 +79,80 @@ namespace Cysharp.Threading.Tasks.Internal
             waitingList = new Action[InitialSize];
         }
 
+        // delegate entrypoint.
         public void Run()
+        {
+            // for debugging, create named stacktrace.
+#if DEBUG
+            switch (timing)
+            {
+                case PlayerLoopTiming.Initialization:
+                    Initialization();
+                    break;
+                case PlayerLoopTiming.LastInitialization:
+                    LastInitialization();
+                    break;
+                case PlayerLoopTiming.EarlyUpdate:
+                    EarlyUpdate();
+                    break;
+                case PlayerLoopTiming.LastEarlyUpdate:
+                    LastEarlyUpdate();
+                    break;
+                case PlayerLoopTiming.FixedUpdate:
+                    FixedUpdate();
+                    break;
+                case PlayerLoopTiming.LastFixedUpdate:
+                    LastFixedUpdate();
+                    break;
+                case PlayerLoopTiming.PreUpdate:
+                    PreUpdate();
+                    break;
+                case PlayerLoopTiming.LastPreUpdate:
+                    LastPreUpdate();
+                    break;
+                case PlayerLoopTiming.Update:
+                    Update();
+                    break;
+                case PlayerLoopTiming.LastUpdate:
+                    LastUpdate();
+                    break;
+                case PlayerLoopTiming.PreLateUpdate:
+                    PreLateUpdate();
+                    break;
+                case PlayerLoopTiming.LastPreLateUpdate:
+                    LastPreLateUpdate();
+                    break;
+                case PlayerLoopTiming.PostLateUpdate:
+                    PostLateUpdate();
+                    break;
+                case PlayerLoopTiming.LastPostLateUpdate:
+                    LastPostLateUpdate();
+                    break;
+                default:
+                    break;
+            }
+#else
+            RunCore();
+#endif
+        }
+
+        void Initialization() => RunCore();
+        void LastInitialization() => RunCore();
+        void EarlyUpdate() => RunCore();
+        void LastEarlyUpdate() => RunCore();
+        void FixedUpdate() => RunCore();
+        void LastFixedUpdate() => RunCore();
+        void PreUpdate() => RunCore();
+        void LastPreUpdate() => RunCore();
+        void Update() => RunCore();
+        void LastUpdate() => RunCore();
+        void PreLateUpdate() => RunCore();
+        void LastPreLateUpdate() => RunCore();
+        void PostLateUpdate() => RunCore();
+        void LastPostLateUpdate() => RunCore();
+
+        [System.Diagnostics.DebuggerHidden]
+        void RunCore()
         {
             {
                 bool lockTaken = false;

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

@@ -20,6 +20,24 @@ namespace Cysharp.Threading.Tasks.Internal
             throw new ArgumentNullException(paramName);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Exception ArgumentOutOfRange(string paramName)
+        {
+            return new ArgumentOutOfRangeException(paramName);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Exception NoElements()
+        {
+            return new InvalidOperationException("Source sequence doesn't contain any elements.");
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Exception MoreThanOneElement()
+        {
+            return new InvalidOperationException("Source sequence contains more than one element.");
+        }
+
         [MethodImpl(MethodImplOptions.NoInlining)]
         public static void ThrowArgumentException<T>(string message)
         {

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

@@ -8,6 +8,7 @@ namespace Cysharp.Threading.Tasks.Internal
     {
         const int InitialSize = 16;
 
+        readonly PlayerLoopTiming timing;
         readonly object runningAndQueueLock = new object();
         readonly object arrayLock = new object();
         readonly Action<Exception> unhandledExceptionCallback;
@@ -17,9 +18,12 @@ namespace Cysharp.Threading.Tasks.Internal
         IPlayerLoopItem[] loopItems = new IPlayerLoopItem[InitialSize];
         MinimumQueue<IPlayerLoopItem> waitQueue = new MinimumQueue<IPlayerLoopItem>(InitialSize);
 
-        public PlayerLoopRunner()
+
+
+        public PlayerLoopRunner(PlayerLoopTiming timing)
         {
             this.unhandledExceptionCallback = ex => Debug.LogException(ex);
+            this.timing = timing;
         }
 
         public void AddAction(IPlayerLoopItem item)
@@ -55,7 +59,80 @@ namespace Cysharp.Threading.Tasks.Internal
             }
         }
 
+        // delegate entrypoint.
         public void Run()
+        {
+            // for debugging, create named stacktrace.
+#if DEBUG
+            switch (timing)
+            {
+                case PlayerLoopTiming.Initialization:
+                    Initialization();
+                    break;
+                case PlayerLoopTiming.LastInitialization:
+                    LastInitialization();
+                    break;
+                case PlayerLoopTiming.EarlyUpdate:
+                    EarlyUpdate();
+                    break;
+                case PlayerLoopTiming.LastEarlyUpdate:
+                    LastEarlyUpdate();
+                    break;
+                case PlayerLoopTiming.FixedUpdate:
+                    FixedUpdate();
+                    break;
+                case PlayerLoopTiming.LastFixedUpdate:
+                    LastFixedUpdate();
+                    break;
+                case PlayerLoopTiming.PreUpdate:
+                    PreUpdate();
+                    break;
+                case PlayerLoopTiming.LastPreUpdate:
+                    LastPreUpdate();
+                    break;
+                case PlayerLoopTiming.Update:
+                    Update();
+                    break;
+                case PlayerLoopTiming.LastUpdate:
+                    LastUpdate();
+                    break;
+                case PlayerLoopTiming.PreLateUpdate:
+                    PreLateUpdate();
+                    break;
+                case PlayerLoopTiming.LastPreLateUpdate:
+                    LastPreLateUpdate();
+                    break;
+                case PlayerLoopTiming.PostLateUpdate:
+                    PostLateUpdate();
+                    break;
+                case PlayerLoopTiming.LastPostLateUpdate:
+                    LastPostLateUpdate();
+                    break;
+                default:
+                    break;
+            }
+#else
+            RunCore();
+#endif
+        }
+
+        void Initialization() => RunCore();
+        void LastInitialization() => RunCore();
+        void EarlyUpdate() => RunCore();
+        void LastEarlyUpdate() => RunCore();
+        void FixedUpdate() => RunCore();
+        void LastFixedUpdate() => RunCore();
+        void PreUpdate() => RunCore();
+        void LastPreUpdate() => RunCore();
+        void Update() => RunCore();
+        void LastUpdate() => RunCore();
+        void PreLateUpdate() => RunCore();
+        void LastPreLateUpdate() => RunCore();
+        void PostLateUpdate() => RunCore();
+        void LastPostLateUpdate() => RunCore();
+
+        [System.Diagnostics.DebuggerHidden]
+        void RunCore()
         {
             lock (runningAndQueueLock)
             {

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

@@ -4,12 +4,14 @@ using System.Threading;
 
 namespace Cysharp.Threading.Tasks.Internal
 {
-    internal interface IPromisePoolItem
+    // public, allow to user create custom operator with pool.
+
+    public interface IPromisePoolItem
     {
         void Reset();
     }
 
-    internal class PromisePool<T>
+    public class PromisePool<T>
         where T : class, IPromisePoolItem
     {
         int count = 0;