Repository: Cysharp/UniTask Branch: master Commit: a9e27c03d411 Files: 511 Total size: 3.1 MB Directory structure: gitextract_puolhiam/ ├── .config/ │ └── dotnet-tools.json ├── .editorconfig ├── .github/ │ ├── FUNDING.yml │ ├── dependabot.yaml │ └── workflows/ │ ├── build-debug.yaml │ ├── build-docs.yaml │ ├── build-release.yaml │ ├── prevent-github-change.yaml │ ├── stale.yaml │ └── toc.yaml ├── .gitignore ├── Directory.Build.props ├── LICENSE ├── README.md ├── README_CN.md ├── UniTask.NetCore.sln ├── docs/ │ ├── .gitignore │ ├── api/ │ │ └── .gitignore │ ├── docfx.json │ ├── index.md │ └── toc.yml ├── opensource.snk └── src/ ├── UniTask/ │ ├── Assets/ │ │ ├── Editor/ │ │ │ ├── EditorRunnerChecker.cs │ │ │ ├── EditorRunnerChecker.cs.meta │ │ │ ├── PackageExporter.cs │ │ │ └── PackageExporter.cs.meta │ │ ├── Editor.meta │ │ ├── Plugins/ │ │ │ ├── UniTask/ │ │ │ │ ├── Editor/ │ │ │ │ │ ├── SplitterGUILayout.cs │ │ │ │ │ ├── SplitterGUILayout.cs.meta │ │ │ │ │ ├── UniTask.Editor.asmdef │ │ │ │ │ ├── UniTask.Editor.asmdef.meta │ │ │ │ │ ├── UniTaskTrackerTreeView.cs │ │ │ │ │ ├── UniTaskTrackerTreeView.cs.meta │ │ │ │ │ ├── UniTaskTrackerWindow.cs │ │ │ │ │ └── UniTaskTrackerWindow.cs.meta │ │ │ │ ├── Editor.meta │ │ │ │ ├── Runtime/ │ │ │ │ │ ├── AsyncLazy.cs │ │ │ │ │ ├── AsyncLazy.cs.meta │ │ │ │ │ ├── AsyncReactiveProperty.cs │ │ │ │ │ ├── AsyncReactiveProperty.cs.meta │ │ │ │ │ ├── AsyncUnit.cs │ │ │ │ │ ├── AsyncUnit.cs.meta │ │ │ │ │ ├── CancellationTokenEqualityComparer.cs │ │ │ │ │ ├── CancellationTokenEqualityComparer.cs.meta │ │ │ │ │ ├── CancellationTokenExtensions.cs │ │ │ │ │ ├── CancellationTokenExtensions.cs.meta │ │ │ │ │ ├── CancellationTokenSourceExtensions.cs │ │ │ │ │ ├── CancellationTokenSourceExtensions.cs.meta │ │ │ │ │ ├── Channel.cs │ │ │ │ │ ├── Channel.cs.meta │ │ │ │ │ ├── CompilerServices/ │ │ │ │ │ │ ├── AsyncMethodBuilderAttribute.cs │ │ │ │ │ │ ├── AsyncMethodBuilderAttribute.cs.meta │ │ │ │ │ │ ├── AsyncUniTaskMethodBuilder.cs │ │ │ │ │ │ ├── AsyncUniTaskMethodBuilder.cs.meta │ │ │ │ │ │ ├── AsyncUniTaskVoidMethodBuilder.cs │ │ │ │ │ │ ├── AsyncUniTaskVoidMethodBuilder.cs.meta │ │ │ │ │ │ ├── StateMachineRunner.cs │ │ │ │ │ │ └── StateMachineRunner.cs.meta │ │ │ │ │ ├── CompilerServices.meta │ │ │ │ │ ├── EnumerableAsyncExtensions.cs │ │ │ │ │ ├── EnumerableAsyncExtensions.cs.meta │ │ │ │ │ ├── EnumeratorAsyncExtensions.cs │ │ │ │ │ ├── EnumeratorAsyncExtensions.cs.meta │ │ │ │ │ ├── ExceptionExtensions.cs │ │ │ │ │ ├── ExceptionExtensions.cs.meta │ │ │ │ │ ├── External/ │ │ │ │ │ │ ├── Addressables/ │ │ │ │ │ │ │ ├── AddressablesAsyncExtensions.cs │ │ │ │ │ │ │ ├── AddressablesAsyncExtensions.cs.meta │ │ │ │ │ │ │ ├── UniTask.Addressables.asmdef │ │ │ │ │ │ │ └── UniTask.Addressables.asmdef.meta │ │ │ │ │ │ ├── Addressables.meta │ │ │ │ │ │ ├── DOTween/ │ │ │ │ │ │ │ ├── DOTweenAsyncExtensions.cs │ │ │ │ │ │ │ ├── DOTweenAsyncExtensions.cs.meta │ │ │ │ │ │ │ ├── UniTask.DOTween.asmdef │ │ │ │ │ │ │ └── UniTask.DOTween.asmdef.meta │ │ │ │ │ │ ├── DOTween.meta │ │ │ │ │ │ ├── TextMeshPro/ │ │ │ │ │ │ │ ├── TextMeshProAsyncExtensions.InputField.cs │ │ │ │ │ │ │ ├── TextMeshProAsyncExtensions.InputField.cs.meta │ │ │ │ │ │ │ ├── TextMeshProAsyncExtensions.InputField.tt │ │ │ │ │ │ │ ├── TextMeshProAsyncExtensions.InputField.tt.meta │ │ │ │ │ │ │ ├── TextMeshProAsyncExtensions.cs │ │ │ │ │ │ │ ├── TextMeshProAsyncExtensions.cs.meta │ │ │ │ │ │ │ ├── UniTask.TextMeshPro.asmdef │ │ │ │ │ │ │ └── UniTask.TextMeshPro.asmdef.meta │ │ │ │ │ │ └── TextMeshPro.meta │ │ │ │ │ ├── External.meta │ │ │ │ │ ├── IUniTaskAsyncEnumerable.cs │ │ │ │ │ ├── IUniTaskAsyncEnumerable.cs.meta │ │ │ │ │ ├── IUniTaskSource.cs │ │ │ │ │ ├── IUniTaskSource.cs.meta │ │ │ │ │ ├── Internal/ │ │ │ │ │ │ ├── ArrayPool.cs │ │ │ │ │ │ ├── ArrayPool.cs.meta │ │ │ │ │ │ ├── ArrayPoolUtil.cs │ │ │ │ │ │ ├── ArrayPoolUtil.cs.meta │ │ │ │ │ │ ├── ArrayUtil.cs │ │ │ │ │ │ ├── ArrayUtil.cs.meta │ │ │ │ │ │ ├── ContinuationQueue.cs │ │ │ │ │ │ ├── ContinuationQueue.cs.meta │ │ │ │ │ │ ├── DiagnosticsExtensions.cs │ │ │ │ │ │ ├── DiagnosticsExtensions.cs.meta │ │ │ │ │ │ ├── Error.cs │ │ │ │ │ │ ├── Error.cs.meta │ │ │ │ │ │ ├── MinimumQueue.cs │ │ │ │ │ │ ├── MinimumQueue.cs.meta │ │ │ │ │ │ ├── PlayerLoopRunner.cs │ │ │ │ │ │ ├── PlayerLoopRunner.cs.meta │ │ │ │ │ │ ├── PooledDelegate.cs │ │ │ │ │ │ ├── PooledDelegate.cs.meta │ │ │ │ │ │ ├── RuntimeHelpersAbstraction.cs │ │ │ │ │ │ ├── RuntimeHelpersAbstraction.cs.meta │ │ │ │ │ │ ├── StatePool.cs │ │ │ │ │ │ ├── StatePool.cs.meta │ │ │ │ │ │ ├── TaskTracker.cs │ │ │ │ │ │ ├── TaskTracker.cs.meta │ │ │ │ │ │ ├── UnityEqualityComparer.cs │ │ │ │ │ │ ├── UnityEqualityComparer.cs.meta │ │ │ │ │ │ ├── UnityWebRequestExtensions.cs │ │ │ │ │ │ ├── UnityWebRequestExtensions.cs.meta │ │ │ │ │ │ ├── ValueStopwatch.cs │ │ │ │ │ │ ├── ValueStopwatch.cs.meta │ │ │ │ │ │ ├── WeakDictionary.cs │ │ │ │ │ │ └── WeakDictionary.cs.meta │ │ │ │ │ ├── Internal.meta │ │ │ │ │ ├── Linq/ │ │ │ │ │ │ ├── Aggregate.cs │ │ │ │ │ │ ├── Aggregate.cs.meta │ │ │ │ │ │ ├── All.cs │ │ │ │ │ │ ├── All.cs.meta │ │ │ │ │ │ ├── Any.cs │ │ │ │ │ │ ├── Any.cs.meta │ │ │ │ │ │ ├── AppendPrepend.cs │ │ │ │ │ │ ├── AppendPrepend.cs.meta │ │ │ │ │ │ ├── AsUniTaskAsyncEnumerable.cs │ │ │ │ │ │ ├── AsUniTaskAsyncEnumerable.cs.meta │ │ │ │ │ │ ├── AsyncEnumeratorBase.cs │ │ │ │ │ │ ├── AsyncEnumeratorBase.cs.meta │ │ │ │ │ │ ├── Average.cs │ │ │ │ │ │ ├── Average.cs.meta │ │ │ │ │ │ ├── Average.tt │ │ │ │ │ │ ├── Average.tt.meta │ │ │ │ │ │ ├── Buffer.cs │ │ │ │ │ │ ├── Buffer.cs.meta │ │ │ │ │ │ ├── Cast.cs │ │ │ │ │ │ ├── Cast.cs.meta │ │ │ │ │ │ ├── CombineLatest.cs │ │ │ │ │ │ ├── CombineLatest.cs.meta │ │ │ │ │ │ ├── CombineLatest.tt │ │ │ │ │ │ ├── CombineLatest.tt.meta │ │ │ │ │ │ ├── Concat.cs │ │ │ │ │ │ ├── Concat.cs.meta │ │ │ │ │ │ ├── Contains.cs │ │ │ │ │ │ ├── Contains.cs.meta │ │ │ │ │ │ ├── Count.cs │ │ │ │ │ │ ├── Count.cs.meta │ │ │ │ │ │ ├── Create.cs │ │ │ │ │ │ ├── Create.cs.meta │ │ │ │ │ │ ├── DefaultIfEmpty.cs │ │ │ │ │ │ ├── DefaultIfEmpty.cs.meta │ │ │ │ │ │ ├── Distinct.cs │ │ │ │ │ │ ├── Distinct.cs.meta │ │ │ │ │ │ ├── DistinctUntilChanged.cs │ │ │ │ │ │ ├── DistinctUntilChanged.cs.meta │ │ │ │ │ │ ├── Do.cs │ │ │ │ │ │ ├── Do.cs.meta │ │ │ │ │ │ ├── ElementAt.cs │ │ │ │ │ │ ├── ElementAt.cs.meta │ │ │ │ │ │ ├── Empty.cs │ │ │ │ │ │ ├── Empty.cs.meta │ │ │ │ │ │ ├── Except.cs │ │ │ │ │ │ ├── Except.cs.meta │ │ │ │ │ │ ├── First.cs │ │ │ │ │ │ ├── First.cs.meta │ │ │ │ │ │ ├── ForEach.cs │ │ │ │ │ │ ├── ForEach.cs.meta │ │ │ │ │ │ ├── GroupBy.cs │ │ │ │ │ │ ├── GroupBy.cs.meta │ │ │ │ │ │ ├── GroupJoin.cs │ │ │ │ │ │ ├── GroupJoin.cs.meta │ │ │ │ │ │ ├── Intersect.cs │ │ │ │ │ │ ├── Intersect.cs.meta │ │ │ │ │ │ ├── Join.cs │ │ │ │ │ │ ├── Join.cs.meta │ │ │ │ │ │ ├── Last.cs │ │ │ │ │ │ ├── Last.cs.meta │ │ │ │ │ │ ├── LongCount.cs │ │ │ │ │ │ ├── LongCount.cs.meta │ │ │ │ │ │ ├── Max.cs │ │ │ │ │ │ ├── Max.cs.meta │ │ │ │ │ │ ├── Merge.cs │ │ │ │ │ │ ├── Merge.cs.meta │ │ │ │ │ │ ├── Min.cs │ │ │ │ │ │ ├── Min.cs.meta │ │ │ │ │ │ ├── MinMax.cs │ │ │ │ │ │ ├── MinMax.cs.meta │ │ │ │ │ │ ├── MinMax.tt │ │ │ │ │ │ ├── MinMax.tt.meta │ │ │ │ │ │ ├── Never.cs │ │ │ │ │ │ ├── Never.cs.meta │ │ │ │ │ │ ├── OfType.cs │ │ │ │ │ │ ├── OfType.cs.meta │ │ │ │ │ │ ├── OrderBy.cs │ │ │ │ │ │ ├── OrderBy.cs.meta │ │ │ │ │ │ ├── Pairwise.cs │ │ │ │ │ │ ├── Pairwise.cs.meta │ │ │ │ │ │ ├── Publish.cs │ │ │ │ │ │ ├── Publish.cs.meta │ │ │ │ │ │ ├── Queue.cs │ │ │ │ │ │ ├── Queue.cs.meta │ │ │ │ │ │ ├── Range.cs │ │ │ │ │ │ ├── Range.cs.meta │ │ │ │ │ │ ├── Repeat.cs │ │ │ │ │ │ ├── Repeat.cs.meta │ │ │ │ │ │ ├── Return.cs │ │ │ │ │ │ ├── Return.cs.meta │ │ │ │ │ │ ├── Reverse.cs │ │ │ │ │ │ ├── Reverse.cs.meta │ │ │ │ │ │ ├── Select.cs │ │ │ │ │ │ ├── Select.cs.meta │ │ │ │ │ │ ├── SelectMany.cs │ │ │ │ │ │ ├── SelectMany.cs.meta │ │ │ │ │ │ ├── SequenceEqual.cs │ │ │ │ │ │ ├── SequenceEqual.cs.meta │ │ │ │ │ │ ├── Single.cs │ │ │ │ │ │ ├── Single.cs.meta │ │ │ │ │ │ ├── Skip.cs │ │ │ │ │ │ ├── Skip.cs.meta │ │ │ │ │ │ ├── SkipLast.cs │ │ │ │ │ │ ├── SkipLast.cs.meta │ │ │ │ │ │ ├── SkipUntil.cs │ │ │ │ │ │ ├── SkipUntil.cs.meta │ │ │ │ │ │ ├── SkipUntilCanceled.cs │ │ │ │ │ │ ├── SkipUntilCanceled.cs.meta │ │ │ │ │ │ ├── SkipWhile.cs │ │ │ │ │ │ ├── SkipWhile.cs.meta │ │ │ │ │ │ ├── Subscribe.cs │ │ │ │ │ │ ├── Subscribe.cs.meta │ │ │ │ │ │ ├── Sum.cs │ │ │ │ │ │ ├── Sum.cs.meta │ │ │ │ │ │ ├── Sum.tt │ │ │ │ │ │ ├── Sum.tt.meta │ │ │ │ │ │ ├── Take.cs │ │ │ │ │ │ ├── Take.cs.meta │ │ │ │ │ │ ├── TakeLast.cs │ │ │ │ │ │ ├── TakeLast.cs.meta │ │ │ │ │ │ ├── TakeUntil.cs │ │ │ │ │ │ ├── TakeUntil.cs.meta │ │ │ │ │ │ ├── TakeUntilCanceled.cs │ │ │ │ │ │ ├── TakeUntilCanceled.cs.meta │ │ │ │ │ │ ├── TakeWhile.cs │ │ │ │ │ │ ├── TakeWhile.cs.meta │ │ │ │ │ │ ├── Throw.cs │ │ │ │ │ │ ├── Throw.cs.meta │ │ │ │ │ │ ├── ToArray.cs │ │ │ │ │ │ ├── ToArray.cs.meta │ │ │ │ │ │ ├── ToDictionary.cs │ │ │ │ │ │ ├── ToDictionary.cs.meta │ │ │ │ │ │ ├── ToHashSet.cs │ │ │ │ │ │ ├── ToHashSet.cs.meta │ │ │ │ │ │ ├── ToList.cs │ │ │ │ │ │ ├── ToList.cs.meta │ │ │ │ │ │ ├── ToLookup.cs │ │ │ │ │ │ ├── ToLookup.cs.meta │ │ │ │ │ │ ├── ToObservable.cs │ │ │ │ │ │ ├── ToObservable.cs.meta │ │ │ │ │ │ ├── ToUniTaskAsyncEnumerable.cs │ │ │ │ │ │ ├── ToUniTaskAsyncEnumerable.cs.meta │ │ │ │ │ │ ├── UniTask.Linq.asmdef │ │ │ │ │ │ ├── UniTask.Linq.asmdef.meta │ │ │ │ │ │ ├── Union.cs │ │ │ │ │ │ ├── Union.cs.meta │ │ │ │ │ │ ├── UnityExtensions/ │ │ │ │ │ │ │ ├── EveryUpdate.cs │ │ │ │ │ │ │ ├── EveryUpdate.cs.meta │ │ │ │ │ │ │ ├── EveryValueChanged.cs │ │ │ │ │ │ │ ├── EveryValueChanged.cs.meta │ │ │ │ │ │ │ ├── Timer.cs │ │ │ │ │ │ │ └── Timer.cs.meta │ │ │ │ │ │ ├── UnityExtensions.meta │ │ │ │ │ │ ├── Where.cs │ │ │ │ │ │ ├── Where.cs.meta │ │ │ │ │ │ ├── Zip.cs │ │ │ │ │ │ └── Zip.cs.meta │ │ │ │ │ ├── Linq.meta │ │ │ │ │ ├── MoveNextSource.cs │ │ │ │ │ ├── MoveNextSource.cs.meta │ │ │ │ │ ├── PlayerLoopHelper.cs │ │ │ │ │ ├── PlayerLoopHelper.cs.meta │ │ │ │ │ ├── PlayerLoopTimer.cs │ │ │ │ │ ├── PlayerLoopTimer.cs.meta │ │ │ │ │ ├── Progress.cs │ │ │ │ │ ├── Progress.cs.meta │ │ │ │ │ ├── TaskPool.cs │ │ │ │ │ ├── TaskPool.cs.meta │ │ │ │ │ ├── TimeoutController.cs │ │ │ │ │ ├── TimeoutController.cs.meta │ │ │ │ │ ├── TriggerEvent.cs │ │ │ │ │ ├── TriggerEvent.cs.meta │ │ │ │ │ ├── Triggers/ │ │ │ │ │ │ ├── AsyncAwakeTrigger.cs │ │ │ │ │ │ ├── AsyncAwakeTrigger.cs.meta │ │ │ │ │ │ ├── AsyncDestroyTrigger.cs │ │ │ │ │ │ ├── AsyncDestroyTrigger.cs.meta │ │ │ │ │ │ ├── AsyncStartTrigger.cs │ │ │ │ │ │ ├── AsyncStartTrigger.cs.meta │ │ │ │ │ │ ├── AsyncTriggerBase.cs │ │ │ │ │ │ ├── AsyncTriggerBase.cs.meta │ │ │ │ │ │ ├── AsyncTriggerExtensions.cs │ │ │ │ │ │ ├── AsyncTriggerExtensions.cs.meta │ │ │ │ │ │ ├── MonoBehaviourMessagesTriggers.cs │ │ │ │ │ │ ├── MonoBehaviourMessagesTriggers.cs.meta │ │ │ │ │ │ ├── MonoBehaviourMessagesTriggers.tt │ │ │ │ │ │ └── MonoBehaviourMessagesTriggers.tt.meta │ │ │ │ │ ├── Triggers.meta │ │ │ │ │ ├── UniTask.AsValueTask.cs │ │ │ │ │ ├── UniTask.AsValueTask.cs.meta │ │ │ │ │ ├── UniTask.Bridge.cs │ │ │ │ │ ├── UniTask.Bridge.cs.meta │ │ │ │ │ ├── UniTask.Delay.cs │ │ │ │ │ ├── UniTask.Delay.cs.meta │ │ │ │ │ ├── UniTask.Factory.cs │ │ │ │ │ ├── UniTask.Factory.cs.meta │ │ │ │ │ ├── UniTask.Run.cs │ │ │ │ │ ├── UniTask.Run.cs.meta │ │ │ │ │ ├── UniTask.Threading.cs │ │ │ │ │ ├── UniTask.Threading.cs.meta │ │ │ │ │ ├── UniTask.WaitUntil.cs │ │ │ │ │ ├── UniTask.WaitUntil.cs.meta │ │ │ │ │ ├── UniTask.WhenAll.Generated.cs │ │ │ │ │ ├── UniTask.WhenAll.Generated.cs.meta │ │ │ │ │ ├── UniTask.WhenAll.Generated.tt │ │ │ │ │ ├── UniTask.WhenAll.Generated.tt.meta │ │ │ │ │ ├── UniTask.WhenAll.cs │ │ │ │ │ ├── UniTask.WhenAll.cs.meta │ │ │ │ │ ├── UniTask.WhenAny.Generated.cs │ │ │ │ │ ├── UniTask.WhenAny.Generated.cs.meta │ │ │ │ │ ├── UniTask.WhenAny.Generated.tt │ │ │ │ │ ├── UniTask.WhenAny.Generated.tt.meta │ │ │ │ │ ├── UniTask.WhenAny.cs │ │ │ │ │ ├── UniTask.WhenAny.cs.meta │ │ │ │ │ ├── UniTask.WhenEach.cs │ │ │ │ │ ├── UniTask.WhenEach.cs.meta │ │ │ │ │ ├── UniTask.asmdef │ │ │ │ │ ├── UniTask.asmdef.meta │ │ │ │ │ ├── UniTask.cs │ │ │ │ │ ├── UniTask.cs.meta │ │ │ │ │ ├── UniTaskCompletionSource.cs │ │ │ │ │ ├── UniTaskCompletionSource.cs.meta │ │ │ │ │ ├── UniTaskExtensions.Shorthand.cs │ │ │ │ │ ├── UniTaskExtensions.Shorthand.cs.meta │ │ │ │ │ ├── UniTaskExtensions.Shorthand.tt │ │ │ │ │ ├── UniTaskExtensions.Shorthand.tt.meta │ │ │ │ │ ├── UniTaskExtensions.cs │ │ │ │ │ ├── UniTaskExtensions.cs.meta │ │ │ │ │ ├── UniTaskObservableExtensions.cs │ │ │ │ │ ├── UniTaskObservableExtensions.cs.meta │ │ │ │ │ ├── UniTaskScheduler.cs │ │ │ │ │ ├── UniTaskScheduler.cs.meta │ │ │ │ │ ├── UniTaskSynchronizationContext.cs │ │ │ │ │ ├── UniTaskSynchronizationContext.cs.meta │ │ │ │ │ ├── UniTaskVoid.cs │ │ │ │ │ ├── UniTaskVoid.cs.meta │ │ │ │ │ ├── UnityAsyncExtensions.AssetBundleRequestAllAssets.cs │ │ │ │ │ ├── UnityAsyncExtensions.AssetBundleRequestAllAssets.cs.meta │ │ │ │ │ ├── UnityAsyncExtensions.AsyncGPUReadback.cs │ │ │ │ │ ├── UnityAsyncExtensions.AsyncGPUReadback.cs.meta │ │ │ │ │ ├── UnityAsyncExtensions.AsyncInstantiate.cs │ │ │ │ │ ├── UnityAsyncExtensions.AsyncInstantiate.cs.meta │ │ │ │ │ ├── UnityAsyncExtensions.Jobs.cs │ │ │ │ │ ├── UnityAsyncExtensions.Jobs.cs.meta │ │ │ │ │ ├── UnityAsyncExtensions.MonoBehaviour.cs │ │ │ │ │ ├── UnityAsyncExtensions.MonoBehaviour.cs.meta │ │ │ │ │ ├── UnityAsyncExtensions.cs │ │ │ │ │ ├── UnityAsyncExtensions.cs.meta │ │ │ │ │ ├── UnityAsyncExtensions.tt │ │ │ │ │ ├── UnityAsyncExtensions.tt.meta │ │ │ │ │ ├── UnityAsyncExtensions.uGUI.cs │ │ │ │ │ ├── UnityAsyncExtensions.uGUI.cs.meta │ │ │ │ │ ├── UnityAwaitableExtensions.cs │ │ │ │ │ ├── UnityAwaitableExtensions.cs.meta │ │ │ │ │ ├── UnityBindingExtensions.cs │ │ │ │ │ ├── UnityBindingExtensions.cs.meta │ │ │ │ │ ├── UnityWebRequestException.cs │ │ │ │ │ ├── UnityWebRequestException.cs.meta │ │ │ │ │ ├── _InternalVisibleTo.cs │ │ │ │ │ └── _InternalVisibleTo.cs.meta │ │ │ │ ├── Runtime.meta │ │ │ │ ├── package.json │ │ │ │ └── package.json.meta │ │ │ └── UniTask.meta │ │ ├── Plugins.meta │ │ ├── Scenes/ │ │ │ ├── EditorTest1.cs │ │ │ ├── EditorTest1.cs.meta │ │ │ ├── ExceptionExamples.cs │ │ │ ├── ExceptionExamples.cs.meta │ │ │ ├── ExceptionExamples.unity │ │ │ ├── ExceptionExamples.unity.meta │ │ │ ├── MiddlewareSample.cs │ │ │ ├── MiddlewareSample.cs.meta │ │ │ ├── SandboxMain.cs │ │ │ ├── SandboxMain.cs.meta │ │ │ ├── SandboxMain.unity │ │ │ ├── SandboxMain.unity.meta │ │ │ ├── WaitWhileTest.cs │ │ │ └── WaitWhileTest.cs.meta │ │ ├── Scenes.meta │ │ ├── StreamingAssets/ │ │ │ ├── test.txt │ │ │ └── test.txt.meta │ │ ├── StreamingAssets.meta │ │ ├── TempAsm/ │ │ │ ├── FooMonoBehaviour.cs │ │ │ ├── FooMonoBehaviour.cs.meta │ │ │ ├── TempAsm.asmdef │ │ │ └── TempAsm.asmdef.meta │ │ ├── TempAsm.meta │ │ ├── Tests/ │ │ │ ├── AsyncOperationTest.cs │ │ │ ├── AsyncOperationTest.cs.meta │ │ │ ├── AsyncTest.cs │ │ │ ├── AsyncTest.cs.meta │ │ │ ├── CachelikeTest.cs │ │ │ ├── CachelikeTest.cs.meta │ │ │ ├── CoroutineToUniTaskTest.cs │ │ │ ├── CoroutineToUniTaskTest.cs.meta │ │ │ ├── DelayTest.cs │ │ │ ├── DelayTest.cs.meta │ │ │ ├── Editor/ │ │ │ │ ├── AsyncTestEditor.cs │ │ │ │ ├── AsyncTestEditor.cs.meta │ │ │ │ ├── RunTestEditor.cs │ │ │ │ ├── RunTestEditor.cs.meta │ │ │ │ ├── UniTask.Tests.Editor.asmdef │ │ │ │ ├── UniTask.Tests.Editor.asmdef.meta │ │ │ │ ├── WhenAnyTestEditor.cs │ │ │ │ └── WhenAnyTestEditor.cs.meta │ │ │ ├── Editor.meta │ │ │ ├── GenericsWhenAllAny.cs │ │ │ ├── GenericsWhenAllAny.cs.meta │ │ │ ├── PlayerLoopTimerTest.cs │ │ │ ├── PlayerLoopTimerTest.cs.meta │ │ │ ├── Preserve.cs │ │ │ ├── Preserve.cs.meta │ │ │ ├── Resources/ │ │ │ │ └── sample_texture.png.meta │ │ │ ├── Resources.meta │ │ │ ├── RunTest.cs │ │ │ ├── RunTest.cs.meta │ │ │ ├── Shims.cs │ │ │ ├── Shims.cs.meta │ │ │ ├── UniTask.Tests.asmdef │ │ │ ├── UniTask.Tests.asmdef.meta │ │ │ ├── WhenAnyTest.cs │ │ │ └── WhenAnyTest.cs.meta │ │ └── Tests.meta │ ├── Packages/ │ │ ├── manifest.json │ │ └── packages-lock.json │ └── ProjectSettings/ │ ├── AudioManager.asset │ ├── ClusterInputManager.asset │ ├── DynamicsManager.asset │ ├── EditorBuildSettings.asset │ ├── EditorSettings.asset │ ├── GraphicsSettings.asset │ ├── InputManager.asset │ ├── MemorySettings.asset │ ├── NavMeshAreas.asset │ ├── NetworkManager.asset │ ├── PackageManagerSettings.asset │ ├── Physics2DSettings.asset │ ├── PresetManager.asset │ ├── ProjectSettings.asset │ ├── ProjectVersion.txt │ ├── QualitySettings.asset │ ├── SceneTemplateSettings.json │ ├── TagManager.asset │ ├── TimeManager.asset │ ├── UnityConnectSettings.asset │ ├── VFXManager.asset │ ├── VersionControlSettings.asset │ └── XRSettings.asset ├── UniTask.Analyzer/ │ ├── Properties/ │ │ └── launchSettings.json │ ├── UniTask.Analyzer.csproj │ └── UniTaskAnalyzer.cs ├── UniTask.NetCore/ │ ├── NetCore/ │ │ ├── AsyncEnumerableExtensions.cs │ │ ├── UniTask.Delay.cs │ │ ├── UniTask.Run.cs │ │ └── UniTask.Yield.cs │ └── UniTask.NetCore.csproj ├── UniTask.NetCoreSandbox/ │ ├── Program.cs │ └── UniTask.NetCoreSandbox.csproj └── UniTask.NetCoreTests/ ├── AsyncLazyTest.cs ├── AsyncReactivePropertyTest.cs ├── CancellationTokenTest.cs ├── ChannelTest.cs ├── CompletionSourceTest.cs ├── DeferTest.cs ├── Linq/ │ ├── Aggregate.cs │ ├── AllAny.cs │ ├── Concat.cs │ ├── Convert.cs │ ├── CreateTest.cs │ ├── Factory.cs │ ├── Filtering.cs │ ├── FirstLast.cs │ ├── Joins.cs │ ├── Merge.cs │ ├── Paging.cs │ ├── Projection.cs │ ├── PulbishTest.cs │ ├── QueueTest.cs │ ├── Sets.cs │ ├── Sort.cs │ ├── TakeInfinityTest.cs │ └── _Exception.cs ├── TaskBuilderCases.cs ├── TaskExtensionsTest.cs ├── TriggerEventTest.cs ├── UniTask.NetCoreTests.csproj ├── UniTaskCompletionSourceTest.cs ├── WhenEachTest.cs └── WithCancellationTest.cs ================================================ FILE CONTENTS ================================================ ================================================ FILE: .config/dotnet-tools.json ================================================ { "version": 1, "isRoot": true, "tools": { "docfx": { "version": "2.78.3", "commands": [ "docfx" ], "rollForward": false } } } ================================================ FILE: .editorconfig ================================================ # top-most EditorConfig file root = true [*] charset = utf-8 end_of_line = lf indent_style = space indent_size = 2 insert_final_newline = true trim_trailing_whitespace = true # Visual Studio Spell checker configs (https://learn.microsoft.com/en-us/visualstudio/ide/text-spell-checker?view=vs-2022#how-to-customize-the-spell-checker) spelling_exclusion_path = ./exclusion.dic [*.cs] indent_size = 4 charset = utf-8-bom end_of_line = unset # Solution files [*.{sln,slnx}] end_of_line = unset # MSBuild project files [*.{csproj,props,targets}] end_of_line = unset # Xml config files [*.{ruleset,config,nuspec,resx,runsettings,DotSettings}] end_of_line = unset [*{_AssemblyInfo.cs,.notsupported.cs}] generated_code = true # C# code style settings [*.{cs}] dotnet_diagnostic.IDE0044.severity = none # IDE0044: Make field readonly # https://stackoverflow.com/questions/79195382/how-to-disable-fading-unused-methods-in-visual-studio-2022-17-12-0 dotnet_diagnostic.IDE0051.severity = none # IDE0051: Remove unused private member dotnet_diagnostic.IDE0130.severity = none # IDE0130: Namespace does not match folder structure ================================================ FILE: .github/FUNDING.yml ================================================ github: [neuecc] ================================================ FILE: .github/dependabot.yaml ================================================ # ref: https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot version: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "weekly" # Check for updates to GitHub Actions every week groups: dependencies: patterns: - "*" cooldown: default-days: 14 # Wait 14 days before creating another PR for the same dependency. This will prevent vulnerability on the package impact. ignore: # I just want update action when major/minor version is updated. patch updates are too noisy. - dependency-name: "*" update-types: - version-update:semver-patch ================================================ FILE: .github/workflows/build-debug.yaml ================================================ name: Build-Debug on: push: branches: - "master" pull_request: branches: - "master" jobs: build-dotnet: permissions: contents: read runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - uses: Cysharp/Actions/.github/actions/checkout@main - uses: Cysharp/Actions/.github/actions/setup-dotnet@main - run: dotnet build -c Release - run: dotnet test -c Release - run: dotnet pack -c Release --no-build -p:IncludeSymbols=true -o $GITHUB_WORKSPACE/artifacts build-unity: if: ${{ ((github.event_name == 'push' && github.repository_owner == 'Cysharp') || startsWith(github.event.pull_request.head.label, 'Cysharp:')) && github.triggering_actor != 'dependabot[bot]' }} strategy: fail-fast: false max-parallel: 2 matrix: unity: ["2022.3.39f1", "6000.0.12f1"] # Test with LTS permissions: contents: read runs-on: ubuntu-24.04 timeout-minutes: 30 # Unity build takes more than 20min. steps: - name: Load secrets id: op-load-secret uses: 1password/load-secrets-action@581a835fb51b8e7ec56b71cf2ffddd7e68bb25e0 # v2.0.0 with: export-env: false env: OP_SERVICE_ACCOUNT_TOKEN: ${{ secrets.OP_SERVICE_ACCOUNT_TOKEN_PUBLIC }} UNITY_EMAIL: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/username" UNITY_PASSWORD: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/credential" UNITY_SERIAL: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/serial" - uses: Cysharp/Actions/.github/actions/checkout@main # Execute scripts: Export Package # /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export - name: Build Unity (.unitypacakge) if: ${{ startsWith(matrix.unity, '2022') }} # only execute once uses: Cysharp/Actions/.github/actions/unity-builder@main env: UNITY_EMAIL: ${{ steps.op-load-secret.outputs.UNITY_EMAIL }} UNITY_PASSWORD: ${{ steps.op-load-secret.outputs.UNITY_PASSWORD }} UNITY_SERIAL: ${{ steps.op-load-secret.outputs.UNITY_SERIAL }} with: projectPath: src/UniTask unityVersion: ${{ matrix.unity }} targetPlatform: StandaloneLinux64 buildMethod: PackageExporter.Export # Execute UnitTest # /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend IL2CPP /BuildTarget StandaloneLinux64 - name: Build UnitTest (IL2CPP) uses: Cysharp/Actions/.github/actions/unity-builder@main env: UNITY_EMAIL: ${{ steps.op-load-secret.outputs.UNITY_EMAIL }} UNITY_PASSWORD: ${{ steps.op-load-secret.outputs.UNITY_PASSWORD }} UNITY_SERIAL: ${{ steps.op-load-secret.outputs.UNITY_SERIAL }} with: projectPath: src/UniTask unityVersion: ${{ matrix.unity }} targetPlatform: StandaloneLinux64 buildMethod: UnitTestBuilder.BuildUnitTest customParameters: "/headless /ScriptBackend IL2CPP" - name: Check UnitTest file is generated run: ls -lR ./src/UniTask/bin/UnitTest - name: Execute UnitTest run: ./src/UniTask/bin/UnitTest/StandaloneLinux64_IL2CPP/test - uses: Cysharp/Actions/.github/actions/check-metas@main # check meta files with: directory: src/UniTask # Store artifacts. - uses: Cysharp/Actions/.github/actions/upload-artifact@main if: ${{ startsWith(matrix.unity, '2021') }} # only execute 2021 with: name: UniTask.unitypackage-${{ matrix.unity }}.zip path: ./src/UniTask/*.unitypackage retention-days: 1 ================================================ FILE: .github/workflows/build-docs.yaml ================================================ name: build-docs on: push: branches: - master - feature/docs jobs: run-docfx: if: ${{ ((github.event_name == 'push' && github.repository_owner == 'Cysharp') || startsWith(github.event.pull_request.head.label, 'Cysharp:')) && github.triggering_actor != 'dependabot[bot]' }} permissions: contents: write pages: write runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - name: Load secrets id: op-load-secret uses: 1password/load-secrets-action@581a835fb51b8e7ec56b71cf2ffddd7e68bb25e0 # v2.0.0 with: export-env: false env: OP_SERVICE_ACCOUNT_TOKEN: ${{ secrets.OP_SERVICE_ACCOUNT_TOKEN_PUBLIC }} UNITY_EMAIL: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/username" UNITY_PASSWORD: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/credential" UNITY_SERIAL: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/serial" - uses: Cysharp/Actions/.github/actions/checkout@main # Execute scripts: Export Package # /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export - name: Build Unity (.unitypackage) uses: Cysharp/Actions/.github/actions/unity-builder@main env: UNITY_EMAIL: ${{ steps.op-load-secret.outputs.UNITY_EMAIL }} UNITY_PASSWORD: ${{ steps.op-load-secret.outputs.UNITY_PASSWORD }} UNITY_SERIAL: ${{ steps.op-load-secret.outputs.UNITY_SERIAL }} with: projectPath: src/UniTask unityVersion: "2022.3.39f1" targetPlatform: StandaloneLinux64 buildMethod: PackageExporter.Export - uses: Cysharp/Actions/.github/actions/checkout@main with: repository: Cysharp/DocfxTemplate path: docs/_DocfxTemplate - uses: Cysharp/Actions/.github/actions/setup-dotnet@main - name: dotnet tool restore run: dotnet tool restore - name: Docfx metadata run: dotnet docfx metadata docs/docfx.json - name: Docfx build run: dotnet docfx build docs/docfx.json - name: Publish to GitHub Pages uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0 with: github_token: ${{ secrets.GITHUB_TOKEN }} publish_dir: docs/_site ================================================ FILE: .github/workflows/build-release.yaml ================================================ name: build-release on: workflow_dispatch: inputs: tag: description: "tag: git tag you want create. (sample 1.0.0)" required: true dry-run: description: "dry-run: true will never create relase/nuget." required: true default: false type: boolean jobs: update-packagejson: permissions: actions: read contents: write uses: Cysharp/Actions/.github/workflows/update-packagejson.yaml@main with: file-path: ./src/UniTask/Assets/Plugins/UniTask/package.json tag: ${{ inputs.tag }} dry-run: ${{ inputs.dry-run }} build-dotnet: needs: [update-packagejson] permissions: contents: read runs-on: ubuntu-24.04 timeout-minutes: 10 steps: - run: echo ${{ needs.update-packagejson.outputs.sha }} - uses: Cysharp/Actions/.github/actions/checkout@main with: ref: ${{ needs.update-packagejson.outputs.sha }} - uses: Cysharp/Actions/.github/actions/setup-dotnet@main # build and pack - run: dotnet build -c Release -p:Version=${{ inputs.tag }} - run: dotnet test -c Release --no-build - run: dotnet pack ./src/UniTask.NetCore/UniTask.NetCore.csproj -c Release --no-build -p:Version=${{ inputs.tag }} -o ./publish # Store artifacts. - uses: Cysharp/Actions/.github/actions/upload-artifact@main with: name: nuget path: ./publish/ retention-days: 1 build-unity: needs: [update-packagejson] strategy: matrix: unity: ["2022.3.39f1"] permissions: contents: read runs-on: ubuntu-24.04 timeout-minutes: 15 steps: - name: Load secrets id: op-load-secret uses: 1password/load-secrets-action@581a835fb51b8e7ec56b71cf2ffddd7e68bb25e0 # v2.0.0 with: export-env: false env: OP_SERVICE_ACCOUNT_TOKEN: ${{ secrets.OP_SERVICE_ACCOUNT_TOKEN_PUBLIC }} UNITY_EMAIL: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/username" UNITY_PASSWORD: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/credential" UNITY_SERIAL: "op://${{ vars.OP_VAULT_ACTIONS_PUBLIC }}/UNITY_LICENSE/serial" - run: echo ${{ needs.update-packagejson.outputs.sha }} - uses: Cysharp/Actions/.github/actions/checkout@main with: ref: ${{ needs.update-packagejson.outputs.sha }} # Execute scripts: Export Package # /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export - name: Build Unity (.unitypacakge) uses: Cysharp/Actions/.github/actions/unity-builder@main env: UNITY_EMAIL: ${{ steps.op-load-secret.outputs.UNITY_EMAIL }} UNITY_PASSWORD: ${{ steps.op-load-secret.outputs.UNITY_PASSWORD }} UNITY_SERIAL: ${{ steps.op-load-secret.outputs.UNITY_SERIAL }} with: projectPath: src/UniTask unityVersion: ${{ matrix.unity }} targetPlatform: StandaloneLinux64 buildMethod: PackageExporter.Export - uses: Cysharp/Actions/.github/actions/check-metas@main # check meta files with: directory: src/UniTask # Store artifacts. - uses: Cysharp/Actions/.github/actions/upload-artifact@main with: name: UniTask.${{ inputs.tag }}.unitypackage path: ./src/UniTask/UniTask.${{ inputs.tag }}.unitypackage retention-days: 1 # release create-release: needs: [update-packagejson, build-dotnet, build-unity] permissions: contents: write id-token: write # required for NuGet Trusted Publish uses: Cysharp/Actions/.github/workflows/create-release.yaml@main with: commit-id: ${{ needs.update-packagejson.outputs.sha }} dry-run: ${{ inputs.dry-run }} tag: ${{ inputs.tag }} nuget-push: true release-upload: true release-asset-path: ./UniTask.${{ inputs.tag }}.unitypackage/UniTask.${{ inputs.tag }}.unitypackage secrets: inherit cleanup: if: ${{ needs.update-packagejson.outputs.is-branch-created == 'true' }} needs: [update-packagejson, build-dotnet, build-unity] permissions: contents: write uses: Cysharp/Actions/.github/workflows/clean-packagejson-branch.yaml@main with: branch: ${{ needs.update-packagejson.outputs.branch-name }} ================================================ FILE: .github/workflows/prevent-github-change.yaml ================================================ name: Prevent github change on: pull_request: paths: - ".github/**/*.yaml" - ".github/**/*.yml" jobs: detect: permissions: contents: read uses: Cysharp/Actions/.github/workflows/prevent-github-change.yaml@main ================================================ FILE: .github/workflows/stale.yaml ================================================ name: "Close stale issues" on: workflow_dispatch: schedule: - cron: "0 0 * * *" jobs: stale: permissions: contents: read pull-requests: write issues: write uses: Cysharp/Actions/.github/workflows/stale-issue.yaml@main ================================================ FILE: .github/workflows/toc.yaml ================================================ name: TOC Generator on: push: paths: - 'README.md' jobs: toc: permissions: contents: write uses: Cysharp/Actions/.github/workflows/toc-generator.yaml@main with: TOC_TITLE: "## Table of Contents" secrets: inherit ================================================ FILE: .gitignore ================================================ # Unity *.pidb *.suo *.userprefs *.vsmdi *.testsettings */bin */obj */publish $tf TestResults !*.sln !*.csproj !*/*.csproj [Ll]ibrary/ [Tt]emp/ [Oo]bj/ # VS2013 # Build Folders (you can keep bin if you'd like, to store dlls and pdbs) [Bb]in/ [Oo]bj/ # mstest test results TestResults ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # User-specific files *.suo *.user *.sln.docstates # Build results [Dd]ebug/ [Rr]elease/ x64/ *_i.c *_p.c *.ilk # *.meta # already ignored in Unity section *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.log *.vspscc *.vssscc .builds # Visual C++ cache files ipch/ *.aps *.ncb *.opensdf *.sdf # Visual Studio profiler *.psess *.vsp *.vspx # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper* # NCrunch *.ncrunch* .*crunch*.local.xml # Installshield output folder [Ee]xpress # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish # Publish Web Output *.Publish.xml # NuGet Packages Directory *.nupkg # NuGet Symbol Packages *.snupkg # The packages folder can be ignored because of Package Restore # packages # upm pacakge will use Packages # **/[Pp]ackages/* # except build/, which is used as an MSBuild target. # !**/[Pp]ackages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/[Pp]ackages/repositories.config # NuGet v3's project.json files produces more ignorable files *.nuget.props *.nuget.targets # Windows Azure Build Output csx *.build.csdef # Windows Store app package directory AppPackages/ # Others [Bb]in [Oo]bj sql TestResults [Tt]est[Rr]esult* *.Cache ClientBin [Ss]tyle[Cc]op.* ~$* *.dbmdl Generated_Code #added for RIA/Silverlight projects # Backup & report files from converting an old project file to a newer # Visual Studio version. Backup files are not needed, because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML Assets/WSATestCertificate.pfx .vs/ # Unity # Unity .vsconfig src/UniTask/Library/* src/UniTask/Temp/* src/UniTask/Logs/* src/UniTask/[Uu]ser[Ss]ettings/ src/UniTask/*.sln src/UniTask/*.csproj src/UniTask/*.unitypackage !src/UniTask/Packages/ ================================================ FILE: Directory.Build.props ================================================  true $(MSBuildThisFileDirectory)opensource.snk false $(Version) Cysharp Cysharp © Cysharp, Inc. task;async https://github.com/Cysharp/UniTask README.md $(PackageProjectUrl) git MIT Icon.png ================================================ FILE: LICENSE ================================================ The MIT License (MIT) Copyright (c) 2019 Yoshifumi Kawai / Cysharp, Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ 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) [![Readme_CN](https://img.shields.io/badge/UniTask-%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3-red)](https://github.com/Cysharp/UniTask/blob/master/README_CN.md) Provides an efficient allocation free async/await integration for Unity. * Struct based `UniTask` and custom AsyncMethodBuilder to achieve zero allocation * Makes all Unity AsyncOperations and Coroutines awaitable * PlayerLoop based task(`UniTask.Yield`, `UniTask.Delay`, `UniTask.DelayFrame`, etc..) that enable replacing all coroutine operations * MonoBehaviour Message Events and uGUI Events as awaitable/async-enumerable * Runs completely on Unity's PlayerLoop so doesn't use threads and runs on WebGL, wasm, etc. * Asynchronous LINQ, with Channel and AsyncReactiveProperty * TaskTracker window to prevent memory leaks * Highly compatible behaviour with Task/ValueTask/IValueTaskSource For technical details, see blog post: [UniTask v2 — Zero Allocation async/await for Unity, with Asynchronous LINQ ](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd) For advanced tips, see blog post: [Extends UnityWebRequest via async decorator pattern — Advanced Techniques of UniTask](https://medium.com/@neuecc/extends-unitywebrequest-via-async-decorator-pattern-advanced-techniques-of-unitask-ceff9c5ee846) ## Table of Contents - [Getting started](#getting-started) - [Basics of UniTask and AsyncOperation](#basics-of-unitask-and-asyncoperation) - [Cancellation and Exception handling](#cancellation-and-exception-handling) - [Timeout handling](#timeout-handling) - [Progress](#progress) - [PlayerLoop](#playerloop) - [async void vs async UniTaskVoid](#async-void-vs-async-unitaskvoid) - [UniTaskTracker](#unitasktracker) - [External Assets](#external-assets) - [AsyncEnumerable and Async LINQ](#asyncenumerable-and-async-linq) - [Awaitable Events](#awaitable-events) - [Channel](#channel) - [vs Awaitable](#vs-awaitable) - [For Unit Testing](#for-unit-testing) - [ThreadPool limitation](#threadpool-limitation) - [IEnumerator.ToUniTask limitation](#ienumeratortounitask-limitation) - [For UnityEditor](#for-unityeditor) - [Compare with Standard Task API](#compare-with-standard-task-api) - [Pooling Configuration](#pooling-configuration) - [Allocation on Profiler](#allocation-on-profiler) - [UniTaskSynchronizationContext](#unitasksynchronizationcontext) - [API References](#api-references) - [UPM Package](#upm-package) - [Install via git URL](#install-via-git-url) - [.NET Core](#net-core) - [License](#license) Getting started --- Install via [UPM package](#upm-package) with git reference or asset package(`UniTask.*.*.*.unitypackage`) available in [UniTask/releases](https://github.com/Cysharp/UniTask/releases). ```csharp // extension awaiter/methods can be used by this namespace using Cysharp.Threading.Tasks; // You can return type as struct UniTask(or UniTask), it is unity specialized lightweight alternative of Task // zero allocation and fast excution for zero overhead async/await integrate with Unity async UniTask DemoAsync() { // You can await Unity's AsyncObject var asset = await Resources.LoadAsync("foo"); var txt = (await UnityWebRequest.Get("https://...").SendWebRequest()).downloadHandler.text; await SceneManager.LoadSceneAsync("scene2"); // .WithCancellation enables Cancel, GetCancellationTokenOnDestroy synchornizes with lifetime of GameObject // after Unity 2022.2, you can use `destroyCancellationToken` in MonoBehaviour var asset2 = await Resources.LoadAsync("bar").WithCancellation(this.GetCancellationTokenOnDestroy()); // .ToUniTask accepts progress callback(and all options), Progress.Create is a lightweight alternative of IProgress var asset3 = await Resources.LoadAsync("baz").ToUniTask(Progress.Create(x => Debug.Log(x))); // await frame-based operation like a coroutine await UniTask.DelayFrame(100); // replacement of yield return new WaitForSeconds/WaitForSecondsRealtime await UniTask.Delay(TimeSpan.FromSeconds(10), ignoreTimeScale: false); // yield any playerloop timing(PreUpdate, Update, LateUpdate, etc...) await UniTask.Yield(PlayerLoopTiming.PreLateUpdate); // replacement of yield return null await UniTask.Yield(); await UniTask.NextFrame(); // replacement of WaitForEndOfFrame #if UNITY_2023_1_OR_NEWER await UniTask.WaitForEndOfFrame(); #else // requires MonoBehaviour(CoroutineRunner)) await UniTask.WaitForEndOfFrame(this); // this is MonoBehaviour #endif // replacement of yield return new WaitForFixedUpdate(same as UniTask.Yield(PlayerLoopTiming.FixedUpdate)) await UniTask.WaitForFixedUpdate(); // replacement of yield return WaitUntil await UniTask.WaitUntil(() => isActive == false); // special helper of WaitUntil await UniTask.WaitUntilValueChanged(this, x => x.isActive); // You can await IEnumerator coroutines await FooCoroutineEnumerator(); // You can await a standard task await Task.Run(() => 100); // Multithreading, run on ThreadPool under this code await UniTask.SwitchToThreadPool(); /* work on ThreadPool */ // return to MainThread(same as `ObserveOnMainThread` in UniRx) await UniTask.SwitchToMainThread(); // get async webrequest async UniTask GetTextAsync(UnityWebRequest req) { var op = await req.SendWebRequest(); return op.downloadHandler.text; } var task1 = GetTextAsync(UnityWebRequest.Get("http://google.com")); var task2 = GetTextAsync(UnityWebRequest.Get("http://bing.com")); var task3 = GetTextAsync(UnityWebRequest.Get("http://yahoo.com")); // concurrent async-wait and get results easily by tuple syntax var (google, bing, yahoo) = await UniTask.WhenAll(task1, task2, task3); // shorthand of WhenAll, tuple can await directly var (google2, bing2, yahoo2) = await (task1, task2, task3); // return async-value.(or you can use `UniTask`(no result), `UniTaskVoid`(fire and forget)). return (asset as TextAsset)?.text ?? throw new InvalidOperationException("Asset not found"); } ``` Basics of UniTask and AsyncOperation --- UniTask features rely on C# 7.0([task-like custom async method builder feature](https://github.com/dotnet/roslyn/blob/master/docs/features/task-types.md)) so the required Unity version is after `Unity 2018.3`, the official lowest version supported is `Unity 2018.4.13f1`. Why is UniTask(custom task-like object) required? Because Task is too heavy and not matched to Unity threading (single-thread). UniTask does not use threads and SynchronizationContext/ExecutionContext because Unity's asynchronous object is automaticaly dispatched by Unity's engine layer. It achieves faster and lower allocation, and is completely integrated with Unity. You can await `AsyncOperation`, `ResourceRequest`, `AssetBundleRequest`, `AssetBundleCreateRequest`, `UnityWebRequestAsyncOperation`, `AsyncGPUReadbackRequest`, `IEnumerator` and others when `using Cysharp.Threading.Tasks;`. UniTask provides three pattern of extension methods. ```csharp * await asyncOperation; * .WithCancellation(CancellationToken); * .ToUniTask(IProgress, PlayerLoopTiming, CancellationToken); ``` `WithCancellation` is a simple version of `ToUniTask`, both return `UniTask`. For details of cancellation, see: [Cancellation and Exception handling](#cancellation-and-exception-handling) section. > Note: await directly is returned from native timing of PlayerLoop but WithCancellation and ToUniTask are returned from specified PlayerLoopTiming. For details of timing, see: [PlayerLoop](#playerloop) section. > Note: AssetBundleRequest has `asset` and `allAssets`, default await returns `asset`. If you want to get `allAssets`, you can use `AwaitForAllAssets()` method. The type of `UniTask` can use utilities like `UniTask.WhenAll`, `UniTask.WhenAny`, `UniTask.WhenEach`. They are like `Task.WhenAll`/`Task.WhenAny` but the return type is more useful. They return value tuples so you can deconstruct each result and pass multiple types. ```csharp public async UniTaskVoid LoadManyAsync() { // parallel load. var (a, b, c) = await UniTask.WhenAll( LoadAsSprite("foo"), LoadAsSprite("bar"), LoadAsSprite("baz")); } async UniTask LoadAsSprite(string path) { var resource = await Resources.LoadAsync(path); return (resource as Sprite); } ``` If you want to convert a callback to UniTask, you can use `UniTaskCompletionSource` which is a lightweight edition of `TaskCompletionSource`. ```csharp public UniTask WrapByUniTaskCompletionSource() { var utcs = new UniTaskCompletionSource(); // when complete, call utcs.TrySetResult(); // when failed, call utcs.TrySetException(); // when cancel, call utcs.TrySetCanceled(); return utcs.Task; //return UniTask } ``` You can convert Task -> UniTask: `AsUniTask`, `UniTask` -> `UniTask`: `AsAsyncUnitUniTask`, `UniTask` -> `UniTask`: `AsUniTask`. `UniTask` -> `UniTask`'s conversion cost is free. If you want to convert async to coroutine, you can use `.ToCoroutine()`, this is useful if you want to only allow using the coroutine system. UniTask can not await twice. This is a similar constraint to the [ValueTask/IValueTaskSource](https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.valuetask-1?view=netcore-3.1) introduced in .NET Standard 2.1. > The following operations should never be performed on a ValueTask instance: > > * Awaiting the instance multiple times. > * Calling AsTask multiple times. > * Using .Result or .GetAwaiter().GetResult() when the operation hasn't yet completed, or using them multiple times. > * Using more than one of these techniques to consume the instance. > > If you do any of the above, the results are undefined. ```csharp var task = UniTask.DelayFrame(10); await task; await task; // NG, throws Exception ``` Store to the class field, you can use `UniTask.Lazy` that supports calling multiple times. `.Preserve()` allows for multiple calls (internally cached results). This is useful when there are multiple calls in a function scope. Also `UniTaskCompletionSource` can await multiple times and await from many callers. Cancellation and Exception handling --- Some UniTask factory methods have a `CancellationToken cancellationToken = default` parameter. Also some async operations for Unity have `WithCancellation(CancellationToken)` and `ToUniTask(..., CancellationToken cancellation = default)` extension methods. You can pass `CancellationToken` to parameter by standard [`CancellationTokenSource`](https://docs.microsoft.com/en-us/dotnet/api/system.threading.cancellationtokensource). ```csharp var cts = new CancellationTokenSource(); cancelButton.onClick.AddListener(() => { cts.Cancel(); }); await UnityWebRequest.Get("http://google.co.jp").SendWebRequest().WithCancellation(cts.Token); await UniTask.DelayFrame(1000, cancellationToken: cts.Token); ``` CancellationToken can be created by `CancellationTokenSource` or MonoBehaviour's extension method `GetCancellationTokenOnDestroy`. ```csharp // this CancellationToken lifecycle is same as GameObject. await UniTask.DelayFrame(1000, cancellationToken: this.GetCancellationTokenOnDestroy()); ``` For propagate Cancellation, all async method recommend to accept `CancellationToken cancellationToken` at last argument, and pass `CancellationToken` from root to end. ```csharp await FooAsync(this.GetCancellationTokenOnDestroy()); // --- async UniTask FooAsync(CancellationToken cancellationToken) { await BarAsync(cancellationToken); } async UniTask BarAsync(CancellationToken cancellationToken) { await UniTask.Delay(TimeSpan.FromSeconds(3), cancellationToken); } ``` `CancellationToken` means lifecycle of async. You can hold your own lifecycle insteadof default CancellationTokenOnDestroy. ```csharp public class MyBehaviour : MonoBehaviour { CancellationTokenSource disableCancellation = new CancellationTokenSource(); CancellationTokenSource destroyCancellation = new CancellationTokenSource(); private void OnEnable() { if (disableCancellation != null) { disableCancellation.Dispose(); } disableCancellation = new CancellationTokenSource(); } private void OnDisable() { disableCancellation.Cancel(); } private void OnDestroy() { destroyCancellation.Cancel(); destroyCancellation.Dispose(); } } ``` After Unity 2022.2, Unity adds CancellationToken in [MonoBehaviour.destroyCancellationToken](https://docs.unity3d.com/ScriptReference/MonoBehaviour-destroyCancellationToken.html) and [Application.exitCancellationToken](https://docs.unity3d.com/ScriptReference/Application-exitCancellationToken.html). When cancellation is detected, all methods throw `OperationCanceledException` and propagate upstream. When exception(not limited to `OperationCanceledException`) is not handled in async method, it is propagated finally to `UniTaskScheduler.UnobservedTaskException`. The default behaviour of received unhandled exception is to write log as exception. Log level can be changed using `UniTaskScheduler.UnobservedExceptionWriteLogType`. If you want to use custom behaviour, set an action to `UniTaskScheduler.UnobservedTaskException.` And also `OperationCanceledException` is a special exception, this is silently ignored at `UnobservedTaskException`. If you want to cancel behaviour in an async UniTask method, throw `OperationCanceledException` manually. ```csharp public async UniTask FooAsync() { await UniTask.Yield(); throw new OperationCanceledException(); } ``` If you handle an exception but want to ignore(propagate to global cancellation handling), use an exception filter. ```csharp public async UniTask BarAsync() { try { var x = await FooAsync(); return x * 2; } catch (Exception ex) when (!(ex is OperationCanceledException)) // when (ex is not OperationCanceledException) at C# 9.0 { return -1; } } ``` throws/catch `OperationCanceledException` is slightly heavy, so if performance is a concern, use `UniTask.SuppressCancellationThrow` to avoid OperationCanceledException throw. It returns `(bool IsCanceled, T Result)` instead of throwing. ```csharp var (isCanceled, _) = await UniTask.DelayFrame(10, cancellationToken: cts.Token).SuppressCancellationThrow(); if (isCanceled) { // ... } ``` Note: Only suppress throws if you call directly into the most source method. Otherwise, the return value will be converted, but the entire pipeline will not suppress throws. Some features that use Unity's player loop, such as `UniTask.Yield` and `UniTask.Delay` etc, determines CancellationToken state on the player loop. This means it does not cancel immediately upon `CancellationToken` fired. If you want to change this behaviour, the cancellation to be immediate, set the `cancelImmediately` flag as an argument. ```csharp await UniTask.Yield(cancellationToken, cancelImmediately: true); ``` Note: Setting `cancelImmediately` to true and detecting an immediate cancellation is more costly than the default behavior. This is because it uses `CancellationToken.Register`; it is heavier than checking CancellationToken on the player loop. Timeout handling --- Timeout is a variation of cancellation. You can set timeout by `CancellationTokenSouce.CancelAfterSlim(TimeSpan)` and pass CancellationToken to async methods. ```csharp var cts = new CancellationTokenSource(); cts.CancelAfterSlim(TimeSpan.FromSeconds(5)); // 5sec timeout. try { await UnityWebRequest.Get("http://foo").SendWebRequest().WithCancellation(cts.Token); } catch (OperationCanceledException ex) { if (ex.CancellationToken == cts.Token) { UnityEngine.Debug.Log("Timeout"); } } ``` > `CancellationTokenSouce.CancelAfter` is a standard api. However in Unity you should not use it because it depends threading timer. `CancelAfterSlim` is UniTask's extension methods, it uses PlayerLoop instead. If you want to use timeout with other source of cancellation, use `CancellationTokenSource.CreateLinkedTokenSource`. ```csharp var cancelToken = new CancellationTokenSource(); cancelButton.onClick.AddListener(() => { cancelToken.Cancel(); // cancel from button click. }); var timeoutToken = new CancellationTokenSource(); timeoutToken.CancelAfterSlim(TimeSpan.FromSeconds(5)); // 5sec timeout. try { // combine token var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancelToken.Token, timeoutToken.Token); await UnityWebRequest.Get("http://foo").SendWebRequest().WithCancellation(linkedTokenSource.Token); } catch (OperationCanceledException ex) { if (timeoutToken.IsCancellationRequested) { UnityEngine.Debug.Log("Timeout."); } else if (cancelToken.IsCancellationRequested) { UnityEngine.Debug.Log("Cancel clicked."); } } ``` Optimize for reduce allocation of CancellationTokenSource for timeout per call async method, you can use UniTask's `TimeoutController`. ```csharp TimeoutController timeoutController = new TimeoutController(); // setup to field for reuse. async UniTask FooAsync() { try { // you can pass timeoutController.Timeout(TimeSpan) to cancellationToken. await UnityWebRequest.Get("http://foo").SendWebRequest() .WithCancellation(timeoutController.Timeout(TimeSpan.FromSeconds(5))); timeoutController.Reset(); // call Reset(Stop timeout timer and ready for reuse) when succeed. } catch (OperationCanceledException ex) { if (timeoutController.IsTimeout()) { UnityEngine.Debug.Log("timeout"); } } } ``` If you want to use timeout with other source of cancellation, use `new TimeoutController(CancellationToken)`. ```csharp TimeoutController timeoutController; CancellationTokenSource clickCancelSource; void Start() { this.clickCancelSource = new CancellationTokenSource(); this.timeoutController = new TimeoutController(clickCancelSource); } ``` Note: UniTask has `.Timeout`, `.TimeoutWithoutException` methods however, if possible, do not use these, please pass `CancellationToken`. Because `.Timeout` work from external of task, can not stop timeoutted task. `.Timeout` means ignore result when timeout. If you pass a `CancellationToken` to the method, it will act from inside of the task, so it is possible to stop a running task. Progress --- Some async operations for unity have `ToUniTask(IProgress progress = null, ...)` extension methods. ```csharp var progress = Progress.Create(x => Debug.Log(x)); var request = await UnityWebRequest.Get("http://google.co.jp") .SendWebRequest() .ToUniTask(progress: progress); ``` You should not use standard `new System.Progress`, because it causes allocation every time. Use `Cysharp.Threading.Tasks.Progress` instead. This progress factory has two methods, `Create` and `CreateOnlyValueChanged`. `CreateOnlyValueChanged` calls only when the progress value has changed. Implementing IProgress interface to caller is better as there is no lambda allocation. ```csharp public class Foo : MonoBehaviour, IProgress { public void Report(float value) { UnityEngine.Debug.Log(value); } public async UniTaskVoid WebRequest() { var request = await UnityWebRequest.Get("http://google.co.jp") .SendWebRequest() .ToUniTask(progress: this); // pass this } } ``` PlayerLoop --- UniTask is run on a custom [PlayerLoop](https://docs.unity3d.com/ScriptReference/LowLevel.PlayerLoop.html). UniTask's playerloop based methods (such as `Delay`, `DelayFrame`, `asyncOperation.ToUniTask`, etc...) accept this `PlayerLoopTiming`. ```csharp public enum PlayerLoopTiming { Initialization = 0, LastInitialization = 1, EarlyUpdate = 2, LastEarlyUpdate = 3, FixedUpdate = 4, LastFixedUpdate = 5, PreUpdate = 6, LastPreUpdate = 7, Update = 8, LastUpdate = 9, PreLateUpdate = 10, LastPreLateUpdate = 11, PostLateUpdate = 12, LastPostLateUpdate = 13 #if UNITY_2020_2_OR_NEWER TimeUpdate = 14, LastTimeUpdate = 15, #endif } ``` It indicates when to run, you can check [PlayerLoopList.md](https://gist.github.com/neuecc/bc3a1cfd4d74501ad057e49efcd7bdae) to Unity's default playerloop and injected UniTask's custom loop. `PlayerLoopTiming.Update` is similar to `yield return null` in a coroutine, but it is called before Update(Update and uGUI events(button.onClick, etc...) are called on `ScriptRunBehaviourUpdate`, yield return null is called on `ScriptRunDelayedDynamicFrameRate`). `PlayerLoopTiming.FixedUpdate` is similar to `WaitForFixedUpdate`. > `PlayerLoopTiming.LastPostLateUpdate` is not equivalent to coroutine's `yield return new WaitForEndOfFrame()`. Coroutine's WaitForEndOfFrame seems to run after the PlayerLoop is done. Some methods that require coroutine's end of frame(`Texture2D.ReadPixels`, `ScreenCapture.CaptureScreenshotAsTexture`, `CommandBuffer`, etc) do not work correctly when replaced with async/await. In these cases, pass MonoBehaviour(coroutine runnner) to `UniTask.WaitForEndOfFrame`. For example, `await UniTask.WaitForEndOfFrame(this);` is lightweight allocation free alternative of `yield return new WaitForEndOfFrame()`. > > Note: In Unity 2023.1 or newer, `await UniTask.WaitForEndOfFrame();` no longer requires MonoBehaviour. It uses `UnityEngine.Awaitable.EndOfFrameAsync`. `yield return null` and `UniTask.Yield` are similar but different. `yield return null` always returns next frame but `UniTask.Yield` returns next called. That is, call `UniTask.Yield(PlayerLoopTiming.Update)` on `PreUpdate`, it returns same frame. `UniTask.NextFrame()` guarantees return next frame, you can expect this to behave exactly the same as `yield return null`. > UniTask.Yield(without CancellationToken) is a special type, returns `YieldAwaitable` and runs on YieldRunner. It is the most lightweight and fastest. `AsyncOperation` is returned from native timing. For example, await `SceneManager.LoadSceneAsync` is returned from `EarlyUpdate.UpdatePreloading` and after being called, the loaded scene's `Start` is called from `EarlyUpdate.ScriptRunDelayedStartupFrame`. Also `await UnityWebRequest` is returned from `EarlyUpdate.ExecuteMainThreadJobs`. In UniTask, await directly uses native timing, while `WithCancellation` and `ToUniTask` use specified timing. This is usually not a particular problem, but with `LoadSceneAsync`, it causes a different order of Start and continuation after await. So it is recommended not to use `LoadSceneAsync.ToUniTask`. > Note: When using Unity 2023.1 or newer, ensure you have `using UnityEngine;` in the using statements of your file when working with new `UnityEngine.Awaitable` methods like `SceneManager.LoadSceneAsync`. > This prevents compilation errors by avoiding the use of the `UnityEngine.AsyncOperation` version. In the stacktrace, you can check where it is running in playerloop. ![image](https://user-images.githubusercontent.com/46207/83735571-83caea80-a68b-11ea-8d22-5e22864f0d24.png) By default, UniTask's PlayerLoop is initialized at `[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]`. The order in which methods are called in BeforeSceneLoad is nondeterministic, so if you want to use UniTask in other BeforeSceneLoad methods, you should try to initialize it before this. ```csharp // AfterAssembliesLoaded is called before BeforeSceneLoad [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)] public static void InitUniTaskLoop() { var loop = PlayerLoop.GetCurrentPlayerLoop(); Cysharp.Threading.Tasks.PlayerLoopHelper.Initialize(ref loop); } ``` If you import Unity's `Entities` package, that resets the custom player loop to default at `BeforeSceneLoad` and injects ECS's loop. When Unity calls ECS's inject method after UniTask's initialize method, UniTask will no longer work. To solve this issue, you can re-initialize the UniTask PlayerLoop after ECS is initialized. ```csharp // Get ECS Loop. var playerLoop = ScriptBehaviourUpdateOrder.CurrentPlayerLoop; // Setup UniTask's PlayerLoop. PlayerLoopHelper.Initialize(ref playerLoop); ``` You can diagnose whether UniTask's player loop is ready by calling `PlayerLoopHelper.IsInjectedUniTaskPlayerLoop()`. And also `PlayerLoopHelper.DumpCurrentPlayerLoop` logs all current playerloops to console. ```csharp void Start() { UnityEngine.Debug.Log("UniTaskPlayerLoop ready? " + PlayerLoopHelper.IsInjectedUniTaskPlayerLoop()); PlayerLoopHelper.DumpCurrentPlayerLoop(); } ``` You can optimize loop cost slightly by remove unuse PlayerLoopTiming injection. You can call `PlayerLoopHelper.Initialize(InjectPlayerLoopTimings)` on initialize. ```csharp var loop = PlayerLoop.GetCurrentPlayerLoop(); PlayerLoopHelper.Initialize(ref loop, InjectPlayerLoopTimings.Minimum); // minimum is Update | FixedUpdate | LastPostLateUpdate ``` `InjectPlayerLoopTimings` has three preset, `All` and `Standard`(All without last except LastPostLateUpdate), `Minimum`(`Update | FixedUpdate | LastPostLateUpdate`). Default is All and you can combine custom inject timings like `InjectPlayerLoopTimings.Update | InjectPlayerLoopTimings.FixedUpdate | InjectPlayerLoopTimings.PreLateUpdate`. You can make error to use uninjected `PlayerLoopTiming` by [Microsoft.CodeAnalysis.BannedApiAnalyzers](https://github.com/dotnet/roslyn-analyzers/blob/master/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/BannedApiAnalyzers.Help.md). For example, you can setup `BannedSymbols.txt` like this for `InjectPlayerLoopTimings.Minimum`. ```txt F:Cysharp.Threading.Tasks.PlayerLoopTiming.Initialization; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastInitialization; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.EarlyUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastEarlyUpdate; Isn't injected this PlayerLoop in this project.d F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastFixedUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.PreUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastPreUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.PreLateUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastPreLateUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.PostLateUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.TimeUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastTimeUpdate; Isn't injected this PlayerLoop in this project. ``` You can configure `RS0030` severity to error. ![image](https://user-images.githubusercontent.com/46207/109150837-bb933880-77ac-11eb-85ba-4fd15819dbd0.png) async void vs async UniTaskVoid --- `async void` is a standard C# task system so it does not run on UniTask systems. It is better not to use it. `async UniTaskVoid` is a lightweight version of `async UniTask` because it does not have awaitable completion and reports errors immediately to `UniTaskScheduler.UnobservedTaskException`. If you don't require awaiting (fire and forget), using `UniTaskVoid` is better. Unfortunately to dismiss warning, you're required to call `Forget()`. ```csharp public async UniTaskVoid FireAndForgetMethod() { // do anything... await UniTask.Yield(); } public void Caller() { FireAndForgetMethod().Forget(); } ``` Also UniTask has the `Forget` method, it is similar to `UniTaskVoid` and has the same effects. However `UniTaskVoid` is more efficient if you completely don't use `await`。 ```csharp public async UniTask DoAsync() { // do anything... await UniTask.Yield(); } public void Caller() { DoAsync().Forget(); } ``` To use an async lambda registered to an event, don't use `async void`. Instead you can use `UniTask.Action` or `UniTask.UnityAction`, both of which create a delegate via `async UniTaskVoid` lambda. ```csharp Action actEvent; UnityAction unityEvent; // especially used in uGUI // Bad: async void actEvent += async () => { }; unityEvent += async () => { }; // Ok: create Action delegate by lambda actEvent += UniTask.Action(async () => { await UniTask.Yield(); }); unityEvent += UniTask.UnityAction(async () => { await UniTask.Yield(); }); ``` `UniTaskVoid` can also be used in MonoBehaviour's `Start` method. ```csharp class Sample : MonoBehaviour { async UniTaskVoid Start() { // async init code. } } ``` UniTaskTracker --- useful for checking (leaked) UniTasks. You can open tracker window in `Window -> UniTask Tracker`. ![image](https://user-images.githubusercontent.com/46207/83527073-4434bf00-a522-11ea-86e9-3b3975b26266.png) * Enable AutoReload(Toggle) - Reload automatically. * Reload - Reload view. * GC.Collect - Invoke GC.Collect. * Enable Tracking(Toggle) - Start to track async/await UniTask. Performance impact: low. * Enable StackTrace(Toggle) - Capture StackTrace when task is started. Performance impact: high. UniTaskTracker is intended for debugging use only as enabling tracking and capturing stacktraces is useful but has a heavy performance impact. Recommended usage is to enable both tracking and stacktraces to find task leaks and to disable them both when done. External Assets --- By default, UniTask supports TextMeshPro(`BindTo(TMP_Text)` and `TMP_InputField` event extensions like standard uGUI `InputField`), DOTween(`Tween` as awaitable) and Addressables(`AsyncOperationHandle` and `AsyncOperationHandle` as awaitable). There are defined in separated asmdefs like `UniTask.TextMeshPro`, `UniTask.DOTween`, `UniTask.Addressables`. TextMeshPro and Addressables support are automatically enabled when importing their packages from package manager. However for DOTween support, after importing from the [DOTWeen assets](https://assetstore.unity.com/packages/tools/animation/dotween-hotween-v2-27676r) and define the scripting define symbol `UNITASK_DOTWEEN_SUPPORT` to enable it. ```csharp // sequential await transform.DOMoveX(2, 10); await transform.DOMoveZ(5, 20); // parallel with cancellation var ct = this.GetCancellationTokenOnDestroy(); await UniTask.WhenAll( transform.DOMoveX(10, 3).WithCancellation(ct), transform.DOScale(10, 3).WithCancellation(ct)); ``` DOTween support's default behaviour(`await`, `WithCancellation`, `ToUniTask`) awaits tween is killed. It works on both Complete(true/false) and Kill(true/false). But if you want to reuse tweens (`SetAutoKill(false)`), it does not work as expected. If you want to await for another timing, the following extension methods exist in Tween, `AwaitForComplete`, `AwaitForPause`, `AwaitForPlay`, `AwaitForRewind`, `AwaitForStepComplete`. AsyncEnumerable and Async LINQ --- Unity 2020.2 supports C# 8.0 so you can use `await foreach`. This is the new Update notation in the async era. ```csharp // Unity 2020.2, C# 8.0 await foreach (var _ in UniTaskAsyncEnumerable.EveryUpdate().WithCancellation(token)) { Debug.Log("Update() " + Time.frameCount); } ``` In a C# 7.3 environment, you can use the `ForEachAsync` method to work in almost the same way. ```csharp // C# 7.3(Unity 2018.3~) await UniTaskAsyncEnumerable.EveryUpdate().ForEachAsync(_ => { Debug.Log("Update() " + Time.frameCount); }, token); ``` `UniTask.WhenEach` that is similar to .NET 9's `Task.WhenEach` can consume new way for await multiple tasks. ```csharp await foreach (var result in UniTask.WhenEach(task1, task2, task3)) { // The result is of type WhenEachResult. // It contains either `T Result` or `Exception Exception`. // You can check `IsCompletedSuccessfully` or `IsFaulted` to determine whether to access `.Result` or `.Exception`. // If you want to throw an exception when `IsFaulted` and retrieve the result when successful, use `GetResult()`. Debug.Log(result.GetResult()); } ``` UniTaskAsyncEnumerable implements asynchronous LINQ, similar to LINQ in `IEnumerable` or Rx in `IObservable`. All standard LINQ query operators can be applied to asynchronous streams. For example, the following code shows how to apply a Where filter to a button-click asynchronous stream that runs once every two clicks. ```csharp await okButton.OnClickAsAsyncEnumerable().Where((x, i) => i % 2 == 0).ForEachAsync(_ => { }); ``` Fire and Forget style(for example, event handling), you can also use `Subscribe`. ```csharp okButton.OnClickAsAsyncEnumerable().Where((x, i) => i % 2 == 0).Subscribe(_ => { }); ``` Async LINQ is enabled when `using Cysharp.Threading.Tasks.Linq;`, and `UniTaskAsyncEnumerable` is defined in `UniTask.Linq` asmdef. It's closer to UniRx (Reactive Extensions), but UniTaskAsyncEnumerable is a pull-based asynchronous stream, whereas Rx was a push-based asynchronous stream. Note that although similar, the characteristics are different and the details behave differently along with them. `UniTaskAsyncEnumerable` is the entry point like `Enumerable`. In addition to the standard query operators, there are other generators for Unity such as `EveryUpdate`, `Timer`, `TimerFrame`, `Interval`, `IntervalFrame`, and `EveryValueChanged`. And also added additional UniTask original query operators like `Append`, `Prepend`, `DistinctUntilChanged`, `ToHashSet`, `Buffer`, `CombineLatest`,`Merge` `Do`, `Never`, `ForEachAsync`, `Pairwise`, `Publish`, `Queue`, `Return`, `SkipUntil`, `TakeUntil`, `SkipUntilCanceled`, `TakeUntilCanceled`, `TakeLast`, `Subscribe`. The method with Func as an argument has three additional overloads, `***Await`, `***AwaitWithCancellation`. ```csharp Select(Func selector) SelectAwait(Func> selector) SelectAwaitWithCancellation(Func> selector) ``` If you want to use the `async` method inside the func, use the `***Await` or `***AwaitWithCancellation`. How to create an async iterator: C# 8.0 supports async iterator(`async yield return`) but it only allows `IAsyncEnumerable` and of course requires C# 8.0. UniTask supports `UniTaskAsyncEnumerable.Create` method to create custom async iterator. ```csharp // IAsyncEnumerable, C# 8.0 version of async iterator. ( do not use this style, IAsyncEnumerable is not controled in UniTask). public async IAsyncEnumerable MyEveryUpdate([EnumeratorCancellation]CancellationToken cancelationToken = default) { var frameCount = 0; await UniTask.Yield(); while (!token.IsCancellationRequested) { yield return frameCount++; await UniTask.Yield(); } } // UniTaskAsyncEnumerable.Create and use `await writer.YieldAsync` instead of `yield return`. public IUniTaskAsyncEnumerable MyEveryUpdate() { // writer(IAsyncWriter) has `YieldAsync(value)` method. return UniTaskAsyncEnumerable.Create(async (writer, token) => { var frameCount = 0; await UniTask.Yield(); while (!token.IsCancellationRequested) { await writer.YieldAsync(frameCount++); // instead of `yield return` await UniTask.Yield(); } }); } ``` Awaitable Events --- All uGUI component implements `***AsAsyncEnumerable` to convert asynchronous streams of events. ```csharp async UniTask TripleClick() { // In default, used button.GetCancellationTokenOnDestroy to manage lieftime of async await button.OnClickAsync(); await button.OnClickAsync(); await button.OnClickAsync(); Debug.Log("Three times clicked"); } // more efficient way async UniTask TripleClick() { using (var handler = button.GetAsyncClickEventHandler()) { await handler.OnClickAsync(); await handler.OnClickAsync(); await handler.OnClickAsync(); Debug.Log("Three times clicked"); } } // use async LINQ async UniTask TripleClick(CancellationToken token) { await button.OnClickAsAsyncEnumerable().Take(3).Last(); Debug.Log("Three times clicked"); } // use async LINQ2 async UniTask TripleClick(CancellationToken token) { await button.OnClickAsAsyncEnumerable().Take(3).ForEachAsync(_ => { Debug.Log("Every clicked"); }); Debug.Log("Three times clicked, complete."); } ``` All MonoBehaviour message events can convert async-streams by `AsyncTriggers` that can be enabled by `using Cysharp.Threading.Tasks.Triggers;`. AsyncTrigger can be created using `GetAsync***Trigger` and triggers itself as UniTaskAsyncEnumerable. ```csharp var trigger = this.GetOnCollisionEnterAsyncHandler(); await trigger.OnCollisionEnterAsync(); await trigger.OnCollisionEnterAsync(); await trigger.OnCollisionEnterAsync(); // every moves. await this.GetAsyncMoveTrigger().ForEachAsync(axisEventData => { }); ``` `AsyncReactiveProperty`, `AsyncReadOnlyReactiveProperty` is UniTask's version of ReactiveProperty. `BindTo` extension method of `IUniTaskAsyncEnumerable` for binding asynchronous stream values to Unity components(Text/Selectable/TMP/Text). ```csharp var rp = new AsyncReactiveProperty(99); // AsyncReactiveProperty itself is IUniTaskAsyncEnumerable, you can query by LINQ rp.ForEachAsync(x => { Debug.Log(x); }, this.GetCancellationTokenOnDestroy()).Forget(); rp.Value = 10; // push 10 to all subscriber rp.Value = 11; // push 11 to all subscriber // WithoutCurrent ignore initial value // BindTo bind stream value to unity components. rp.WithoutCurrent().BindTo(this.textComponent); await rp.WaitAsync(); // wait until next value set // also exists ToReadOnlyAsyncReactiveProperty var rp2 = new AsyncReactiveProperty(99); var rorp = rp.CombineLatest(rp2, (x, y) => (x, y)).ToReadOnlyAsyncReactiveProperty(CancellationToken.None); ``` A pull-type asynchronous stream does not get the next values until the asynchronous processing in the sequence is complete. This could spill data from push-type events such as buttons. ```csharp // can not get click event during 3 seconds complete. await button.OnClickAsAsyncEnumerable().ForEachAwaitAsync(async x => { await UniTask.Delay(TimeSpan.FromSeconds(3)); }); ``` It is useful (prevent double-click) but not useful sometimes. Using the `Queue()` method will also queue events during asynchronous processing. ```csharp // queued message in asynchronous processing await button.OnClickAsAsyncEnumerable().Queue().ForEachAwaitAsync(async x => { await UniTask.Delay(TimeSpan.FromSeconds(3)); }); ``` Or use `Subscribe`, fire and forget style. ```csharp button.OnClickAsAsyncEnumerable().Subscribe(async x => { await UniTask.Delay(TimeSpan.FromSeconds(3)); }); ``` Channel --- `Channel` is the same as [System.Threading.Tasks.Channels](https://docs.microsoft.com/en-us/dotnet/api/system.threading.channels?view=netcore-3.1) which is similar to a GoLang Channel. Currently it only supports multiple-producer, single-consumer unbounded channels. It can create by `Channel.CreateSingleConsumerUnbounded()`. For producer(`.Writer`), use `TryWrite` to push value and `TryComplete` to complete channel. For consumer(`.Reader`), use `TryRead`, `WaitToReadAsync`, `ReadAsync`, `Completion` and `ReadAllAsync` to read queued messages. `ReadAllAsync` returns `IUniTaskAsyncEnumerable` so query LINQ operators. Reader only allows single-consumer but uses `.Publish()` query operator to enable multicast message. For example, make pub/sub utility. ```csharp public class AsyncMessageBroker : IDisposable { Channel channel; IConnectableUniTaskAsyncEnumerable multicastSource; IDisposable connection; public AsyncMessageBroker() { channel = Channel.CreateSingleConsumerUnbounded(); multicastSource = channel.Reader.ReadAllAsync().Publish(); connection = multicastSource.Connect(); // Publish returns IConnectableUniTaskAsyncEnumerable. } public void Publish(T value) { channel.Writer.TryWrite(value); } public IUniTaskAsyncEnumerable Subscribe() { return multicastSource; } public void Dispose() { channel.Writer.TryComplete(); connection.Dispose(); } } ``` vs Awaitable --- Unity 6 introduces the awaitable type, [Awaitable](https://docs.unity3d.com/6000.0/Documentation/ScriptReference/Awaitable.html). To put it simply, Awaitable can be considered a subset of UniTask, and in fact, Awaitable's design was influenced by UniTask. It should be able to handle PlayerLoop-based awaits, pooled Tasks, and support for cancellation with `CancellationToken` in a similar way. With its inclusion in the standard library, you may wonder whether to continue using UniTask or migrate to Awaitable. Here's a brief guide. First, the functionality provided by Awaitable is equivalent to what coroutines offer. Instead of `yield return`, you use await; `await NextFrameAsync()` replaces `yield return null`; and there are equivalents for `WaitForSeconds` and `EndOfFrame`. However, that's the extent of it. Being coroutine-based in terms of functionality, it lacks Task-based features. In practical application development using async/await, operations like `WhenAll` are essential. Additionally, UniTask enables many frame-based operations (such as `DelayFrame`) and more flexible PlayerLoopTiming control, which are not available in Awaitable. Of course, there's no Tracker Window either. Therefore, I recommend using UniTask for application development. UniTask is a superset of Awaitable and includes many essential features. For library development, where you want to avoid external dependencies, using Awaitable as a return type for methods would be appropriate. Awaitable can be converted to UniTask using `AsUniTask`, so there's no issue in handling Awaitable-based functionality within the UniTask library. Of course, if you don't need to worry about dependencies, using UniTask would be the best choice even for library development. For Unit Testing --- Unity's `[UnityTest]` attribute can test coroutine(IEnumerator) but can not test async. `UniTask.ToCoroutine` bridges async/await to coroutine so you can test async methods. ```csharp [UnityTest] public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () => { var time = Time.realtimeSinceStartup; Time.timeScale = 0.5f; try { await UniTask.Delay(TimeSpan.FromSeconds(3), ignoreTimeScale: true); var elapsed = Time.realtimeSinceStartup - time; Assert.AreEqual(3, (int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)); } finally { Time.timeScale = 1.0f; } }); ``` UniTask's own unit tests are written using Unity Test Runner and [Cysharp/RuntimeUnitTestToolkit](https://github.com/Cysharp/RuntimeUnitTestToolkit) to integrate with CI and check if IL2CPP is working. ThreadPool limitation --- Most UniTask methods run on a single thread (PlayerLoop), with only `UniTask.Run`(`Task.Run` equivalent) and `UniTask.SwitchToThreadPool` running on a thread pool. If you use a thread pool, it won't work with WebGL and so on. `UniTask.Run` is now deprecated. You can use `UniTask.RunOnThreadPool` instead. And also consider whether you can use `UniTask.Create` or `UniTask.Void`. IEnumerator.ToUniTask limitation --- You can convert coroutine(IEnumerator) to UniTask(or await directly) but it has some limitations. * `WaitForEndOfFrame`/`WaitForFixedUpdate`/`Coroutine` is not supported. * Consuming loop timing is not the same as `StartCoroutine`, it uses the specified `PlayerLoopTiming` and the default `PlayerLoopTiming.Update` is run before MonoBehaviour's `Update` and `StartCoroutine`'s loop. If you want fully compatible conversion from coroutine to async, use the `IEnumerator.ToUniTask(MonoBehaviour coroutineRunner)` overload. It executes StartCoroutine on an instance of the argument MonoBehaviour and waits for it to complete in UniTask. For UnityEditor --- UniTask can run on Unity Editor like an Editor Coroutine. However, there are some limitations. * UniTask.Delay's DelayType.DeltaTime, UnscaledDeltaTime do not work correctly because they can not get deltaTime in editor. Therefore run on EditMode, automatically change DelayType to `DelayType.Realtime` that wait for the right time. * All PlayerLoopTiming run on the timing `EditorApplication.update`. * `-batchmode` with `-quit` does not work because Unity does not run `EditorApplication.update` and quit after a single frame. Instead, don't use `-quit` and quit manually with `EditorApplication.Exit(0)`. Compare with Standard Task API --- UniTask has many standard Task-like APIs. This table shows what the alternative apis are. Use standard type. | .NET Type | UniTask Type | | --- | --- | | `IProgress` | --- | | `CancellationToken` | --- | | `CancellationTokenSource` | --- | Use UniTask type. | .NET Type | UniTask Type | | --- | --- | | `Task`/`ValueTask` | `UniTask` | | `Task`/`ValueTask` | `UniTask` | | `async void` | `async UniTaskVoid` | | `+= async () => { }` | `UniTask.Void`, `UniTask.Action`, `UniTask.UnityAction` | | --- | `UniTaskCompletionSource` | | `TaskCompletionSource` | `UniTaskCompletionSource`/`AutoResetUniTaskCompletionSource` | | `ManualResetValueTaskSourceCore` | `UniTaskCompletionSourceCore` | | `IValueTaskSource` | `IUniTaskSource` | | `IValueTaskSource` | `IUniTaskSource` | | `ValueTask.IsCompleted` | `UniTask.Status.IsCompleted()` | | `ValueTask.IsCompleted` | `UniTask.Status.IsCompleted()` | | `new Progress` | `Progress.Create` | | `CancellationToken.Register(UnsafeRegister)` | `CancellationToken.RegisterWithoutCaptureExecutionContext` | | `CancellationTokenSource.CancelAfter` | `CancellationTokenSource.CancelAfterSlim` | | `Channel.CreateUnbounded(false){ SingleReader = true }` | `Channel.CreateSingleConsumerUnbounded` | | `IAsyncEnumerable` | `IUniTaskAsyncEnumerable` | | `IAsyncEnumerator` | `IUniTaskAsyncEnumerator` | | `IAsyncDisposable` | `IUniTaskAsyncDisposable` | | `Task.Delay` | `UniTask.Delay` | | `Task.Yield` | `UniTask.Yield` | | `Task.Run` | `UniTask.RunOnThreadPool` | | `Task.WhenAll` | `UniTask.WhenAll` | | `Task.WhenAny` | `UniTask.WhenAny` | | `Task.WhenEach` | `UniTask.WhenEach` | | `Task.CompletedTask` | `UniTask.CompletedTask` | | `Task.FromException` | `UniTask.FromException` | | `Task.FromResult` | `UniTask.FromResult` | | `Task.FromCanceled` | `UniTask.FromCanceled` | | `Task.ContinueWith` | `UniTask.ContinueWith` | | `TaskScheduler.UnobservedTaskException` | `UniTaskScheduler.UnobservedTaskException` | Pooling Configuration --- UniTask aggressively caches async promise objects to achieve zero allocation (for technical details, see blog post [UniTask v2 — Zero Allocation async/await for Unity, with Asynchronous LINQ](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd)). By default, it caches all promises but you can configure `TaskPool.SetMaxPoolSize` to your value, the value indicates cache size per type. `TaskPool.GetCacheSizeInfo` returns currently cached objects in pool. ```csharp foreach (var (type, size) in TaskPool.GetCacheSizeInfo()) { Debug.Log(type + ":" + size); } ``` Allocation on Profiler --- In UnityEditor the profiler shows allocation of compiler generated AsyncStateMachine but it only occurs in debug(development) build. C# Compiler generates AsyncStateMachine as class on Debug build and as struct on Release build. Unity supports Code Optimization option starting in 2020.1 (right, footer). ![](https://user-images.githubusercontent.com/46207/89967342-2f944600-dc8c-11ea-99fc-0b74527a16f6.png) You can change C# compiler optimization to release to remove AsyncStateMachine allocation in development builds. This optimization option can also be set via `Compilation.CompilationPipeline-codeOptimization`, and `Compilation.CodeOptimization`. UniTaskSynchronizationContext --- Unity's default SynchronizationContext(`UnitySynchronizationContext`) is a poor implementation for performance. UniTask bypasses `SynchronizationContext`(and `ExecutionContext`) so it does not use it but if exists in `async Task`, still used it. `UniTaskSynchronizationContext` is a replacement of `UnitySynchronizationContext` which is better for performance. ```csharp public class SyncContextInjecter { [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] public static void Inject() { SynchronizationContext.SetSynchronizationContext(new UniTaskSynchronizationContext()); } } ``` This is an optional choice and is not always recommended; `UniTaskSynchronizationContext` is less performant than `async UniTask` and is not a complete UniTask replacement. It also does not guarantee full behavioral compatibility with the `UnitySynchronizationContext`. API References --- UniTask's API References are hosted at [cysharp.github.io/UniTask](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.html) by [DocFX](https://dotnet.github.io/docfx/) and [Cysharp/DocfXTemplate](https://github.com/Cysharp/DocfxTemplate). For example, UniTask's factory methods can be seen at [UniTask#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.UniTask.html#methods-1). UniTaskAsyncEnumerable's factory/extension methods can be seen at [UniTaskAsyncEnumerable#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.Linq.UniTaskAsyncEnumerable.html#methods-1). UPM Package --- ### Install via git URL Requires a version of unity that supports path query parameter for git packages (Unity >= 2019.3.4f1, Unity >= 2020.1a21). You can add `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask` to Package Manager ![image](https://user-images.githubusercontent.com/46207/79450714-3aadd100-8020-11ea-8aae-b8d87fc4d7be.png) ![image](https://user-images.githubusercontent.com/46207/83702872-e0f17c80-a648-11ea-8183-7469dcd4f810.png) or add `"com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask"` to `Packages/manifest.json`. If you want to set a target version, UniTask uses the `*.*.*` release tag so you can specify a version like `#2.1.0`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.1.0`. .NET Core --- For .NET Core, use NuGet. > PM> Install-Package [UniTask](https://www.nuget.org/packages/UniTask) UniTask of .NET Core version is a subset of Unity UniTask with PlayerLoop dependent methods removed. It runs at higher performance than the standard Task/ValueTask, but you should be careful to ignore the ExecutionContext/SynchronizationContext when using it. `AsyncLocal` also does not work because it ignores ExecutionContext. If you use UniTask internally, but provide ValueTask as an external API, you can write it like the following(Inspired by [PooledAwait](https://github.com/mgravell/PooledAwait)). ```csharp public class ZeroAllocAsyncAwaitInDotNetCore { public ValueTask DoAsync(int x, int y) { return Core(this, x, y); static async UniTask Core(ZeroAllocAsyncAwaitInDotNetCore self, int x, int y) { // do anything... await Task.Delay(TimeSpan.FromSeconds(x + y)); await UniTask.Yield(); return 10; } } } // UniTask does not return to original SynchronizationContext but you can use helper `ReturnToCurrentSynchronizationContext`. public ValueTask TestAsync() { await using (UniTask.ReturnToCurrentSynchronizationContext()) { await UniTask.SwitchToThreadPool(); // do anything.. } } ``` .NET Core version is intended to allow users to use UniTask as an interface when sharing code with Unity (such as [Cysharp/MagicOnion](https://github.com/Cysharp/MagicOnion/)). .NET Core version of UniTask enables smooth code sharing. Utility methods such as WhenAll which are equivalent to UniTask are provided as [Cysharp/ValueTaskSupplement](https://github.com/Cysharp/ValueTaskSupplement). License --- This library is under the MIT License. ================================================ FILE: README_CN.md ================================================ 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) 为Unity提供一个高性能，零堆内存分配的 async/await 异步方案。 - 基于值类型的`UniTask`和自定义的 AsyncMethodBuilder 来实现零堆内存分配 - 使所有 Unity 的 AsyncOperations 和 Coroutines 可等待 - 基于 PlayerLoop 的任务（`UniTask.Yield`，`UniTask.Delay`，`UniTask.DelayFrame`等..）可以替换所有协程操作 - 对 MonoBehaviour 消息事件和 uGUI 事件进行可等待/异步枚举扩展 - 完全在 Unity 的 PlayerLoop 上运行，因此不使用Thread，并且同样能在 WebGL、wasm 等平台上运行。 - 带有 Channel 和 AsyncReactiveProperty 的异步 LINQ - 提供一个 TaskTracker EditorWindow 以追踪所有 UniTask 分配来预防内存泄漏 - 与原生 Task/ValueTask/IValueTaskSource 高度兼容的行为 有关技术细节，请参阅博客文章：[UniTask v2 — 适用于 Unity 的零堆内存分配的async/await，支持异步 LINQ](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd) 有关高级技巧，请参阅博客文章：[通过异步装饰器模式扩展 UnityWebRequest — UniTask 的高级技术](https://medium.com/@neuecc/extends-unitywebrequest-via-async-decorator-pattern-advanced-techniques-of-unitask-ceff9c5ee846) ## 目录 - [入门](#%E5%85%A5%E9%97%A8) - [UniTask 和 AsyncOperation 的基础知识](#unitask-%E5%92%8C-asyncoperation-%E7%9A%84%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86) - [取消和异常处理](#%E5%8F%96%E6%B6%88%E5%92%8C%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86) - [超时处理](#%E8%B6%85%E6%97%B6%E5%A4%84%E7%90%86) - [进度](#%E8%BF%9B%E5%BA%A6) - [PlayerLoop](#playerloop) - [async void 与 async UniTaskVoid 对比](#async-void-%E4%B8%8E-async-unitaskvoid-%E5%AF%B9%E6%AF%94) - [UniTaskTracker](#unitasktracker) - [外部拓展](#%E5%A4%96%E9%83%A8%E6%8B%93%E5%B1%95) - [AsyncEnumerable 和 Async LINQ](#asyncenumerable-%E5%92%8C-async-linq) - [可等待事件](#%E5%8F%AF%E7%AD%89%E5%BE%85%E4%BA%8B%E4%BB%B6) - [Channel](#channel) - [与 Awaitable 对比](#%E4%B8%8E-awaitable-%E5%AF%B9%E6%AF%94) - [单元测试](#%E5%8D%95%E5%85%83%E6%B5%8B%E8%AF%95) - [线程池的限制](#%E7%BA%BF%E7%A8%8B%E6%B1%A0%E7%9A%84%E9%99%90%E5%88%B6) - [IEnumerator.ToUniTask 的限制](#ienumeratortounitask-%E7%9A%84%E9%99%90%E5%88%B6) - [关于 UnityEditor](#%E5%85%B3%E4%BA%8E-unityeditor) - [与原生 Task API 对比](#%E4%B8%8E%E5%8E%9F%E7%94%9F-task-api-%E5%AF%B9%E6%AF%94) - [池化配置](#%E6%B1%A0%E5%8C%96%E9%85%8D%E7%BD%AE) - [Profiler 下的堆内存分配](#profiler-%E4%B8%8B%E7%9A%84%E5%A0%86%E5%86%85%E5%AD%98%E5%88%86%E9%85%8D) - [UniTaskSynchronizationContext](#unitasksynchronizationcontext) - [API 文档](#api-%E6%96%87%E6%A1%A3) - [UPM 包](#upm-%E5%8C%85) - [通过 git URL 安装](#%E9%80%9A%E8%BF%87-git-url-%E5%AE%89%E8%A3%85) - [关于 .NET Core](#%E5%85%B3%E4%BA%8E-net-core) - [许可证](#%E8%AE%B8%E5%8F%AF%E8%AF%81) 入门 --- 通过[UniTask/releases](https://github.com/Cysharp/UniTask/releases)页面中提供的[UPM 包](https://github.com/Cysharp/UniTask#upm-package)或资产包（`UniTask.*.*.*.unitypackage`）安装。 ```csharp // 使用 UniTask 所需的命名空间 using Cysharp.Threading.Tasks; // 您可以返回一个形如 UniTask(或 UniTask) 的类型，这种类型事为Unity定制的，作为替代原生 Task 的轻量级方案 // 为 Unity 集成的零堆内存分配，快速调用，0消耗的 async/await 方案 async UniTask DemoAsync() { // 您可以等待一个 Unity 异步对象 var asset = await Resources.LoadAsync("foo"); var txt = (await UnityWebRequest.Get("https://...").SendWebRequest()).downloadHandler.text; await SceneManager.LoadSceneAsync("scene2"); // .WithCancellation 会启用取消功能，GetCancellationTokenOnDestroy 表示获取一个依赖对象生命周期的 Cancel 句柄，当对象被销毁时，将会调用这个 Cancel 句柄，从而实现取消的功能 // 在 Unity 2022.2之后，您可以在 MonoBehaviour 中使用`destroyCancellationToken` var asset2 = await Resources.LoadAsync("bar").WithCancellation(this.GetCancellationTokenOnDestroy()); // .ToUniTask 可接收一个 progress 回调以及一些配置参数，Progress.Create 是 IProgress 的轻量级替代方案 var asset3 = await Resources.LoadAsync("baz").ToUniTask(Progress.Create(x => Debug.Log(x))); // 等待一个基于帧的延时操作（就像一个协程一样） await UniTask.DelayFrame(100); // yield return new WaitForSeconds/WaitForSecondsRealtime 的替代方案 await UniTask.Delay(TimeSpan.FromSeconds(10), ignoreTimeScale: false); // 可以等待任何 playerloop 的生命周期（PreUpdate，Update，LateUpdate等） await UniTask.Yield(PlayerLoopTiming.PreLateUpdate); // yield return null 的替代方案 await UniTask.Yield(); await UniTask.NextFrame(); // WaitForEndOfFrame 的替代方案 #if UNITY_2023_1_OR_NEWER await UniTask.WaitForEndOfFrame(); #else // 需要 MonoBehaviour（CoroutineRunner） await UniTask.WaitForEndOfFrame(this); // this是一个 MonoBehaviour #endif // yield return new WaitForFixedUpdate 的替代方案，（等同于 UniTask.Yield(PlayerLoopTiming.FixedUpdate)） await UniTask.WaitForFixedUpdate(); // yield return WaitUntil 的替代方案 await UniTask.WaitUntil(() => isActive == false); // WaitUntil 扩展，指定某个值改变时触发 await UniTask.WaitUntilValueChanged(this, x => x.isActive); // 您可以直接 await 一个 IEnumerator 协程 await FooCoroutineEnumerator(); // 您可以直接 await 一个原生 task await Task.Run(() => 100); // 多线程示例，在此行代码后的内容都运行在一个线程池上 await UniTask.SwitchToThreadPool(); /* 工作在线程池上的代码 */ // 转回主线程（等同于 UniRx 的`ObserveOnMainThread`） await UniTask.SwitchToMainThread(); // 获取异步的 webrequest async UniTask GetTextAsync(UnityWebRequest req) { var op = await req.SendWebRequest(); return op.downloadHandler.text; } var task1 = GetTextAsync(UnityWebRequest.Get("http://google.com")); var task2 = GetTextAsync(UnityWebRequest.Get("http://bing.com")); var task3 = GetTextAsync(UnityWebRequest.Get("http://yahoo.com")); // 构造一个 async-wait，并通过元组语义轻松获取所有结果 var (google, bing, yahoo) = await UniTask.WhenAll(task1, task2, task3); // WhenAll 的简写形式，元组可以直接 await var (google2, bing2, yahoo2) = await (task1, task2, task3); // 返回一个异步值，或者您也可以使用`UniTask`（无结果），`UniTaskVoid`（不可等待） return (asset as TextAsset)?.text ?? throw new InvalidOperationException("Asset not found"); } ``` UniTask 和 AsyncOperation 的基础知识 --- UniTask 功能依赖于 C# 7.0（[task-like custom async method builder feature](https://github.com/dotnet/roslyn/blob/master/docs/features/task-types.md)），所以需要`Unity 2018.3`之后的版本，官方支持的最低版本是`Unity 2018.4.13f1`。 为什么需要 UniTask（自定义task对象）？因为原生 Task 太重，与 Unity 线程（单线程）相性不好。因为 Unity 的异步对象由 Unity 的引擎层自动调度，所以 UniTask 不使用线程和 SynchronizationContext/ExecutionContext。它实现了更快和更低的分配，并且与Unity完全兼容。 您可以在使用`using Cysharp.Threading.Tasks;`时对`AsyncOperation`，`ResourceRequest`，`AssetBundleRequest`，`AssetBundleCreateRequest`，`UnityWebRequestAsyncOperation`，`AsyncGPUReadbackRequest`，`IEnumerator`以及其他的异步操作进行 await UniTask 提供了三种模式的扩展方法。 ```csharp await asyncOperation; .WithCancellation(CancellationToken); .ToUniTask(IProgress, PlayerLoopTiming, CancellationToken); ``` `WithCancellation`是`ToUniTask`的简化版本，两者都返回`UniTask`。有关 cancellation 的详细信息，请参阅：[取消和异常处理](https://github.com/Cysharp/UniTask#cancellation-and-exception-handling)部分。 > 注意：await 会在 PlayerLoop 执行await对象的相应native生命周期方法时返回（如果条件满足的话），而 WithCancellation 和 ToUniTask 是从指定的 PlayerLoop 生命周期执行时返回。有关 PlayLoop生命周期 的详细信息，请参阅：[PlayerLoop](https://github.com/Cysharp/UniTask#playerloop)部分。 > 注意： AssetBundleRequest 有`asset`和`allAssets`，默认 await 返回`asset`。如果您想得到`allAssets`，您可以使用`AwaitForAllAssets()`方法。 `UniTask`可以使用`UniTask.WhenAll`，`UniTask.WhenAny`，`UniTask.WhenEach`等实用函数。它们就像`Task.WhenAll`和`Task.WhenAny`，但它们返回的数据类型更好用。它们会返回值元组，因此您可以传递多种类型并解构每个结果。 ```csharp public async UniTaskVoid LoadManyAsync() { // 并行加载. var (a, b, c) = await UniTask.WhenAll( LoadAsSprite("foo"), LoadAsSprite("bar"), LoadAsSprite("baz")); } async UniTask LoadAsSprite(string path) { var resource = await Resources.LoadAsync(path); return (resource as Sprite); } ``` 如果您想要将一个回调转换为 UniTask，您可以使用`UniTaskCompletionSource`，它是`TaskCompletionSource`的轻量级版本。 ```csharp public UniTask WrapByUniTaskCompletionSource() { var utcs = new UniTaskCompletionSource(); // 当操作完成时，调用 utcs.TrySetResult(); // 当操作失败时，调用 utcs.TrySetException(); // 当操作取消时，调用 utcs.TrySetCanceled(); return utcs.Task; //本质上就是返回了一个 UniTask } ``` 您可以进行如下转换：
-`Task` -> `UniTask `：使用`AsUniTask`
-`UniTask` -> `UniTask`：使用 `AsAsyncUnitUniTask`
-`UniTask` -> `UniTask`：使用 `AsUniTask`。`UniTask` -> `UniTask`的转换是无消耗的。 如果您想将异步转换为协程，您可以使用`.ToCoroutine()`，这对于您想只允许使用协程系统大有帮助。 UniTask 不能 await 两次。这是与.NET Standard 2.1 中引入的[ValueTask/IValueTaskSource](https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.valuetask-1?view=netcore-3.1)具有相同的约束。 > 千万不要对 `ValueTask` 实例执行以下操作： > > - 多次await实例。 > - 多次调用 AsTask。 > - 在操作尚未完成时调用 .Result 或 .GetAwaiter().GetResult()，或对它们进行多次调用。 > - 对实例进行上述多种操作。 > > 如果您执行了上述任何操作，则结果是未定义的。 ```csharp var task = UniTask.DelayFrame(10); await task; await task; // 错误，抛出异常 ``` 如果实在需要多次 await 一个异步操作，可以使用支持多次调用的`UniTask.Lazy`。`.Preserve()`同样允许多次调用（由 UniTask 内部缓存结果）。这种方法在函数范围内有多次调用时很有用。 同样的，`UniTaskCompletionSource`可以在同一个地方被 await 多次，或者在很多不同的地方被 await。 取消和异常处理 --- 一些 UniTask 工厂方法中有一个`CancellationToken cancellationToken = default`参数。Unity 的一些异步操作也有`WithCancellation(CancellationToken)`和`ToUniTask(..., CancellationToken cancellation = default)`扩展方法。 可以通过原生的[`CancellationTokenSource`](https://docs.microsoft.com/en-us/dotnet/api/system.threading.cancellationtokensource)将 CancellationToken 传递给参数 ```csharp var cts = new CancellationTokenSource(); cancelButton.onClick.AddListener(() => { cts.Cancel(); }); await UnityWebRequest.Get("http://google.co.jp").SendWebRequest().WithCancellation(cts.Token); await UniTask.DelayFrame(1000, cancellationToken: cts.Token); ``` CancellationToken 可通过`CancellationTokenSource`或 MonoBehaviour 的扩展方法`GetCancellationTokenOnDestroy`来创建。 ```csharp // 这个 CancellationToken 的生命周期与 GameObject 的相同 await UniTask.DelayFrame(1000, cancellationToken: this.GetCancellationTokenOnDestroy()); ``` 对于链式取消，建议所有异步方法的最后一个参数都接受`CancellationToken cancellationToken`，并将`CancellationToken`从头传递到尾。 ```csharp await FooAsync(this.GetCancellationTokenOnDestroy()); // --- async UniTask FooAsync(CancellationToken cancellationToken) { await BarAsync(cancellationToken); } async UniTask BarAsync(CancellationToken cancellationToken) { await UniTask.Delay(TimeSpan.FromSeconds(3), cancellationToken); } ``` `CancellationToken`代表了异步操作的生命周期。您可以不使用默认的 CancellationTokenOnDestroy ，通过自定义的`CancellationToken`自行管理生命周期。 ```csharp public class MyBehaviour : MonoBehaviour { CancellationTokenSource disableCancellation = new CancellationTokenSource(); CancellationTokenSource destroyCancellation = new CancellationTokenSource(); private void OnEnable() { if (disableCancellation != null) { disableCancellation.Dispose(); } disableCancellation = new CancellationTokenSource(); } private void OnDisable() { disableCancellation.Cancel(); } private void OnDestroy() { destroyCancellation.Cancel(); destroyCancellation.Dispose(); } } ``` 在Unity 2022.2之后，Unity在[MonoBehaviour.destroyCancellationToken](https://docs.unity3d.com/ScriptReference/MonoBehaviour-destroyCancellationToken.html)和[Application.exitCancellationToken](https://docs.unity3d.com/ScriptReference/Application-exitCancellationToken.html)中添加了 CancellationToken。 当检测到取消时，所有方法都会向上游抛出并传播`OperationCanceledException`。当异常（不限于`OperationCanceledException`）没有在异步方法中处理时，它将被传播到`UniTaskScheduler.UnobservedTaskException`。默认情况下，将接收到的未处理异常作为一般异常写入日志。可以使用`UniTaskScheduler.UnobservedExceptionWriteLogType`更改日志级别。若想对接收到未处理异常时的处理进行自定义，请为`UniTaskScheduler.UnobservedTaskException`设置一个委托 而`OperationCanceledException`是一种特殊的异常，会被`UnobservedTaskException`无视 如果要取消异步 UniTask 方法中的行为，请手动抛出`OperationCanceledException`。 ```csharp public async UniTask FooAsync() { await UniTask.Yield(); throw new OperationCanceledException(); } ``` 如果您只想处理异常，忽略取消操作（让其传播到全局处理 cancellation 的地方），请使用异常过滤器。 ```csharp public async UniTask BarAsync() { try { var x = await FooAsync(); return x * 2; } catch (Exception ex) when (!(ex is OperationCanceledException)) // 在 C# 9.0 下改成 when (ex is not OperationCanceledException) { return -1; } } ``` 抛出和捕获`OperationCanceledException`有点重度，如果比较在意性能开销，请使用`UniTask.SuppressCancellationThrow`以避免抛出 OperationCanceledException 。它将返回`(bool IsCanceled, T Result)`而不是抛出异常。 ```csharp var (isCanceled, _) = await UniTask.DelayFrame(10, cancellationToken: cts.Token).SuppressCancellationThrow(); if (isCanceled) { // ... } ``` 注意：仅当您在源头处直接调用`UniTask.SuppressCancellationThrow`时才会抑制异常抛出。否则，返回值将被转换，且整个管道不会抑制异常抛出。 `UniTask.Yield`和`UniTask.Delay`等功能依赖于 Unity 的 PlayerLoop，它们在 PlayerLoop 中确定`CancellationToken`状态。 这意味着当`CancellationToken`被触发时，它们并不会立即取消。 如果要更改此行为，实现立即取消，可将`cancelImmediately`标志设置为 true。 ```csharp await UniTask.Yield(cancellationToken, cancelImmediately: true); ``` 注意：比起默认行为，设置 `cancelImmediately` 为 true 并检测立即取消会有更多的性能开销。 这是因为它使用了`CancellationToken.Register`；这比在 PlayerLoop 中检查 CancellationToken 更重度。 超时处理 --- 超时是取消的一种变体。您可以通过`CancellationTokenSouce.CancelAfterSlim(TimeSpan)`设置超时并将 CancellationToken 传递给异步方法。 ```csharp var cts = new CancellationTokenSource(); cts.CancelAfterSlim(TimeSpan.FromSeconds(5)); // 设置5s超时。 try { await UnityWebRequest.Get("http://foo").SendWebRequest().WithCancellation(cts.Token); } catch (OperationCanceledException ex) { if (ex.CancellationToken == cts.Token) { UnityEngine.Debug.Log("Timeout"); } } ``` > `CancellationTokenSouce.CancelAfter`是一个原生的 api。但是在 Unity 中您不应该使用它，因为它依赖于线程计时器。`CancelAfterSlim`是 UniTask 的扩展方法，它使用 PlayerLoop 代替了线程计时器。 如果您想将超时与其他 cancellation 一起使用，请使用`CancellationTokenSource.CreateLinkedTokenSource`。 ```csharp var cancelToken = new CancellationTokenSource(); cancelButton.onClick.AddListener(()=> { cancelToken.Cancel(); // 点击按钮后取消。 }); var timeoutToken = new CancellationTokenSource(); timeoutToken.CancelAfterSlim(TimeSpan.FromSeconds(5)); // 设置5s超时。 try { // 链接 token var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancelToken.Token, timeoutToken.Token); await UnityWebRequest.Get("http://foo").SendWebRequest().WithCancellation(linkedTokenSource.Token); } catch (OperationCanceledException ex) { if (timeoutToken.IsCancellationRequested) { UnityEngine.Debug.Log("Timeout."); } else if (cancelToken.IsCancellationRequested) { UnityEngine.Debug.Log("Cancel clicked."); } } ``` 为减少每次调用异步方法时用于超时的 CancellationTokenSource 的堆内存分配，您可以使用 UniTask 的`TimeoutController`进行优化。 ```csharp TimeoutController timeoutController = new TimeoutController(); // 提前创建好，以便复用。 async UniTask FooAsync() { try { // 您可以通过 timeoutController.Timeout(TimeSpan) 把超时设置传递到 cancellationToken。 await UnityWebRequest.Get("http://foo").SendWebRequest() .WithCancellation(timeoutController.Timeout(TimeSpan.FromSeconds(5))); timeoutController.Reset(); // 当 await 完成后调用 Reset（停止超时计时器，并准备下一次复用）。 } catch (OperationCanceledException ex) { if (timeoutController.IsTimeout()) { UnityEngine.Debug.Log("timeout"); } } } ``` 如果您想将超时结合其他取消源一起使用，请使用`new TimeoutController(CancellationToken)`. ```csharp TimeoutController timeoutController; CancellationTokenSource clickCancelSource; void Start() { this.clickCancelSource = new CancellationTokenSource(); this.timeoutController = new TimeoutController(clickCancelSource); } ``` 注意：UniTask 有`.Timeout`，`.TimeoutWithoutException`方法，但如果可以的话，尽量不要使用这些方法，请传递`CancellationToken`。因为`.Timeout`是在任务外部执行，所以无法停止超时任务。`.Timeout`意味着超时后忽略结果。如果您将一个`CancellationToken`传递给该方法，它将从任务内部执行，因此可以停止正在运行的任务。 进度 --- 一些 Unity 的异步操作具有`ToUniTask(IProgress progress = null, ...)`的扩展方法。 ```csharp var progress = Progress.Create(x => Debug.Log(x)); var request = await UnityWebRequest.Get("http://google.co.jp") .SendWebRequest() .ToUniTask(progress: progress); ``` 您不应该使用原生的`new System.Progress`，因为每次调用它都会产生堆内存分配。请改用`Cysharp.Threading.Tasks.Progress`。这个 progress 工厂类有两个方法，`Create`和`CreateOnlyValueChanged`。`CreateOnlyValueChanged`仅在进度值更新时调用。 为调用者实现 IProgress 接口会更好，这样不会因使用 lambda 而产生堆内存分配。 ```csharp public class Foo : MonoBehaviour, IProgress { public void Report(float value) { UnityEngine.Debug.Log(value); } public async UniTaskVoid WebRequest() { var request = await UnityWebRequest.Get("http://google.co.jp") .SendWebRequest() .ToUniTask(progress: this); } } ``` PlayerLoop --- UniTask 运行在自定义的[PlayerLoop](https://docs.unity3d.com/ScriptReference/LowLevel.PlayerLoop.html)中。UniTask 中基于 PlayerLoop 的方法（如`Delay`、`DelayFrame`、`asyncOperation.ToUniTask`等）接受这个`PlayerLoopTiming`。 ```csharp public enum PlayerLoopTiming { Initialization = 0, LastInitialization = 1, EarlyUpdate = 2, LastEarlyUpdate = 3, FixedUpdate = 4, LastFixedUpdate = 5, PreUpdate = 6, LastPreUpdate = 7, Update = 8, LastUpdate = 9, PreLateUpdate = 10, LastPreLateUpdate = 11, PostLateUpdate = 12, LastPostLateUpdate = 13 #if UNITY_2020_2_OR_NEWER TimeUpdate = 14, LastTimeUpdate = 15, #endif } ``` 它表明了异步任务会在哪个时机运行，您可以查阅[PlayerLoopList.md](https://gist.github.com/neuecc/bc3a1cfd4d74501ad057e49efcd7bdae)以了解 Unity 的默认 PlayerLoop 以及注入的 UniTask 的自定义循环。 `PlayerLoopTiming.Update`与协程中的`yield return null`类似，但它会在`ScriptRunBehaviourUpdate`时，Update（Update 和 uGUI 事件(button.onClick等）之前被调用，而 yield return null 是在`ScriptRunDelayedDynamicFrameRate`时被调用。`PlayerLoopTiming.FixedUpdate`类似于`WaitForFixedUpdate`。 > `PlayerLoopTiming.LastPostLateUpdate`不等同于协程的`yield return new WaitForEndOfFrame()`。协程的 WaitForEndOfFrame 似乎在 PlayerLoop 完成后运行。一些需要协程结束帧的方法(`Texture2D.ReadPixels`，`ScreenCapture.CaptureScreenshotAsTexture`，`CommandBuffer`等)在 async/await 时无法正常工作。在这些情况下，请将 MonoBehaviour（用于运行协程）传递给`UniTask.WaitForEndOfFrame`。例如，`await UniTask.WaitForEndOfFrame(this);`是`yield return new WaitForEndOfFrame()`轻量级无堆内存分配的替代方案。 > 注意：在 Unity 2023.1或更高的版本中，`await UniTask.WaitForEndOfFrame();`不再需要 MonoBehaviour。因为它使用了`UnityEngine.Awaitable.EndOfFrameAsync`。 `yield return null`和`UniTask.Yield`相似但不同。`yield return null`总是返回下一帧但`UniTask.Yield`返回下一次调用。也就是说，`UniTask.Yield(PlayerLoopTiming.Update)`在 `PreUpdate`上调用，它返回同一帧。`UniTask.NextFrame()`保证返回下一帧，您可以认为它的行为与`yield return null`一致。 > UniTask.Yield（不带 CancellationToken）是一种特殊类型，返回`YieldAwaitable`并在 YieldRunner 上运行。它是最轻量和最快的。 `AsyncOperation`在原生生命周期返回。例如，await `SceneManager.LoadSceneAsync`在`EarlyUpdate.UpdatePreloading`时返回，在此之后，在`EarlyUpdate.ScriptRunDelayedStartupFrame`时调用已加载场景的`Start`方法。同样的，`await UnityWebRequest`在`EarlyUpdate.ExecuteMainThreadJobs`时返回。 在 UniTask 中，直接 await 使用的是原生生命周期，而`WithCancellation`和`ToUniTask`使用的特定的生命周期。这通常不会有问题，但对于`LoadSceneAsync`，它会导致`Start`方法与 await 之后的逻辑的执行顺序错乱。所以建议不要使用`LoadSceneAsync.ToUniTask`。 > 注意：在 Unity 2023.1或更高的版本中，当您使用新的`UnityEngine.Awaitable`方法（如`SceneManager.LoadSceneAsync`）时，请确保您的文件的 using 指令区域中包含`using UnityEngine;`。 > 这可以通过避免使用`UnityEngine.AsyncOperation`版本来防止编译错误。 在堆栈跟踪中，您可以检查它在 PlayerLoop 中的运行位置。 ![image](https://user-images.githubusercontent.com/46207/83735571-83caea80-a68b-11ea-8d22-5e22864f0d24.png) 默认情况下，UniTask 的 PlayerLoop 在`[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]`初始化。 在 BeforeSceneLoad 中调用的方法，它们的执行顺序是不确定的，所以如果您想在其他 BeforeSceneLoad 方法中使用 UniTask，您应该尝试在此之前初始化好 PlayerLoop。 ```csharp // AfterAssembliesLoaded 表示将会在 BeforeSceneLoad 之前调用 [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)] public static void InitUniTaskLoop() { var loop = PlayerLoop.GetCurrentPlayerLoop(); Cysharp.Threading.Tasks.PlayerLoopHelper.Initialize(ref loop); } ``` 如果您导入了 Unity 的`Entities`包，则会在`BeforeSceneLoad`将自定义 PlayerLoop 重置为默认值，并注入 ECS 的循环。当 Unity 在 UniTask 的初始化方法执行之后调用了 ECS 的注入方法，UniTask 将不再起作用。 为了解决这个问题，您可以在 ECS 初始化后重新初始化 UniTask PlayerLoop。 ```csharp // 获取 ECS Loop。 var playerLoop = ScriptBehaviourUpdateOrder.CurrentPlayerLoop; // 设置 UniTask PlayerLoop。 PlayerLoopHelper.Initialize(ref playerLoop); ``` 您可以通过调用`PlayerLoopHelper.IsInjectedUniTaskPlayerLoop()`来诊断 UniTask 的 PlayerLoop 是否准备就绪。并且`PlayerLoopHelper.DumpCurrentPlayerLoop`还会将所有当前 PlayerLoop 记录到控制台。 ```csharp void Start() { UnityEngine.Debug.Log("UniTaskPlayerLoop ready? " + PlayerLoopHelper.IsInjectedUniTaskPlayerLoop()); PlayerLoopHelper.DumpCurrentPlayerLoop(); } ``` 您可以通过移除未使用的 PlayerLoopTiming 注入来稍微优化循环成本。您可以在初始化时调用`PlayerLoopHelper.Initialize(InjectPlayerLoopTimings)`。 ```csharp var loop = PlayerLoop.GetCurrentPlayerLoop(); PlayerLoopHelper.Initialize(ref loop, InjectPlayerLoopTimings.Minimum); // Minimum 就是 Update | FixedUpdate | LastPostLateUpdate ``` `InjectPlayerLoopTimings`有三个预设，`All`，`Standard`（All 除 LastPostLateUpdate 外），`Minimum`（`Update | FixedUpdate | LastPostLateUpdate`）。默认为 All，您可以通过组合来自定义要注入的时机，例如`InjectPlayerLoopTimings.Update | InjectPlayerLoopTimings.FixedUpdate | InjectPlayerLoopTimings.PreLateUpdate`。 使用未注入`PlayerLoopTiming`的[Microsoft.CodeAnalysis.BannedApiAnalyzers](https://github.com/dotnet/roslyn-analyzers/blob/master/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/BannedApiAnalyzers.Help.md)可能会出错。例如，您可以像下列方式那样，为`InjectPlayerLoopTimings.Minimum`设置`BannedSymbols.txt` ```txt F:Cysharp.Threading.Tasks.PlayerLoopTiming.Initialization; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastInitialization; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.EarlyUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastEarlyUpdate; Isn't injected this PlayerLoop in this project.d F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastFixedUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.PreUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastPreUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.PreLateUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastPreLateUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.PostLateUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.TimeUpdate; Isn't injected this PlayerLoop in this project. F:Cysharp.Threading.Tasks.PlayerLoopTiming.LastTimeUpdate; Isn't injected this PlayerLoop in this project. ``` 您可以将`RS0030`的严重性配置为错误。 ![image](https://user-images.githubusercontent.com/46207/109150837-bb933880-77ac-11eb-85ba-4fd15819dbd0.png) async void 与 async UniTaskVoid 对比 --- `async void`是一个原生的 C# 任务系统，因此它不在 UniTask 系统上运行。也最好不要使用它。`async UniTaskVoid`是`async UniTask`的轻量级版本，因为它没有等待完成并立即向`UniTaskScheduler.UnobservedTaskException`报告错误。如果您不需要等待（即发即弃），那么使用`UniTaskVoid`会更好。不幸的是，要解除警告，您需要在尾部添加`Forget()`。 ```csharp public async UniTaskVoid FireAndForgetMethod() { // do anything... await UniTask.Yield(); } public void Caller() { FireAndForgetMethod().Forget(); } ``` UniTask 也有`Forget`方法，与`UniTaskVoid`类似且效果相同。如果您完全不需要使用`await`，那么使用`UniTaskVoid`会更高效。 ```csharp public async UniTask DoAsync() { // do anything... await UniTask.Yield(); } public void Caller() { DoAsync().Forget(); } ``` 要使用注册到事件的异步 lambda，请不要使用`async void`。您可以使用`UniTask.Action` 或 `UniTask.UnityAction`来代替，这两者都通过`async UniTaskVoid` lambda 来创建委托。 ```csharp Action actEvent; UnityAction unityEvent; // UGUI 特供 // 这样是不好的: async void actEvent += async () => { }; unityEvent += async () => { }; // 这样是可以的: 通过 lamada 创建 Action actEvent += UniTask.Action(async () => { await UniTask.Yield(); }); unityEvent += UniTask.UnityAction(async () => { await UniTask.Yield(); }); ``` `UniTaskVoid`也可以用在 MonoBehaviour 的`Start`方法中。 ```csharp class Sample : MonoBehaviour { async UniTaskVoid Start() { // 异步初始化代码。 } } ``` UniTaskTracker --- 对于检查（泄露的）UniTasks 很有用。您可以在`Window -> UniTask Tracker`中打开跟踪器窗口。 ![image](https://user-images.githubusercontent.com/46207/83527073-4434bf00-a522-11ea-86e9-3b3975b26266.png) - Enable AutoReload(Toggle) - 自动重新加载。 - Reload - 重新加载视图（重新扫描内存中UniTask实例，并刷新界面）。 - GC.Collect - 调用 GC.Collect。 - Enable Tracking(Toggle) - 开始跟踪异步/等待 UniTask。性能影响：低。 - Enable StackTrace(Toggle) - 在任务启动时捕获 StackTrace。性能影响：高。 UniTaskTracker 仅用于调试用途，因为启用跟踪和捕获堆栈跟踪很有用，但会对性能产生重大影响。推荐的用法是只在查找任务泄漏时启用跟踪和堆栈跟踪，并在使用完毕后禁用它们。 外部拓展 --- 默认情况下，UniTask 支持 TextMeshPro（`BindTo(TMP_Text)`和像原生 uGUI `InputField` 那样的事件扩展，如`TMP_InputField`）、DOTween（`Tween`作为可等待的）和 Addressables（`AsyncOperationHandle`和`AsyncOperationHandle`作为可等待的）。 它们被定义在了如`UniTask.TextMeshPro`，`UniTask.DOTween`，`UniTask.Addressables`等单独的 asmdef文件中。 从包管理器中导入软件包时，会自动启用对 TextMeshPro 和 Addressables 的支持。 但对于 DOTween 的支持，则需要从[DOTWeen assets](https://assetstore.unity.com/packages/tools/animation/dotween-hotween-v2-27676r)中导入并定义脚本定义符号`UNITASK_DOTWEEN_SUPPORT`后才能启用。 ```csharp // 动画序列 await transform.DOMoveX(2, 10); await transform.DOMoveZ(5, 20); // 并行，并传递 cancellation 用于取消 var ct = this.GetCancellationTokenOnDestroy(); await UniTask.WhenAll( transform.DOMoveX(10, 3).WithCancellation(ct), transform.DOScale(10, 3).WithCancellation(ct)); ``` DOTween 支持的默认行为（`await`，`WithCancellation`，`ToUniTask`） 会等待到 tween 被终止。它适用于 Complete(true/false) 和 Kill(true/false)。但是如果您想复用 tweens（`SetAutoKill(false)`），它就不能按预期工作。如果您想等待另一个时间点，Tween 中存在以下扩展方法，`AwaitForComplete`，`AwaitForPause`，`AwaitForPlay`，`AwaitForRewind`，`AwaitForStepComplete`。 AsyncEnumerable 和 Async LINQ --- Unity 2020.2 支持 C# 8.0，因此您可以使用`await foreach`。这是异步时代的新更新符号。 ```csharp // Unity 2020.2，C# 8.0 await foreach (var _ in UniTaskAsyncEnumerable.EveryUpdate().WithCancellation(token)) { Debug.Log("Update() " + Time.frameCount); } ``` 在 C# 7.3 环境中，您可以使用`ForEachAsync`方法以几乎相同的方式工作。 ```csharp // C# 7.3(Unity 2018.3~) await UniTaskAsyncEnumerable.EveryUpdate().ForEachAsync(_ => { Debug.Log("Update() " + Time.frameCount); }, token); ``` `UniTask.WhenEach`类似于 .NET 9 的`Task.WhenEach`，它可以使用新的方式来等待多个任务。 ```csharp await foreach (var result in UniTask.WhenEach(task1, task2, task3)) { // 结果的类型为 WhenEachResult。 // 它包含 `T Result` or `Exception Exception`。 // 您可以检查 `IsCompletedSuccessfully` 或 `IsFaulted` 以确定是访 `.Result` 还是 `.Exception`。 // 如果希望在 `IsFaulted` 时抛出异常并在成功时获取结果，可以使用 `GetResult()`。 Debug.Log(result.GetResult()); } ``` UniTaskAsyncEnumerable 实现了异步 LINQ，类似于 LINQ 的`IEnumerable`或 Rx 的 `IObservable`。所有标准 LINQ 查询运算符都可以应用于异步流。例如，以下代码展示了如何将 Where 过滤器应用于每两次单击运行一次的按钮点击异步流。 ```csharp await okButton.OnClickAsAsyncEnumerable().Where((x, i) => i % 2 == 0).ForEachAsync(_ => { }); ``` 即发即弃（Fire and Forget）风格（例如，事件处理），您也可以使用`Subscribe`。 ```csharp okButton.OnClickAsAsyncEnumerable().Where((x, i) => i % 2 == 0).Subscribe(_ => { }); ``` 在引入`using Cysharp.Threading.Tasks.Linq;`后，异步 LINQ 将被启用，并且`UniTaskAsyncEnumerable`在 asmdef 文件`UniTask.Linq`中定义。 它更接近 UniRx（Reactive Extensions），但 UniTaskAsyncEnumerable 是基于 pull 的异步流，而 Rx 是基于 push 的异步流。请注意，尽管它们相似，但特性不同，细节也有所不同。 `UniTaskAsyncEnumerable`是类似`Enumerable`的入口点。除了标准查询操作符之外，还为 Unity 提供了其他生成器，例如`EveryUpdate`、`Timer`、`TimerFrame`、`Interval`、`IntervalFrame`和`EveryValueChanged`。此外，还添加了 UniTask 原生的查询操作符，如`Append`，`Prepend`，`DistinctUntilChanged`，`ToHashSet`，`Buffer`，`CombineLatest`，`Do`，`Never`，`ForEachAsync`，`Pairwise`，`Publish`，`Queue`，`Return`，`SkipUntil`，`TakeUntil`，`SkipUntilCanceled`，`TakeUntilCanceled`，`TakeLast`，`Subscribe`。 以 Func 作为参数的方法具有三个额外的重载，另外两个是`***Await`和`***AwaitWithCancellation`。 ```csharp Select(Func selector) SelectAwait(Func> selector) SelectAwaitWithCancellation(Func> selector) ``` 如果在 func 内部使用`async`方法，请使用`***Await`或`***AwaitWithCancellation`。 如何创建异步迭代器：C# 8.0 支持异步迭代器（`async yield return`），但它只允许`IAsyncEnumerable`，当然也需要 C# 8.0。UniTask 支持使用`UniTaskAsyncEnumerable.Create`方法来创建自定义异步迭代器。 ```csharp // IAsyncEnumerable，C# 8.0 异步迭代器。（请不要这样使用，因为 IAsyncEnumerable 不被 UniTask 所控制）。 public async IAsyncEnumerable MyEveryUpdate([EnumeratorCancellation]CancellationToken cancelationToken = default) { var frameCount = 0; await UniTask.Yield(); while (!token.IsCancellationRequested) { yield return frameCount++; await UniTask.Yield(); } } // UniTaskAsyncEnumerable.Create 并用 `await writer.YieldAsync` 代替 `yield return`. public IUniTaskAsyncEnumerable MyEveryUpdate() { // writer(IAsyncWriter) 有 `YieldAsync(value)` 方法。 return UniTaskAsyncEnumerable.Create(async (writer, token) => { var frameCount = 0; await UniTask.Yield(); while (!token.IsCancellationRequested) { await writer.YieldAsync(frameCount++); // 代替 `yield return` await UniTask.Yield(); } }); } ``` 可等待事件 --- 所有 uGUI 组件都实现了`***AsAsyncEnumerable`，以实现对事件的异步流的转换。 ```csharp async UniTask TripleClick() { // 默认情况下，使用了button.GetCancellationTokenOnDestroy 来管理异步生命周期 await button.OnClickAsync(); await button.OnClickAsync(); await button.OnClickAsync(); Debug.Log("Three times clicked"); } // 更高效的方法 async UniTask TripleClick() { using (var handler = button.GetAsyncClickEventHandler()) { await handler.OnClickAsync(); await handler.OnClickAsync(); await handler.OnClickAsync(); Debug.Log("Three times clicked"); } } // 使用异步 LINQ async UniTask TripleClick(CancellationToken token) { await button.OnClickAsAsyncEnumerable().Take(3).Last(); Debug.Log("Three times clicked"); } // 使用异步 LINQ async UniTask TripleClick(CancellationToken token) { await button.OnClickAsAsyncEnumerable().Take(3).ForEachAsync(_ => { Debug.Log("Every clicked"); }); Debug.Log("Three times clicked, complete."); } ``` 所有 MonoBehaviour 消息事件均可通过`AsyncTriggers`转换成异步流，`AsyncTriggers`可通过引入`using Cysharp.Threading.Tasks.Triggers;`来启用。`AsyncTriggers`可以使用`GetAsync***Trigger`来创建，并将它作为 UniTaskAsyncEnumerable 来触发。 ```csharp var trigger = this.GetOnCollisionEnterAsyncHandler(); await trigger.OnCollisionEnterAsync(); await trigger.OnCollisionEnterAsync(); await trigger.OnCollisionEnterAsync(); // 每次移动触发。 await this.GetAsyncMoveTrigger().ForEachAsync(axisEventData => { }); ``` `AsyncReactiveProperty`，`AsyncReadOnlyReactiveProperty`是 UniTask 的 ReactiveProperty 版本。`BindTo`的`IUniTaskAsyncEnumerable`扩展方法，可以把异步流值绑定到 Unity 组件（Text/Selectable/TMP/Text）。 ```csharp var rp = new AsyncReactiveProperty(99); // AsyncReactiveProperty 本身是 IUniTaskAsyncEnumerable，可以通过 LINQ 进行查询 rp.ForEachAsync(x => { Debug.Log(x); }, this.GetCancellationTokenOnDestroy()).Forget(); rp.Value = 10; // 推送10给所有订阅者 rp.Value = 11; // 推送11给所有订阅者 // WithoutCurrent 忽略初始值 // BindTo 绑定 stream value 到 unity 组件. rp.WithoutCurrent().BindTo(this.textComponent); await rp.WaitAsync(); // 一直等待，直到下一个值被设置 // 同样支持 ToReadOnlyAsyncReactiveProperty var rp2 = new AsyncReactiveProperty(99); var rorp = rp.CombineLatest(rp2, (x, y) => (x, y)).ToReadOnlyAsyncReactiveProperty(CancellationToken.None); ``` 在序列中的异步处理完成之前，pull-based异步流不会获取下一个值。这可能会从按钮等推送类型的事件中溢出数据。 ```csharp // 在3s延迟结束前，无法获取 event await button.OnClickAsAsyncEnumerable().ForEachAwaitAsync(async x => { await UniTask.Delay(TimeSpan.FromSeconds(3)); }); ``` 它（在防止双击方面）是有用的，但有时也并非都有用。 使用`Queue()`方法在异步处理期间也会对事件进行排队。 ```csharp // 异步处理中对 message 进行排队 await button.OnClickAsAsyncEnumerable().Queue().ForEachAwaitAsync(async x => { await UniTask.Delay(TimeSpan.FromSeconds(3)); }); ``` 或使用即发即弃风格的`Subscribe`。 ```csharp button.OnClickAsAsyncEnumerable().Subscribe(async x => { await UniTask.Delay(TimeSpan.FromSeconds(3)); }); ``` Channel --- `Channel`与[System.Threading.Tasks.Channels](https://docs.microsoft.com/en-us/dotnet/api/system.threading.channels?view=netcore-3.1)相同，类似于 GoLang Channel。 目前只支持多生产者、单消费者无界 Channel。它可以通过`Channel.CreateSingleConsumerUnbounded()`来创建。 对于生产者(`.Writer`)，使用`TryWrite`来推送值，使用`TryComplete`来完成 Channel。对于消费者(`.Reader`)，使用`TryRead`、`WaitToReadAsync`、`ReadAsync`和`Completion`，`ReadAllAsync`来读取队列的消息。 `ReadAllAsync`返回`IUniTaskAsyncEnumerable` 因此可以使用 LINQ 操作符。Reader 只允许单消费者，但可以使用`.Publish()`查询操作符来启用多播消息。例如，可以制作发布/订阅工具。 ```csharp public class AsyncMessageBroker : IDisposable { Channel channel; IConnectableUniTaskAsyncEnumerable multicastSource; IDisposable connection; public AsyncMessageBroker() { channel = Channel.CreateSingleConsumerUnbounded(); multicastSource = channel.Reader.ReadAllAsync().Publish(); connection = multicastSource.Connect(); // Publish returns IConnectableUniTaskAsyncEnumerable. } public void Publish(T value) { channel.Writer.TryWrite(value); } public IUniTaskAsyncEnumerable Subscribe() { return multicastSource; } public void Dispose() { channel.Writer.TryComplete(); connection.Dispose(); } } ``` 与 Awaitable 对比 --- Unity 6 引入了可等待类型[Awaitable](https://docs.unity3d.com/6000.0/Documentation/ScriptReference/Awaitable.html)。简而言之，Awaitable 可以被认为是 UniTask 的一个子集，并且事实上，Awaitable的设计也受 UniTask 的影响。它应该能够处理基于 PlayerLoop 的 await，池化 Task，以及支持以类似的方式使用`CancellationToken`进行取消。随着它被包含在标准库中，您可能想知道是继续使用 UniTask 还是迁移到 Awaitable。以下是简要指南。 首先，Awaitable 提供的功能与协程提供的功能相同。使用 await 代替`yield return`；`await NextFrameAsync()`代替`yield return null`；`WaitForSeconds`和`EndOfFrame`等价。然而，这只是两者之间的差异。就功能而言，它是基于协程的，缺乏基于 Task 的特性。在使用 async/await 的实际应用程序开发中，像`WhenAll`这样的操作是必不可少的。此外，UniTask 支持许多基于帧的操作（如`DelayFrame`）和更灵活的 PlayerLoopTiming 控制，这些在 Awaitable 中是不可用的。当然，它也没有跟踪器窗口。 因此，我推荐在应用程序开发中使用 UniTask。UniTask 是 Awaitable 的超集，并包含了许多基本特性。对于库开发，如果您希望避免外部依赖，可以使用 Awaitable 作为方法的返回类型。因为 Awaitable 可以使用`AsUniTask`转换为 UniTask，所以支持在 UniTask 库中处理基于 Awaitable 的功能。即便是在库开发中，如果您不需要担心依赖关系，使用 UniTask 也会是您的最佳选择。 单元测试 --- Unity 的`[UnityTest]`属性可以测试协程（IEnumerator）但不能测试异步。`UniTask.ToCoroutine`将 async/await 桥接到协程，以便您可以测试异步方法。 ```csharp [UnityTest] public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () => { var time = Time.realtimeSinceStartup; Time.timeScale = 0.5f; try { await UniTask.Delay(TimeSpan.FromSeconds(3), ignoreTimeScale: true); var elapsed = Time.realtimeSinceStartup - time; Assert.AreEqual(3, (int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)); } finally { Time.timeScale = 1.0f; } }); ``` UniTask 自身的单元测试是使用 Unity Test Runner 和[Cysharp/RuntimeUnitTestToolkit](https://github.com/Cysharp/RuntimeUnitTestToolkit)编写的，以集成到 CI 中并检查 IL2CPP 是否正常工作。 ## 线程池的限制 大多数 UniTask 方法在单个线程 (PlayerLoop) 上运行，只有`UniTask.Run`（等同于`Task.Run`）和`UniTask.SwitchToThreadPool`在线程池上运行。如果您使用线程池，它将无法与 WebGL 等平台兼容。 `UniTask.Run`现在已弃用。您可以改用`UniTask.RunOnThreadPool`。并且还要考虑是否可以使用`UniTask.Create`或`UniTask.Void`。 ## IEnumerator.ToUniTask 的限制 您可以将协程（IEnumerator）转换为 UniTask（或直接 await），但它有一些限制。 - 不支持`WaitForEndOfFrame`，`WaitForFixedUpdate`，`Coroutine` - 生命周期与`StartCoroutine`不一样，它使用指定的`PlayerLoopTiming`，并且默认情况下，`PlayerLoopTiming.Update`在 MonoBehaviour 的`Update`和`StartCoroutine`的循环之前执行。 如果您想要实现从协程到异步的完全兼容转换，请使用`IEnumerator.ToUniTask(MonoBehaviour coroutineRunner)`重载。它会在传入的 MonoBehaviour 实例中执行 StartCoroutine 并在 UniTask 中等待它完成。 ## 关于 UnityEditor UniTask 可以像编辑器协程一样在 Unity 编辑器上运行。但它有一些限制。 - UniTask.Delay 的 DelayType.DeltaTime、UnscaledDeltaTime 无法正常工作，因为它们无法在编辑器中获取 deltaTime。因此在 EditMode 下运行时，会自动将 DelayType 更改为能等待正确的时间的`DelayType.Realtime`。 - 所有 PlayerLoopTiming 都在`EditorApplication.update`生命周期上运行。 - 带`-quit`的`-batchmode`不起作用，因为 Unity 不会执行 `EditorApplication.update` 并在一帧后退出。因此，不要使用`-quit`并使用`EditorApplication.Exit(0)`手动退出。 与原生 Task API 对比 --- UniTask 有许多原生的类Task API。此表展示了两者相对应的 API。 使用原生类型。 | .NET 类型 | UniTask 类型 | |---------------------------| --- | | `IProgress` | --- | | `CancellationToken` | --- | | `CancellationTokenSource` | --- | 使用 UniTask 类型。 | .NET 类型 | UniTask 类型 | | --- | --- | | `Task`/`ValueTask` | `UniTask` | | `Task`/`ValueTask` | `UniTask` | | `async void` | `async UniTaskVoid` | | `+= async () => { }` | `UniTask.Void`, `UniTask.Action`, `UniTask.UnityAction` | | --- | `UniTaskCompletionSource` | | `TaskCompletionSource` | `UniTaskCompletionSource`/`AutoResetUniTaskCompletionSource` | | `ManualResetValueTaskSourceCore` | `UniTaskCompletionSourceCore` | | `IValueTaskSource` | `IUniTaskSource` | | `IValueTaskSource` | `IUniTaskSource` | | `ValueTask.IsCompleted` | `UniTask.Status.IsCompleted()` | | `ValueTask.IsCompleted` | `UniTask.Status.IsCompleted()` | | `new Progress` | `Progress.Create` | | `CancellationToken.Register(UnsafeRegister)` | `CancellationToken.RegisterWithoutCaptureExecutionContext` | | `CancellationTokenSource.CancelAfter` | `CancellationTokenSource.CancelAfterSlim` | | `Channel.CreateUnbounded(false){ SingleReader = true }` | `Channel.CreateSingleConsumerUnbounded` | | `IAsyncEnumerable` | `IUniTaskAsyncEnumerable` | | `IAsyncEnumerator` | `IUniTaskAsyncEnumerator` | | `IAsyncDisposable` | `IUniTaskAsyncDisposable` | | `Task.Delay` | `UniTask.Delay` | | `Task.Yield` | `UniTask.Yield` | | `Task.Run` | `UniTask.RunOnThreadPool` | | `Task.WhenAll` | `UniTask.WhenAll` | | `Task.WhenAny` | `UniTask.WhenAny` | | `Task.WhenEach` | `UniTask.WhenEach` | | `Task.CompletedTask` | `UniTask.CompletedTask` | | `Task.FromException` | `UniTask.FromException` | | `Task.FromResult` | `UniTask.FromResult` | | `Task.FromCanceled` | `UniTask.FromCanceled` | | `Task.ContinueWith` | `UniTask.ContinueWith` | | `TaskScheduler.UnobservedTaskException` | `UniTaskScheduler.UnobservedTaskException` | 池化配置 --- UniTask 通过积极缓存异步 promise 对象实现零堆内存分配（有关技术细节，请参阅博客文章[UniTask v2 — 适用于 Unity 的零堆内存分配的async/await，支持异步 LINQ](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd)）。默认情况下，它缓存所有 promise，但您可以通过调用`TaskPool.SetMaxPoolSize`方法来自定义每种类型的最大缓存大小。`TaskPool.GetCacheSizeInfo`返回池中当前缓存的对象。 ```csharp foreach (var (type, size) in TaskPool.GetCacheSizeInfo()) { Debug.Log(type + ":" + size); } ``` Profiler 下的堆内存分配 --- 在 UnityEditor 中，能从 profiler 中看到编译器生成的 AsyncStateMachine 的堆内存分配，但它只出现在Debug（development）构建中。C# 编译器在Debug 构建时将 AsyncStateMachine 生成为类，而在Release 构建时将其生成为结构。 Unity 从2020.1版本开始支持代码优化选项（位于右下角）。 ![](https://user-images.githubusercontent.com/46207/89967342-2f944600-dc8c-11ea-99fc-0b74527a16f6.png) 在开发构建中，您可以通过将 C# 编译器优化设置为 release 模式来移除 AsyncStateMachine 的堆内存分配。此优化选项也可以通过`Compilation.CompilationPipeline-codeOptimization`和`Compilation.CodeOptimization`来设置。 UniTaskSynchronizationContext --- Unity 的默认 SynchronizationContext(`UnitySynchronizationContext`) 在性能方面表现不佳。UniTask 绕过`SynchronizationContext`(和`ExecutionContext`) 因此 UniTask 不使用它，但如果存在`async Task`，则仍然使用它。`UniTaskSynchronizationContext`是`UnitySynchronizationContext`性能更好的替代品。 ```csharp public class SyncContextInjecter { [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] public static void Inject() { SynchronizationContext.SetSynchronizationContext(new UniTaskSynchronizationContext()); } } ``` 这是一个可选的选择，并不总是推荐；`UniTaskSynchronizationContext`性能不如`async UniTask`，并且不是完整的 UniTask 替代品。它也不保证与`UnitySynchronizationContext`完全兼容 API 文档 --- UniTask 的 API 文档托管在[cysharp.github.io/UniTask](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.html)，使用[DocFX](https://dotnet.github.io/docfx/)和[Cysharp/DocfXTemplate](https://github.com/Cysharp/DocfxTemplate)生成。 例如，UniTask 的工厂方法可以在[UniTask#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.UniTask.html#methods-1)中查阅。UniTaskAsyncEnumerable 的工厂方法和扩展方法可以在[UniTaskAsyncEnumerable#methods](https://cysharp.github.io/UniTask/api/Cysharp.Threading.Tasks.Linq.UniTaskAsyncEnumerable.html#methods-1)中查阅。 UPM 包 --- ### 通过 git URL 安装 需要支持 git 包路径查询参数的 Unity 版本（Unity >= 2019.3.4f1，Unity >= 2020.1a21）。您可以在包管理器中添加`https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask` ![image](https://user-images.githubusercontent.com/46207/79450714-3aadd100-8020-11ea-8aae-b8d87fc4d7be.png) ![image](https://user-images.githubusercontent.com/46207/83702872-e0f17c80-a648-11ea-8183-7469dcd4f810.png) 或在`Packages/manifest.json`中添加`"com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask"` 。 UniTask 使用`*.*.*`发布标签来指定版本，因此如果您要设置指定版本，您可以在后面添加像`#2.1.0`这样的版本标签。例如`https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.1.0` 。 关于 .NET Core --- 对于 .NET Core，请使用 NuGet。 > PM> Install-Package [UniTask](https://www.nuget.org/packages/UniTask) .NET Core 版本的 UniTask 是 Unity 版本的 UniTask 的子集，它移除了依赖 PlayerLoop 的方法。 相比于原生 Task 和 ValueTask，它能以更高的性能运行，但在使用时应注意忽略 ExecutionContext 和 SynchronizationContext。因为它忽略了 ExecutionContext，`AsyncLocal`也不起作用。 如果您在内部使用 UniTask，但将 ValueTask 作为外部 API 提供，您可以编写如下代码（受[PooledAwait](https://github.com/mgravell/PooledAwait)启发）。 ```csharp public class ZeroAllocAsyncAwaitInDotNetCore { public ValueTask DoAsync(int x, int y) { return Core(this, x, y); static async UniTask Core(ZeroAllocAsyncAwaitInDotNetCore self, int x, int y) { // do anything... await Task.Delay(TimeSpan.FromSeconds(x + y)); await UniTask.Yield(); return 10; } } } // UniTask 不会返回到原生 SynchronizationContext，但可以使用 `ReturnToCurrentSynchronizationContext`来让他返回 public ValueTask TestAsync() { await using (UniTask.ReturnToCurrentSynchronizationContext()) { await UniTask.SwitchToThreadPool(); // do anything.. } } ``` .NET Core 版本的 UniTask 是为了让用户在与 Unity 共享代码时（例如使用[CysharpOnion](https://github.com/Cysharp/MagicOnion/)），能够将 UniTask 用作接口。.NET Core 版本的 UniTask 使得代码共享更加顺畅。 [Cysharp/ValueTaskSupplement](https://github.com/Cysharp/ValueTaskSupplement)提供了一些实用方法，如 WhenAll，这些方法等效于 UniTask。 许可证 --- 此库采用MIT许可证 ================================================ FILE: UniTask.NetCore.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.0.31606.5 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UniTask.NetCoreTests", "src\UniTask.NetCoreTests\UniTask.NetCoreTests.csproj", "{B3E311A4-70D8-4131-9965-C073A99D201A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UniTask.NetCore", "src\UniTask.NetCore\UniTask.NetCore.csproj", "{16EE20D0-7FB1-483A-8467-A5EEDBF1F5BF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UniTask.NetCoreSandbox", "src\UniTask.NetCoreSandbox\UniTask.NetCoreSandbox.csproj", "{3915E72E-33E0-4A14-A6D8-872702200E58}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UniTask.Analyzer", "src\UniTask.Analyzer\UniTask.Analyzer.csproj", "{0AC6F052-A255-4EE3-9E05-1C02D49AB1C2}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {B3E311A4-70D8-4131-9965-C073A99D201A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B3E311A4-70D8-4131-9965-C073A99D201A}.Debug|Any CPU.Build.0 = Debug|Any CPU {B3E311A4-70D8-4131-9965-C073A99D201A}.Release|Any CPU.ActiveCfg = Release|Any CPU {B3E311A4-70D8-4131-9965-C073A99D201A}.Release|Any CPU.Build.0 = Release|Any CPU {16EE20D0-7FB1-483A-8467-A5EEDBF1F5BF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {16EE20D0-7FB1-483A-8467-A5EEDBF1F5BF}.Debug|Any CPU.Build.0 = Debug|Any CPU {16EE20D0-7FB1-483A-8467-A5EEDBF1F5BF}.Release|Any CPU.ActiveCfg = Release|Any CPU {16EE20D0-7FB1-483A-8467-A5EEDBF1F5BF}.Release|Any CPU.Build.0 = Release|Any CPU {3915E72E-33E0-4A14-A6D8-872702200E58}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3915E72E-33E0-4A14-A6D8-872702200E58}.Debug|Any CPU.Build.0 = Debug|Any CPU {3915E72E-33E0-4A14-A6D8-872702200E58}.Release|Any CPU.ActiveCfg = Release|Any CPU {3915E72E-33E0-4A14-A6D8-872702200E58}.Release|Any CPU.Build.0 = Release|Any CPU {0AC6F052-A255-4EE3-9E05-1C02D49AB1C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {0AC6F052-A255-4EE3-9E05-1C02D49AB1C2}.Debug|Any CPU.Build.0 = Debug|Any CPU {0AC6F052-A255-4EE3-9E05-1C02D49AB1C2}.Release|Any CPU.ActiveCfg = Release|Any CPU {0AC6F052-A255-4EE3-9E05-1C02D49AB1C2}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {90F78FCC-7CD4-4E88-A3DB-873F481F8C8B} EndGlobalSection EndGlobal ================================================ FILE: docs/.gitignore ================================================ ############### # folder # ############### /**/DROP/ /**/TEMP/ /**/packages/ /**/bin/ /**/obj/ _site _DocfxTemplate ================================================ FILE: docs/api/.gitignore ================================================ ############### # temp file # ############### *.yml .manifest ================================================ FILE: docs/docfx.json ================================================ { "metadata": [ { "src": [ { "files": [ "UniTask/Library/ScriptAssemblies/UniTask*.dll" ], "exclude": [ "UniTask/Library/ScriptAssemblies/UniTask.Tests.dll", "UniTask/Library/ScriptAssemblies/UniTask.Tests.Editor.dll" ], "src": "../src" } ], "dest": "api", "disableGitFeatures": false, "disableDefaultFilter": false } ], "build": { "globalMetadata": { "_disableContribution": true, "_appTitle": "UniTask" }, "content": [ { "files": [ "api/**.yml", "api/index.md" ] }, { "files": [ "articles/**.md", "articles/**/toc.yml", "toc.yml", "*.md" ] } ], "resource": [ { "files": [ "images/**" ] } ], "overwrite": [ { "files": [ "apidoc/**.md" ], "exclude": [ "obj/**", "_site/**" ] } ], "dest": "_site", "globalMetadataFiles": [], "fileMetadataFiles": [], "template": [ "_DocfxTemplate/templates/default-v2.5.2", "_DocfxTemplate/templates/cysharp" ], "postProcessors": [], "markdownEngineName": "markdig", "noLangKeyword": false, "keepFileLink": false, "cleanupCacheHistory": false } } ================================================ FILE: docs/index.md ================================================ --- title: Home --- # UniTask Provides an efficient async/await integration to Unity. https://github.com/Cysharp/UniTask ================================================ FILE: docs/toc.yml ================================================ - name: API Documentation href: api/ homepage: api/Cysharp.Threading.Tasks.html - name: Repository href: https://github.com/Cysharp/UniTask homepage: https://github.com/Cysharp/UniTask - name: Releases href: https://github.com/Cysharp/UniTask/releases homepage: https://github.com/Cysharp/UniTask/releases ================================================ FILE: src/UniTask/Assets/Editor/EditorRunnerChecker.cs ================================================ #if UNITY_EDITOR using Cysharp.Threading.Tasks; using System; using System.IO; using System.Linq; using UnityEditor; using UnityEngine; using UnityEngine.Networking; public static class EditorRunnerChecker { [MenuItem("Tools/UniTaskEditorRunnerChecker")] public static void RunUniTaskAsync() { RunCore().Forget(); } static async UniTaskVoid RunCore() { Debug.Log("Start"); //var r = await UnityWebRequest.Get("https://bing.com/").SendWebRequest().ToUniTask(); //Debug.Log(r.downloadHandler.text.Substring(0, 100)); //await UniTask.Yield(); await UniTask.DelayFrame(30); Debug.Log("End"); } } #endif ================================================ FILE: src/UniTask/Assets/Editor/EditorRunnerChecker.cs.meta ================================================ fileFormatVersion: 2 guid: e51b78c06cb410f42b36e0af9de3b065 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Editor/PackageExporter.cs ================================================ #if UNITY_EDITOR using System; using System.IO; using System.Linq; using UnityEditor; using UnityEngine; public static class PackageExporter { [MenuItem("Tools/Export Unitypackage")] public static void Export() { var root = "Plugins/UniTask"; 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) .Where(x => Path.GetExtension(x) == ".cs" || Path.GetExtension(x) == ".asmdef" || Path.GetExtension(x) == ".json" || Path.GetExtension(x) == ".meta") .Select(x => "Assets" + x.Replace(Application.dataPath, "").Replace(@"\", "/")) .ToArray(); UnityEngine.Debug.Log("Export below files" + Environment.NewLine + string.Join(Environment.NewLine, assets)); AssetDatabase.ExportPackage( assets, exportPath, ExportPackageOptions.Default); 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(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 ================================================ FILE: src/UniTask/Assets/Editor/PackageExporter.cs.meta ================================================ fileFormatVersion: 2 guid: af97405af79afbb4e9f7f49f30088474 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Editor.meta ================================================ fileFormatVersion: 2 guid: 99c8676e874bf0343b421d3527868f16 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor/SplitterGUILayout.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Linq; using System.Reflection; using UnityEditor; using UnityEngine; namespace Cysharp.Threading.Tasks.Editor { // reflection call of UnityEditor.SplitterGUILayout internal static class SplitterGUILayout { static BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static; static Lazy splitterStateType = new Lazy(() => { var type = typeof(EditorWindow).Assembly.GetTypes().First(x => x.FullName == "UnityEditor.SplitterState"); return type; }); static Lazy splitterStateCtor = new Lazy(() => { var type = splitterStateType.Value; return type.GetConstructor(flags, null, new Type[] { typeof(float[]), typeof(int[]), typeof(int[]) }, null); }); static Lazy splitterGUILayoutType = new Lazy(() => { var type = typeof(EditorWindow).Assembly.GetTypes().First(x => x.FullName == "UnityEditor.SplitterGUILayout"); return type; }); static Lazy beginVerticalSplit = new Lazy(() => { var type = splitterGUILayoutType.Value; return type.GetMethod("BeginVerticalSplit", flags, null, new Type[] { splitterStateType.Value, typeof(GUILayoutOption[]) }, null); }); static Lazy endVerticalSplit = new Lazy(() => { var type = splitterGUILayoutType.Value; return type.GetMethod("EndVerticalSplit", flags, null, Type.EmptyTypes, null); }); public static object CreateSplitterState(float[] relativeSizes, int[] minSizes, int[] maxSizes) { return splitterStateCtor.Value.Invoke(new object[] { relativeSizes, minSizes, maxSizes }); } public static void BeginVerticalSplit(object splitterState, params GUILayoutOption[] options) { beginVerticalSplit.Value.Invoke(null, new object[] { splitterState, options }); } public static void EndVerticalSplit() { endVerticalSplit.Value.Invoke(null, Type.EmptyTypes); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor/SplitterGUILayout.cs.meta ================================================ fileFormatVersion: 2 guid: 40ef2e46f900131419e869398a8d3c9d MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor/UniTask.Editor.asmdef ================================================ { "name": "UniTask.Editor", "references": [ "UniTask" ], "includePlatforms": [ "Editor" ], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": false, "precompiledReferences": [], "autoReferenced": false, "defineConstraints": [], "versionDefines": [], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor/UniTask.Editor.asmdef.meta ================================================ fileFormatVersion: 2 guid: 4129704b5a1a13841ba16f230bf24a57 AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor/UniTaskTrackerTreeView.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using UnityEngine; using UnityEditor; using System.Collections.Generic; using System.Linq; using System.Reflection; using System; using UnityEditor.IMGUI.Controls; using Cysharp.Threading.Tasks.Internal; using System.Text; using System.Text.RegularExpressions; namespace Cysharp.Threading.Tasks.Editor { public class UniTaskTrackerViewItem : TreeViewItem { static Regex removeHref = new Regex("(.+)", RegexOptions.Compiled); public string TaskType { get; set; } public string Elapsed { get; set; } public string Status { get; set; } string position; public string Position { get { return position; } set { position = value; PositionFirstLine = GetFirstLine(position); } } public string PositionFirstLine { get; private set; } static string GetFirstLine(string str) { var sb = new StringBuilder(); for (int i = 0; i < str.Length; i++) { if (str[i] == '\r' || str[i] == '\n') { break; } sb.Append(str[i]); } return removeHref.Replace(sb.ToString(), "$1"); } public UniTaskTrackerViewItem(int id) : base(id) { } } public class UniTaskTrackerTreeView : TreeView { const string sortedColumnIndexStateKey = "UniTaskTrackerTreeView_sortedColumnIndex"; public IReadOnlyList CurrentBindingItems; public UniTaskTrackerTreeView() : this(new TreeViewState(), new MultiColumnHeader(new MultiColumnHeaderState(new[] { new MultiColumnHeaderState.Column() { headerContent = new GUIContent("TaskType"), width = 20}, new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Elapsed"), width = 10}, new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Status"), width = 10}, new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Position")}, }))) { } UniTaskTrackerTreeView(TreeViewState state, MultiColumnHeader header) : base(state, header) { rowHeight = 20; showAlternatingRowBackgrounds = true; showBorder = true; header.sortingChanged += Header_sortingChanged; header.ResizeToFit(); Reload(); header.sortedColumnIndex = SessionState.GetInt(sortedColumnIndexStateKey, 1); } public void ReloadAndSort() { var currentSelected = this.state.selectedIDs; Reload(); Header_sortingChanged(this.multiColumnHeader); this.state.selectedIDs = currentSelected; } private void Header_sortingChanged(MultiColumnHeader multiColumnHeader) { SessionState.SetInt(sortedColumnIndexStateKey, multiColumnHeader.sortedColumnIndex); var index = multiColumnHeader.sortedColumnIndex; var ascending = multiColumnHeader.IsSortedAscending(multiColumnHeader.sortedColumnIndex); var items = rootItem.children.Cast(); IOrderedEnumerable orderedEnumerable; switch (index) { case 0: orderedEnumerable = ascending ? items.OrderBy(item => item.TaskType) : items.OrderByDescending(item => item.TaskType); break; case 1: orderedEnumerable = ascending ? items.OrderBy(item => double.Parse(item.Elapsed)) : items.OrderByDescending(item => double.Parse(item.Elapsed)); break; case 2: orderedEnumerable = ascending ? items.OrderBy(item => item.Status) : items.OrderByDescending(item => item.Elapsed); break; case 3: orderedEnumerable = ascending ? items.OrderBy(item => item.Position) : items.OrderByDescending(item => item.PositionFirstLine); break; default: throw new ArgumentOutOfRangeException(nameof(index), index, null); } CurrentBindingItems = rootItem.children = orderedEnumerable.Cast().ToList(); BuildRows(rootItem); } protected override TreeViewItem BuildRoot() { var root = new TreeViewItem { depth = -1 }; var children = new List(); TaskTracker.ForEachActiveTask((trackingId, awaiterType, status, created, stackTrace) => { children.Add(new UniTaskTrackerViewItem(trackingId) { TaskType = awaiterType, Status = status.ToString(), Elapsed = (DateTime.UtcNow - created).TotalSeconds.ToString("00.00"), Position = stackTrace }); }); CurrentBindingItems = children; root.children = CurrentBindingItems as List; return root; } protected override bool CanMultiSelect(TreeViewItem item) { return false; } protected override void RowGUI(RowGUIArgs args) { var item = args.item as UniTaskTrackerViewItem; for (var visibleColumnIndex = 0; visibleColumnIndex < args.GetNumVisibleColumns(); visibleColumnIndex++) { var rect = args.GetCellRect(visibleColumnIndex); var columnIndex = args.GetColumn(visibleColumnIndex); var labelStyle = args.selected ? EditorStyles.whiteLabel : EditorStyles.label; labelStyle.alignment = TextAnchor.MiddleLeft; switch (columnIndex) { case 0: EditorGUI.LabelField(rect, item.TaskType, labelStyle); break; case 1: EditorGUI.LabelField(rect, item.Elapsed, labelStyle); break; case 2: EditorGUI.LabelField(rect, item.Status, labelStyle); break; case 3: EditorGUI.LabelField(rect, item.PositionFirstLine, labelStyle); break; default: throw new ArgumentOutOfRangeException(nameof(columnIndex), columnIndex, null); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor/UniTaskTrackerTreeView.cs.meta ================================================ fileFormatVersion: 2 guid: 52e2d973a2156674e8c1c9433ed031f7 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor/UniTaskTrackerWindow.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using UnityEngine; using UnityEditor; using System.Collections.Generic; using System.Linq; using System.Reflection; using System; using UnityEditor.IMGUI.Controls; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Editor { public class UniTaskTrackerWindow : EditorWindow { static int interval; static UniTaskTrackerWindow window; [MenuItem("Window/UniTask Tracker")] public static void OpenWindow() { if (window != null) { window.Close(); } // will called OnEnable(singleton instance will be set). GetWindow("UniTask Tracker").Show(); } static readonly GUILayoutOption[] EmptyLayoutOption = new GUILayoutOption[0]; UniTaskTrackerTreeView treeView; object splitterState; void OnEnable() { window = this; // set singleton. splitterState = SplitterGUILayout.CreateSplitterState(new float[] { 75f, 25f }, new int[] { 32, 32 }, null); treeView = new UniTaskTrackerTreeView(); TaskTracker.EditorEnableState.EnableAutoReload = EditorPrefs.GetBool(TaskTracker.EnableAutoReloadKey, false); TaskTracker.EditorEnableState.EnableTracking = EditorPrefs.GetBool(TaskTracker.EnableTrackingKey, false); TaskTracker.EditorEnableState.EnableStackTrace = EditorPrefs.GetBool(TaskTracker.EnableStackTraceKey, false); } void OnGUI() { // Head RenderHeadPanel(); // Splittable SplitterGUILayout.BeginVerticalSplit(this.splitterState, EmptyLayoutOption); { // Column Tabble RenderTable(); // StackTrace details RenderDetailsPanel(); } SplitterGUILayout.EndVerticalSplit(); } #region HeadPanel public static bool EnableAutoReload => TaskTracker.EditorEnableState.EnableAutoReload; public static bool EnableTracking => TaskTracker.EditorEnableState.EnableTracking; public static bool EnableStackTrace => TaskTracker.EditorEnableState.EnableStackTrace; static readonly GUIContent EnableAutoReloadHeadContent = EditorGUIUtility.TrTextContent("Enable AutoReload", "Reload automatically.", (Texture)null); static readonly GUIContent ReloadHeadContent = EditorGUIUtility.TrTextContent("Reload", "Reload View.", (Texture)null); static readonly GUIContent GCHeadContent = EditorGUIUtility.TrTextContent("GC.Collect", "Invoke GC.Collect.", (Texture)null); static readonly GUIContent EnableTrackingHeadContent = EditorGUIUtility.TrTextContent("Enable Tracking", "Start to track async/await UniTask. Performance impact: low", (Texture)null); static readonly GUIContent EnableStackTraceHeadContent = EditorGUIUtility.TrTextContent("Enable StackTrace", "Capture StackTrace when task is started. Performance impact: high", (Texture)null); // [Enable Tracking] | [Enable StackTrace] void RenderHeadPanel() { EditorGUILayout.BeginVertical(EmptyLayoutOption); EditorGUILayout.BeginHorizontal(EditorStyles.toolbar, EmptyLayoutOption); if (GUILayout.Toggle(EnableAutoReload, EnableAutoReloadHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableAutoReload) { TaskTracker.EditorEnableState.EnableAutoReload = !EnableAutoReload; } if (GUILayout.Toggle(EnableTracking, EnableTrackingHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableTracking) { TaskTracker.EditorEnableState.EnableTracking = !EnableTracking; } if (GUILayout.Toggle(EnableStackTrace, EnableStackTraceHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableStackTrace) { TaskTracker.EditorEnableState.EnableStackTrace = !EnableStackTrace; } GUILayout.FlexibleSpace(); if (GUILayout.Button(ReloadHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption)) { TaskTracker.CheckAndResetDirty(); treeView.ReloadAndSort(); Repaint(); } if (GUILayout.Button(GCHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption)) { GC.Collect(0); } EditorGUILayout.EndHorizontal(); EditorGUILayout.EndVertical(); } #endregion #region TableColumn Vector2 tableScroll; GUIStyle tableListStyle; void RenderTable() { if (tableListStyle == null) { tableListStyle = new GUIStyle("CN Box"); tableListStyle.margin.top = 0; tableListStyle.padding.left = 3; } EditorGUILayout.BeginVertical(tableListStyle, EmptyLayoutOption); this.tableScroll = EditorGUILayout.BeginScrollView(this.tableScroll, new GUILayoutOption[] { GUILayout.ExpandWidth(true), GUILayout.MaxWidth(2000f) }); var controlRect = EditorGUILayout.GetControlRect(new GUILayoutOption[] { GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true) }); treeView?.OnGUI(controlRect); EditorGUILayout.EndScrollView(); EditorGUILayout.EndVertical(); } private void Update() { if (EnableAutoReload) { if (interval++ % 120 == 0) { if (TaskTracker.CheckAndResetDirty()) { treeView.ReloadAndSort(); Repaint(); } } } } #endregion #region Details static GUIStyle detailsStyle; Vector2 detailsScroll; void RenderDetailsPanel() { if (detailsStyle == null) { detailsStyle = new GUIStyle("CN Message"); detailsStyle.wordWrap = false; detailsStyle.stretchHeight = true; detailsStyle.margin.right = 15; } string message = ""; var selected = treeView.state.selectedIDs; if (selected.Count > 0) { var first = selected[0]; var item = treeView.CurrentBindingItems.FirstOrDefault(x => x.id == first) as UniTaskTrackerViewItem; if (item != null) { message = item.Position; } } detailsScroll = EditorGUILayout.BeginScrollView(this.detailsScroll, EmptyLayoutOption); var vector = detailsStyle.CalcSize(new GUIContent(message)); EditorGUILayout.SelectableLabel(message, detailsStyle, new GUILayoutOption[] { GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true), GUILayout.MinWidth(vector.x), GUILayout.MinHeight(vector.y) }); EditorGUILayout.EndScrollView(); } #endregion } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor/UniTaskTrackerWindow.cs.meta ================================================ fileFormatVersion: 2 guid: 5bee3e3860e37484aa3b861bf76d129f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Editor.meta ================================================ fileFormatVersion: 2 guid: 275b87293edc6634f9d72387851dbbdf folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncLazy.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; namespace Cysharp.Threading.Tasks { public class AsyncLazy { static Action continuation = SetCompletionSource; Func taskFactory; UniTaskCompletionSource completionSource; UniTask.Awaiter awaiter; object syncLock; bool initialized; public AsyncLazy(Func taskFactory) { this.taskFactory = taskFactory; this.completionSource = new UniTaskCompletionSource(); this.syncLock = new object(); this.initialized = false; } internal AsyncLazy(UniTask task) { this.taskFactory = null; this.completionSource = new UniTaskCompletionSource(); this.syncLock = null; this.initialized = true; var awaiter = task.GetAwaiter(); if (awaiter.IsCompleted) { SetCompletionSource(awaiter); } else { this.awaiter = awaiter; awaiter.SourceOnCompleted(continuation, this); } } public UniTask Task { get { EnsureInitialized(); return completionSource.Task; } } public UniTask.Awaiter GetAwaiter() => Task.GetAwaiter(); void EnsureInitialized() { if (Volatile.Read(ref initialized)) { return; } EnsureInitializedCore(); } void EnsureInitializedCore() { lock (syncLock) { if (!Volatile.Read(ref initialized)) { var f = Interlocked.Exchange(ref taskFactory, null); if (f != null) { var task = f(); var awaiter = task.GetAwaiter(); if (awaiter.IsCompleted) { SetCompletionSource(awaiter); } else { this.awaiter = awaiter; awaiter.SourceOnCompleted(continuation, this); } Volatile.Write(ref initialized, true); } } } } void SetCompletionSource(in UniTask.Awaiter awaiter) { try { awaiter.GetResult(); completionSource.TrySetResult(); } catch (Exception ex) { completionSource.TrySetException(ex); } } static void SetCompletionSource(object state) { var self = (AsyncLazy)state; try { self.awaiter.GetResult(); self.completionSource.TrySetResult(); } catch (Exception ex) { self.completionSource.TrySetException(ex); } finally { self.awaiter = default; } } } public class AsyncLazy { static Action continuation = SetCompletionSource; Func> taskFactory; UniTaskCompletionSource completionSource; UniTask.Awaiter awaiter; object syncLock; bool initialized; public AsyncLazy(Func> taskFactory) { this.taskFactory = taskFactory; this.completionSource = new UniTaskCompletionSource(); this.syncLock = new object(); this.initialized = false; } internal AsyncLazy(UniTask task) { this.taskFactory = null; this.completionSource = new UniTaskCompletionSource(); this.syncLock = null; this.initialized = true; var awaiter = task.GetAwaiter(); if (awaiter.IsCompleted) { SetCompletionSource(awaiter); } else { this.awaiter = awaiter; awaiter.SourceOnCompleted(continuation, this); } } public UniTask Task { get { EnsureInitialized(); return completionSource.Task; } } public UniTask.Awaiter GetAwaiter() => Task.GetAwaiter(); void EnsureInitialized() { if (Volatile.Read(ref initialized)) { return; } EnsureInitializedCore(); } void EnsureInitializedCore() { lock (syncLock) { if (!Volatile.Read(ref initialized)) { var f = Interlocked.Exchange(ref taskFactory, null); if (f != null) { var task = f(); var awaiter = task.GetAwaiter(); if (awaiter.IsCompleted) { SetCompletionSource(awaiter); } else { this.awaiter = awaiter; awaiter.SourceOnCompleted(continuation, this); } Volatile.Write(ref initialized, true); } } } } void SetCompletionSource(in UniTask.Awaiter awaiter) { try { var result = awaiter.GetResult(); completionSource.TrySetResult(result); } catch (Exception ex) { completionSource.TrySetException(ex); } } static void SetCompletionSource(object state) { var self = (AsyncLazy)state; try { var result = self.awaiter.GetResult(); self.completionSource.TrySetResult(result); } catch (Exception ex) { self.completionSource.TrySetException(ex); } finally { self.awaiter = default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncLazy.cs.meta ================================================ fileFormatVersion: 2 guid: 01d1404ca421466419a7db7340ff5e77 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncReactiveProperty.cs ================================================ using System; using System.Threading; namespace Cysharp.Threading.Tasks { public interface IReadOnlyAsyncReactiveProperty : IUniTaskAsyncEnumerable { T Value { get; } IUniTaskAsyncEnumerable WithoutCurrent(); UniTask WaitAsync(CancellationToken cancellationToken = default); } public interface IAsyncReactiveProperty : IReadOnlyAsyncReactiveProperty { new T Value { get; set; } } [Serializable] public class AsyncReactiveProperty : IAsyncReactiveProperty, IDisposable { TriggerEvent 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 WithoutCurrent() { return new WithoutCurrentEnumerable(this); } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken) { return new Enumerator(this, cancellationToken, true); } public void Dispose() { triggerEvent.SetCompleted(); } public static implicit operator T(AsyncReactiveProperty value) { return value.Value; } public override string ToString() { if (isValueType) return latestValue.ToString(); return latestValue?.ToString(); } public UniTask WaitAsync(CancellationToken cancellationToken = default) { return new UniTask(WaitAsyncSource.Create(this, cancellationToken, out var token), token); } static bool isValueType; static AsyncReactiveProperty() { isValueType = typeof(T).IsValueType; } sealed class WaitAsyncSource : IUniTaskSource, ITriggerHandler, ITaskPoolNode { static Action cancellationCallback = CancellationCallback; static TaskPool pool; WaitAsyncSource nextNode; ref WaitAsyncSource ITaskPoolNode.NextNode => ref nextNode; static WaitAsyncSource() { TaskPool.RegisterSizeGetter(typeof(WaitAsyncSource), () => pool.Size); } AsyncReactiveProperty parent; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; UniTaskCompletionSourceCore core; WaitAsyncSource() { } public static IUniTaskSource Create(AsyncReactiveProperty parent, CancellationToken cancellationToken, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitAsyncSource(); } result.parent = parent; result.cancellationToken = cancellationToken; if (cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, result); } result.parent.triggerEvent.Add(result); TaskTracker.TrackActiveTask(result, 3); token = result.core.Version; return result; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); cancellationTokenRegistration.Dispose(); cancellationTokenRegistration = default; parent.triggerEvent.Remove(this); parent = null; cancellationToken = default; return pool.TryPush(this); } static void CancellationCallback(object state) { var self = (WaitAsyncSource)state; self.OnCanceled(self.cancellationToken); } // IUniTaskSource public T GetResult(short token) { try { return core.GetResult(token); } finally { TryReturn(); } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } // ITriggerHandler ITriggerHandler ITriggerHandler.Prev { get; set; } ITriggerHandler ITriggerHandler.Next { get; set; } public void OnCanceled(CancellationToken cancellationToken) { core.TrySetCanceled(cancellationToken); } public void OnCompleted() { // Complete as Cancel. core.TrySetCanceled(CancellationToken.None); } public void OnError(Exception ex) { core.TrySetException(ex); } public void OnNext(T value) { core.TrySetResult(value); } } sealed class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable { readonly AsyncReactiveProperty parent; public WithoutCurrentEnumerable(AsyncReactiveProperty parent) { this.parent = parent; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new Enumerator(parent, cancellationToken, false); } } sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator, ITriggerHandler { static Action cancellationCallback = CancellationCallback; readonly AsyncReactiveProperty parent; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration cancellationTokenRegistration; T value; bool isDisposed; bool firstCall; public Enumerator(AsyncReactiveProperty parent, CancellationToken cancellationToken, bool publishCurrentValue) { this.parent = parent; this.cancellationToken = cancellationToken; this.firstCall = publishCurrentValue; parent.triggerEvent.Add(this); TaskTracker.TrackActiveTask(this, 3); if (cancellationToken.CanBeCanceled) { cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this); } } public T Current => value; ITriggerHandler ITriggerHandler.Prev { get; set; } ITriggerHandler ITriggerHandler.Next { get; set; } public UniTask MoveNextAsync() { // raise latest value on first call. if (firstCall) { firstCall = false; value = parent.Value; return CompletedTasks.True; } completionSource.Reset(); return new UniTask(this, completionSource.Version); } public UniTask DisposeAsync() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); completionSource.TrySetCanceled(cancellationToken); parent.triggerEvent.Remove(this); } return default; } public void OnNext(T value) { this.value = value; completionSource.TrySetResult(true); } public void OnCanceled(CancellationToken cancellationToken) { DisposeAsync().Forget(); } public void OnCompleted() { completionSource.TrySetResult(false); } public void OnError(Exception ex) { completionSource.TrySetException(ex); } static void CancellationCallback(object state) { var self = (Enumerator)state; self.DisposeAsync().Forget(); } } } public class ReadOnlyAsyncReactiveProperty : IReadOnlyAsyncReactiveProperty, IDisposable { TriggerEvent triggerEvent; T latestValue; IUniTaskAsyncEnumerator enumerator; public T Value { get { return latestValue; } } public ReadOnlyAsyncReactiveProperty(T initialValue, IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { latestValue = initialValue; ConsumeEnumerator(source, cancellationToken).Forget(); } public ReadOnlyAsyncReactiveProperty(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { ConsumeEnumerator(source, cancellationToken).Forget(); } async UniTaskVoid ConsumeEnumerator(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { enumerator = source.GetAsyncEnumerator(cancellationToken); try { while (await enumerator.MoveNextAsync()) { var value = enumerator.Current; this.latestValue = value; triggerEvent.SetResult(value); } } finally { await enumerator.DisposeAsync(); enumerator = null; } } public IUniTaskAsyncEnumerable WithoutCurrent() { return new WithoutCurrentEnumerable(this); } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken) { return new Enumerator(this, cancellationToken, true); } public void Dispose() { if (enumerator != null) { enumerator.DisposeAsync().Forget(); } triggerEvent.SetCompleted(); } public static implicit operator T(ReadOnlyAsyncReactiveProperty value) { return value.Value; } public override string ToString() { if (isValueType) return latestValue.ToString(); return latestValue?.ToString(); } public UniTask WaitAsync(CancellationToken cancellationToken = default) { return new UniTask(WaitAsyncSource.Create(this, cancellationToken, out var token), token); } static bool isValueType; static ReadOnlyAsyncReactiveProperty() { isValueType = typeof(T).IsValueType; } sealed class WaitAsyncSource : IUniTaskSource, ITriggerHandler, ITaskPoolNode { static Action cancellationCallback = CancellationCallback; static TaskPool pool; WaitAsyncSource nextNode; ref WaitAsyncSource ITaskPoolNode.NextNode => ref nextNode; static WaitAsyncSource() { TaskPool.RegisterSizeGetter(typeof(WaitAsyncSource), () => pool.Size); } ReadOnlyAsyncReactiveProperty parent; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; UniTaskCompletionSourceCore core; WaitAsyncSource() { } public static IUniTaskSource Create(ReadOnlyAsyncReactiveProperty parent, CancellationToken cancellationToken, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitAsyncSource(); } result.parent = parent; result.cancellationToken = cancellationToken; if (cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, result); } result.parent.triggerEvent.Add(result); TaskTracker.TrackActiveTask(result, 3); token = result.core.Version; return result; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); cancellationTokenRegistration.Dispose(); cancellationTokenRegistration = default; parent.triggerEvent.Remove(this); parent = null; cancellationToken = default; return pool.TryPush(this); } static void CancellationCallback(object state) { var self = (WaitAsyncSource)state; self.OnCanceled(self.cancellationToken); } // IUniTaskSource public T GetResult(short token) { try { return core.GetResult(token); } finally { TryReturn(); } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } // ITriggerHandler ITriggerHandler ITriggerHandler.Prev { get; set; } ITriggerHandler ITriggerHandler.Next { get; set; } public void OnCanceled(CancellationToken cancellationToken) { core.TrySetCanceled(cancellationToken); } public void OnCompleted() { // Complete as Cancel. core.TrySetCanceled(CancellationToken.None); } public void OnError(Exception ex) { core.TrySetException(ex); } public void OnNext(T value) { core.TrySetResult(value); } } sealed class WithoutCurrentEnumerable : IUniTaskAsyncEnumerable { readonly ReadOnlyAsyncReactiveProperty parent; public WithoutCurrentEnumerable(ReadOnlyAsyncReactiveProperty parent) { this.parent = parent; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new Enumerator(parent, cancellationToken, false); } } sealed class Enumerator : MoveNextSource, IUniTaskAsyncEnumerator, ITriggerHandler { static Action cancellationCallback = CancellationCallback; readonly ReadOnlyAsyncReactiveProperty parent; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration cancellationTokenRegistration; T value; bool isDisposed; bool firstCall; public Enumerator(ReadOnlyAsyncReactiveProperty parent, CancellationToken cancellationToken, bool publishCurrentValue) { this.parent = parent; this.cancellationToken = cancellationToken; this.firstCall = publishCurrentValue; parent.triggerEvent.Add(this); TaskTracker.TrackActiveTask(this, 3); if (cancellationToken.CanBeCanceled) { cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this); } } public T Current => value; ITriggerHandler ITriggerHandler.Prev { get; set; } ITriggerHandler ITriggerHandler.Next { get; set; } public UniTask MoveNextAsync() { // raise latest value on first call. if (firstCall) { firstCall = false; value = parent.Value; return CompletedTasks.True; } completionSource.Reset(); return new UniTask(this, completionSource.Version); } public UniTask DisposeAsync() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); completionSource.TrySetCanceled(cancellationToken); parent.triggerEvent.Remove(this); } return default; } public void OnNext(T value) { this.value = value; completionSource.TrySetResult(true); } public void OnCanceled(CancellationToken cancellationToken) { DisposeAsync().Forget(); } public void OnCompleted() { completionSource.TrySetResult(false); } public void OnError(Exception ex) { completionSource.TrySetException(ex); } static void CancellationCallback(object state) { var self = (Enumerator)state; self.DisposeAsync().Forget(); } } } public static class StateExtensions { public static ReadOnlyAsyncReactiveProperty ToReadOnlyAsyncReactiveProperty(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { return new ReadOnlyAsyncReactiveProperty(source, cancellationToken); } public static ReadOnlyAsyncReactiveProperty ToReadOnlyAsyncReactiveProperty(this IUniTaskAsyncEnumerable source, T initialValue, CancellationToken cancellationToken) { return new ReadOnlyAsyncReactiveProperty(initialValue, source, cancellationToken); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncReactiveProperty.cs.meta ================================================ fileFormatVersion: 2 guid: 8ef320b87f537ee4fb2282e765dc6166 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncUnit.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or using System; namespace Cysharp.Threading.Tasks { public readonly struct AsyncUnit : IEquatable { public static readonly AsyncUnit Default = new AsyncUnit(); public override int GetHashCode() { return 0; } public bool Equals(AsyncUnit other) { return true; } public override string ToString() { return "()"; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/AsyncUnit.cs.meta ================================================ fileFormatVersion: 2 guid: 4f95ac245430d304bb5128d13b6becc8 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenEqualityComparer.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks { public class CancellationTokenEqualityComparer : IEqualityComparer { public static readonly IEqualityComparer Default = new CancellationTokenEqualityComparer(); public bool Equals(CancellationToken x, CancellationToken y) { return x.Equals(y); } public int GetHashCode(CancellationToken obj) { return obj.GetHashCode(); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenEqualityComparer.cs.meta ================================================ fileFormatVersion: 2 guid: 7d739f510b125b74fa7290ac4335e46e MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenExtensions.cs ================================================ #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 { public static class CancellationTokenExtensions { static readonly Action cancellationTokenCallback = Callback; static readonly Action disposeCallback = DisposeCallback; public static CancellationToken ToCancellationToken(this UniTask task) { var cts = new CancellationTokenSource(); ToCancellationTokenCore(task, cts).Forget(); return cts.Token; } public static CancellationToken ToCancellationToken(this UniTask task, CancellationToken linkToken) { if (linkToken.IsCancellationRequested) { return linkToken; } if (!linkToken.CanBeCanceled) { return ToCancellationToken(task); } var cts = CancellationTokenSource.CreateLinkedTokenSource(linkToken); ToCancellationTokenCore(task, cts).Forget(); return cts.Token; } public static CancellationToken ToCancellationToken(this UniTask task) { return ToCancellationToken(task.AsUniTask()); } public static CancellationToken ToCancellationToken(this UniTask task, CancellationToken linkToken) { return ToCancellationToken(task.AsUniTask(), linkToken); } static async UniTaskVoid ToCancellationTokenCore(UniTask task, CancellationTokenSource cts) { try { await task; } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } cts.Cancel(); cts.Dispose(); } public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return (UniTask.FromCanceled(cancellationToken), default(CancellationTokenRegistration)); } var promise = new UniTaskCompletionSource(); return (promise.Task, cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, promise)); } static void Callback(object state) { var promise = (UniTaskCompletionSource)state; 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; if (!ExecutionContext.IsFlowSuppressed()) { ExecutionContext.SuppressFlow(); restoreFlow = true; } try { return cancellationToken.Register(callback, false); } finally { if (restoreFlow) { ExecutionContext.RestoreFlow(); } } } public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action callback, object state) { var restoreFlow = false; if (!ExecutionContext.IsFlowSuppressed()) { ExecutionContext.SuppressFlow(); restoreFlow = true; } try { return cancellationToken.Register(callback, state, false); } finally { if (restoreFlow) { ExecutionContext.RestoreFlow(); } } } public static CancellationTokenRegistration AddTo(this IDisposable disposable, CancellationToken cancellationToken) { return cancellationToken.RegisterWithoutCaptureExecutionContext(disposeCallback, disposable); } static void DisposeCallback(object state) { var d = (IDisposable)state; d.Dispose(); } } public struct CancellationTokenAwaitable { CancellationToken cancellationToken; public CancellationTokenAwaitable(CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; } public Awaiter GetAwaiter() { return new Awaiter(cancellationToken); } public struct Awaiter : ICriticalNotifyCompletion { CancellationToken cancellationToken; public Awaiter(CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; } public bool IsCompleted => !cancellationToken.CanBeCanceled || cancellationToken.IsCancellationRequested; public void GetResult() { } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { cancellationToken.RegisterWithoutCaptureExecutionContext(continuation); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 4be7209f04146bd45ac5ee775a5f7c26 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenSourceExtensions.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Threading; using UnityEngine; using Cysharp.Threading.Tasks.Triggers; using System; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public static partial class CancellationTokenSourceExtensions { readonly static Action CancelCancellationTokenSourceStateDelegate = new Action(CancelCancellationTokenSourceState); static void CancelCancellationTokenSourceState(object state) { var cts = (CancellationTokenSource)state; cts.Cancel(); } public static IDisposable CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update) { return CancelAfterSlim(cts, TimeSpan.FromMilliseconds(millisecondsDelay), delayType, delayTiming); } public static IDisposable CancelAfterSlim(this CancellationTokenSource cts, TimeSpan delayTimeSpan, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update) { return PlayerLoopTimer.StartNew(delayTimeSpan, false, delayType, delayTiming, cts.Token, CancelCancellationTokenSourceStateDelegate, cts); } public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, Component component) { RegisterRaiseCancelOnDestroy(cts, component.gameObject); } public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, GameObject gameObject) { var trigger = gameObject.GetAsyncDestroyTrigger(); trigger.CancellationToken.RegisterWithoutCaptureExecutionContext(CancelCancellationTokenSourceStateDelegate, cts); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenSourceExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 22d85d07f1e70ab42a7a4c25bd65e661 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Channel.cs ================================================ using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks { public static class Channel { public static Channel CreateSingleConsumerUnbounded() { return new SingleConsumerUnboundedChannel(); } } public abstract class Channel { public ChannelReader Reader { get; protected set; } public ChannelWriter Writer { get; protected set; } public static implicit operator ChannelReader(Channel channel) => channel.Reader; public static implicit operator ChannelWriter(Channel channel) => channel.Writer; } public abstract class Channel : Channel { } public abstract class ChannelReader { public abstract bool TryRead(out T item); public abstract UniTask WaitToReadAsync(CancellationToken cancellationToken = default(CancellationToken)); public abstract UniTask Completion { get; } public virtual UniTask ReadAsync(CancellationToken cancellationToken = default(CancellationToken)) { if (this.TryRead(out var item)) { return UniTask.FromResult(item); } return ReadAsyncCore(cancellationToken); } async UniTask ReadAsyncCore(CancellationToken cancellationToken = default(CancellationToken)) { if (await WaitToReadAsync(cancellationToken)) { if (TryRead(out var item)) { return item; } } throw new ChannelClosedException(); } public abstract IUniTaskAsyncEnumerable ReadAllAsync(CancellationToken cancellationToken = default(CancellationToken)); } public abstract class ChannelWriter { 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 : Channel { readonly Queue items; readonly SingleConsumerUnboundedChannelReader readerSource; UniTaskCompletionSource completedTaskSource; UniTask completedTask; Exception completionError; bool closed; public SingleConsumerUnboundedChannel() { items = new Queue(); Writer = new SingleConsumerUnboundedChannelWriter(this); readerSource = new SingleConsumerUnboundedChannelReader(this); Reader = readerSource; } sealed class SingleConsumerUnboundedChannelWriter : ChannelWriter { readonly SingleConsumerUnboundedChannel parent; public SingleConsumerUnboundedChannelWriter(SingleConsumerUnboundedChannel 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, IUniTaskSource { readonly Action CancellationCallbackDelegate = CancellationCallback; readonly SingleConsumerUnboundedChannel parent; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; UniTaskCompletionSourceCore core; internal bool isWaiting; public SingleConsumerUnboundedChannelReader(SingleConsumerUnboundedChannel 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 WaitToReadAsync(CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return UniTask.FromCanceled(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(parent.completionError); } } cancellationTokenRegistration.Dispose(); core.Reset(); isWaiting = true; this.cancellationToken = cancellationToken; if (this.cancellationToken.CanBeCanceled) { cancellationTokenRegistration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(CancellationCallbackDelegate, this); } return new UniTask(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 ReadAllAsync(CancellationToken cancellationToken = default) { return new ReadAllAsyncEnumerable(this, cancellationToken); } bool IUniTaskSource.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 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, IUniTaskAsyncEnumerator { readonly Action CancellationCallback1Delegate = CancellationCallback1; readonly Action 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 GetAsyncEnumerator(CancellationToken cancellationToken = default) { if (running) { throw new InvalidOperationException("Enumerator is already running, does not allow call GetAsyncEnumerator twice."); } if (this.cancellationToken1 != cancellationToken) { this.cancellationToken2 = cancellationToken; } if (this.cancellationToken1.CanBeCanceled) { this.cancellationTokenRegistration1 = this.cancellationToken1.RegisterWithoutCaptureExecutionContext(CancellationCallback1Delegate, this); } if (this.cancellationToken2.CanBeCanceled) { this.cancellationTokenRegistration2 = this.cancellationToken2.RegisterWithoutCaptureExecutionContext(CancellationCallback2Delegate, this); } running = true; return this; } public T Current { get { if (cacheValue) { return current; } parent.TryRead(out current); return current; } } public UniTask 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); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Channel.cs.meta ================================================ fileFormatVersion: 2 guid: 5ceb3107bbdd1f14eb39091273798360 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncMethodBuilderAttribute.cs ================================================  #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member #pragma warning disable CS0436 namespace System.Runtime.CompilerServices { internal sealed class AsyncMethodBuilderAttribute : Attribute { public Type BuilderType { get; } public AsyncMethodBuilderAttribute(Type builderType) { BuilderType = builderType; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncMethodBuilderAttribute.cs.meta ================================================ fileFormatVersion: 2 guid: 02ce354d37b10454e8376062f7cbe57a MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncUniTaskMethodBuilder.cs ================================================  #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Security; namespace Cysharp.Threading.Tasks.CompilerServices { [StructLayout(LayoutKind.Auto)] public struct AsyncUniTaskMethodBuilder { IStateMachineRunnerPromise runnerPromise; Exception ex; // 1. Static Create method. [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static AsyncUniTaskMethodBuilder Create() { return default; } // 2. TaskLike Task property. public UniTask Task { [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] get { if (runnerPromise != null) { return runnerPromise.Task; } else if (ex != null) { return UniTask.FromException(ex); } else { return UniTask.CompletedTask; } } } // 3. SetException [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void SetException(Exception exception) { if (runnerPromise == null) { ex = exception; } else { runnerPromise.SetException(exception); } } // 4. SetResult [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void SetResult() { if (runnerPromise != null) { runnerPromise.SetResult(); } } // 5. AwaitOnCompleted [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { if (runnerPromise == null) { AsyncUniTask.SetStateMachine(ref stateMachine, ref runnerPromise); } awaiter.OnCompleted(runnerPromise.MoveNext); } // 6. AwaitUnsafeOnCompleted [DebuggerHidden] [SecuritySafeCritical] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { if (runnerPromise == null) { AsyncUniTask.SetStateMachine(ref stateMachine, ref runnerPromise); } awaiter.UnsafeOnCompleted(runnerPromise.MoveNext); } // 7. Start [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Start(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { stateMachine.MoveNext(); } // 8. SetStateMachine [DebuggerHidden] public void SetStateMachine(IAsyncStateMachine stateMachine) { // don't use boxed stateMachine. } #if DEBUG || !UNITY_2018_3_OR_NEWER // Important for IDE debugger. object debuggingId; private object ObjectIdForDebugger { get { if (debuggingId == null) { debuggingId = new object(); } return debuggingId; } } #endif } [StructLayout(LayoutKind.Auto)] public struct AsyncUniTaskMethodBuilder { IStateMachineRunnerPromise runnerPromise; Exception ex; T result; // 1. Static Create method. [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static AsyncUniTaskMethodBuilder Create() { return default; } // 2. TaskLike Task property. public UniTask Task { [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] get { if (runnerPromise != null) { return runnerPromise.Task; } else if (ex != null) { return UniTask.FromException(ex); } else { return UniTask.FromResult(result); } } } // 3. SetException [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void SetException(Exception exception) { if (runnerPromise == null) { ex = exception; } else { runnerPromise.SetException(exception); } } // 4. SetResult [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void SetResult(T result) { if (runnerPromise == null) { this.result = result; } else { runnerPromise.SetResult(result); } } // 5. AwaitOnCompleted [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { if (runnerPromise == null) { AsyncUniTask.SetStateMachine(ref stateMachine, ref runnerPromise); } awaiter.OnCompleted(runnerPromise.MoveNext); } // 6. AwaitUnsafeOnCompleted [DebuggerHidden] [SecuritySafeCritical] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { if (runnerPromise == null) { AsyncUniTask.SetStateMachine(ref stateMachine, ref runnerPromise); } awaiter.UnsafeOnCompleted(runnerPromise.MoveNext); } // 7. Start [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Start(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { stateMachine.MoveNext(); } // 8. SetStateMachine [DebuggerHidden] public void SetStateMachine(IAsyncStateMachine stateMachine) { // don't use boxed stateMachine. } #if DEBUG || !UNITY_2018_3_OR_NEWER // Important for IDE debugger. object debuggingId; private object ObjectIdForDebugger { get { if (debuggingId == null) { debuggingId = new object(); } return debuggingId; } } #endif } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncUniTaskMethodBuilder.cs.meta ================================================ fileFormatVersion: 2 guid: 68d72a45afdec574ebc26e7de2c38330 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs ================================================  #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Security; namespace Cysharp.Threading.Tasks.CompilerServices { [StructLayout(LayoutKind.Auto)] public struct AsyncUniTaskVoidMethodBuilder { IStateMachineRunner runner; // 1. Static Create method. [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static AsyncUniTaskVoidMethodBuilder Create() { return default; } // 2. TaskLike Task property(void) public UniTaskVoid Task { [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return default; } } // 3. SetException [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void SetException(Exception exception) { // runner is finished, return first. if (runner != null) { #if ENABLE_IL2CPP // workaround for IL2CPP bug. PlayerLoopHelper.AddContinuation(PlayerLoopTiming.LastPostLateUpdate, runner.ReturnAction); #else runner.Return(); #endif runner = null; } UniTaskScheduler.PublishUnobservedTaskException(exception); } // 4. SetResult [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void SetResult() { // runner is finished, return. if (runner != null) { #if ENABLE_IL2CPP // workaround for IL2CPP bug. PlayerLoopHelper.AddContinuation(PlayerLoopTiming.LastPostLateUpdate, runner.ReturnAction); #else runner.Return(); #endif runner = null; } } // 5. AwaitOnCompleted [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { if (runner == null) { AsyncUniTaskVoid.SetStateMachine(ref stateMachine, ref runner); } awaiter.OnCompleted(runner.MoveNext); } // 6. AwaitUnsafeOnCompleted [DebuggerHidden] [SecuritySafeCritical] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { if (runner == null) { AsyncUniTaskVoid.SetStateMachine(ref stateMachine, ref runner); } awaiter.UnsafeOnCompleted(runner.MoveNext); } // 7. Start [DebuggerHidden] public void Start(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { stateMachine.MoveNext(); } // 8. SetStateMachine [DebuggerHidden] public void SetStateMachine(IAsyncStateMachine stateMachine) { // don't use boxed stateMachine. } #if DEBUG || !UNITY_2018_3_OR_NEWER // Important for IDE debugger. object debuggingId; private object ObjectIdForDebugger { get { if (debuggingId == null) { debuggingId = new object(); } return debuggingId; } } #endif } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs.meta ================================================ fileFormatVersion: 2 guid: e891aaac17b933a47a9d7fa3b8e1226f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/StateMachineRunner.cs ================================================ #pragma warning disable CS1591 using Cysharp.Threading.Tasks.Internal; using System; using System.Linq; using System.Diagnostics; using System.Runtime.CompilerServices; namespace Cysharp.Threading.Tasks.CompilerServices { // #ENABLE_IL2CPP in this file is to avoid bug of IL2CPP VM. // Issue is tracked on https://issuetracker.unity3d.com/issues/il2cpp-incorrect-results-when-calling-a-method-from-outside-class-in-a-struct // but currently it is labeled `Won't Fix`. internal interface IStateMachineRunner { Action MoveNext { get; } void Return(); #if ENABLE_IL2CPP Action ReturnAction { get; } #endif } internal interface IStateMachineRunnerPromise : IUniTaskSource { Action MoveNext { get; } UniTask Task { get; } void SetResult(); void SetException(Exception exception); } internal interface IStateMachineRunnerPromise : IUniTaskSource { Action MoveNext { get; } UniTask Task { get; } void SetResult(T result); void SetException(Exception exception); } internal static class StateMachineUtility { // Get AsyncStateMachine internal state to check IL2CPP bug public static int GetState(IAsyncStateMachine stateMachine) { var info = stateMachine.GetType().GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance) .First(x => x.Name.EndsWith("__state")); return (int)info.GetValue(stateMachine); } } internal sealed class AsyncUniTaskVoid : IStateMachineRunner, ITaskPoolNode>, IUniTaskSource where TStateMachine : IAsyncStateMachine { static TaskPool> pool; #if ENABLE_IL2CPP public Action ReturnAction { get; } #endif TStateMachine stateMachine; public Action MoveNext { get; } public AsyncUniTaskVoid() { MoveNext = Run; #if ENABLE_IL2CPP ReturnAction = Return; #endif } public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunner runnerFieldRef) { if (!pool.TryPop(out var result)) { result = new AsyncUniTaskVoid(); } TaskTracker.TrackActiveTask(result, 3); runnerFieldRef = result; // set runner before copied. result.stateMachine = stateMachine; // copy struct StateMachine(in release build). } static AsyncUniTaskVoid() { TaskPool.RegisterSizeGetter(typeof(AsyncUniTaskVoid), () => pool.Size); } AsyncUniTaskVoid nextNode; public ref AsyncUniTaskVoid NextNode => ref nextNode; public void Return() { TaskTracker.RemoveTracking(this); stateMachine = default; pool.TryPush(this); } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] void Run() { stateMachine.MoveNext(); } // dummy interface implementation for TaskTracker. UniTaskStatus IUniTaskSource.GetStatus(short token) { return UniTaskStatus.Pending; } UniTaskStatus IUniTaskSource.UnsafeGetStatus() { return UniTaskStatus.Pending; } void IUniTaskSource.OnCompleted(Action continuation, object state, short token) { } void IUniTaskSource.GetResult(short token) { } } internal sealed class AsyncUniTask : IStateMachineRunnerPromise, IUniTaskSource, ITaskPoolNode> where TStateMachine : IAsyncStateMachine { static TaskPool> pool; #if ENABLE_IL2CPP readonly Action returnDelegate; #endif public Action MoveNext { get; } TStateMachine stateMachine; UniTaskCompletionSourceCore core; AsyncUniTask() { MoveNext = Run; #if ENABLE_IL2CPP returnDelegate = Return; #endif } public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunnerPromise runnerPromiseFieldRef) { if (!pool.TryPop(out var result)) { result = new AsyncUniTask(); } TaskTracker.TrackActiveTask(result, 3); runnerPromiseFieldRef = result; // set runner before copied. result.stateMachine = stateMachine; // copy struct StateMachine(in release build). } AsyncUniTask nextNode; public ref AsyncUniTask NextNode => ref nextNode; static AsyncUniTask() { TaskPool.RegisterSizeGetter(typeof(AsyncUniTask), () => pool.Size); } void Return() { TaskTracker.RemoveTracking(this); core.Reset(); stateMachine = default; pool.TryPush(this); } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); stateMachine = default; return pool.TryPush(this); } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] void Run() { stateMachine.MoveNext(); } public UniTask Task { [DebuggerHidden] get { return new UniTask(this, core.Version); } } [DebuggerHidden] public void SetResult() { core.TrySetResult(AsyncUnit.Default); } [DebuggerHidden] public void SetException(Exception exception) { core.TrySetException(exception); } [DebuggerHidden] public void GetResult(short token) { try { core.GetResult(token); } finally { #if ENABLE_IL2CPP // workaround for IL2CPP bug. PlayerLoopHelper.AddContinuation(PlayerLoopTiming.LastPostLateUpdate, returnDelegate); #else TryReturn(); #endif } } [DebuggerHidden] public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } [DebuggerHidden] public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } [DebuggerHidden] public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } internal sealed class AsyncUniTask : IStateMachineRunnerPromise, IUniTaskSource, ITaskPoolNode> where TStateMachine : IAsyncStateMachine { static TaskPool> pool; #if ENABLE_IL2CPP readonly Action returnDelegate; #endif public Action MoveNext { get; } TStateMachine stateMachine; UniTaskCompletionSourceCore core; AsyncUniTask() { MoveNext = Run; #if ENABLE_IL2CPP returnDelegate = Return; #endif } public static void SetStateMachine(ref TStateMachine stateMachine, ref IStateMachineRunnerPromise runnerPromiseFieldRef) { if (!pool.TryPop(out var result)) { result = new AsyncUniTask(); } TaskTracker.TrackActiveTask(result, 3); runnerPromiseFieldRef = result; // set runner before copied. result.stateMachine = stateMachine; // copy struct StateMachine(in release build). } AsyncUniTask nextNode; public ref AsyncUniTask NextNode => ref nextNode; static AsyncUniTask() { TaskPool.RegisterSizeGetter(typeof(AsyncUniTask), () => pool.Size); } void Return() { TaskTracker.RemoveTracking(this); core.Reset(); stateMachine = default; pool.TryPush(this); } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); stateMachine = default; return pool.TryPush(this); } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] void Run() { // UnityEngine.Debug.Log($"MoveNext State:" + StateMachineUtility.GetState(stateMachine)); stateMachine.MoveNext(); } public UniTask Task { [DebuggerHidden] get { return new UniTask(this, core.Version); } } [DebuggerHidden] public void SetResult(T result) { core.TrySetResult(result); } [DebuggerHidden] public void SetException(Exception exception) { core.TrySetException(exception); } [DebuggerHidden] public T GetResult(short token) { try { return core.GetResult(token); } finally { #if ENABLE_IL2CPP // workaround for IL2CPP bug. PlayerLoopHelper.AddContinuation(PlayerLoopTiming.LastPostLateUpdate, returnDelegate); #else TryReturn(); #endif } } [DebuggerHidden] void IUniTaskSource.GetResult(short token) { GetResult(token); } [DebuggerHidden] public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } [DebuggerHidden] public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } [DebuggerHidden] public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices/StateMachineRunner.cs.meta ================================================ fileFormatVersion: 2 guid: 98649642833cabf44a9dc060ce4c84a1 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/CompilerServices.meta ================================================ fileFormatVersion: 2 guid: 64b064347ca7a404494a996b072e2e29 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/EnumerableAsyncExtensions.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; namespace Cysharp.Threading.Tasks { public static class EnumerableAsyncExtensions { // overload resolver - .Select(async x => { }) : IEnumerable> public static IEnumerable Select(this IEnumerable source, Func selector) { return System.Linq.Enumerable.Select(source, selector); } public static IEnumerable> Select(this IEnumerable source, Func> selector) { return System.Linq.Enumerable.Select(source, selector); } public static IEnumerable Select(this IEnumerable source, Func selector) { return System.Linq.Enumerable.Select(source, selector); } public static IEnumerable> Select(this IEnumerable source, Func> selector) { return System.Linq.Enumerable.Select(source, selector); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/EnumerableAsyncExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: ff50260d74bd54c4b92cf99895549445 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/EnumeratorAsyncExtensions.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections; using System.Reflection; using System.Runtime.ExceptionServices; using System.Threading; using Cysharp.Threading.Tasks.Internal; using UnityEngine; namespace Cysharp.Threading.Tasks { public static class EnumeratorAsyncExtensions { public static UniTask.Awaiter GetAwaiter(this T enumerator) where T : IEnumerator { var e = (IEnumerator)enumerator; Error.ThrowArgumentNullException(e, nameof(enumerator)); return new UniTask(EnumeratorPromise.Create(e, PlayerLoopTiming.Update, CancellationToken.None, out var token), token).GetAwaiter(); } public static UniTask WithCancellation(this IEnumerator enumerator, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(enumerator, nameof(enumerator)); return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, cancellationToken, out var token), token); } public static UniTask ToUniTask(this IEnumerator enumerator, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken)) { Error.ThrowArgumentNullException(enumerator, nameof(enumerator)); return new UniTask(EnumeratorPromise.Create(enumerator, timing, cancellationToken, out var token), token); } public static UniTask ToUniTask(this IEnumerator enumerator, MonoBehaviour coroutineRunner) { var source = AutoResetUniTaskCompletionSource.Create(); coroutineRunner.StartCoroutine(Core(enumerator, coroutineRunner, source)); return source.Task; } static IEnumerator Core(IEnumerator inner, MonoBehaviour coroutineRunner, AutoResetUniTaskCompletionSource source) { yield return coroutineRunner.StartCoroutine(inner); source.TrySetResult(); } sealed class EnumeratorPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; EnumeratorPromise nextNode; public ref EnumeratorPromise NextNode => ref nextNode; static EnumeratorPromise() { TaskPool.RegisterSizeGetter(typeof(EnumeratorPromise), () => pool.Size); } IEnumerator innerEnumerator; CancellationToken cancellationToken; int initialFrame; bool loopRunning; bool calledGetResult; UniTaskCompletionSourceCore core; EnumeratorPromise() { } public static IUniTaskSource Create(IEnumerator innerEnumerator, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new EnumeratorPromise(); } TaskTracker.TrackActiveTask(result, 3); result.innerEnumerator = ConsumeEnumerator(innerEnumerator); result.cancellationToken = cancellationToken; result.loopRunning = true; result.calledGetResult = false; result.initialFrame = -1; token = result.core.Version; // run immediately. if (result.MoveNext()) { PlayerLoopHelper.AddAction(timing, result); } return result; } public void GetResult(short token) { try { calledGetResult = true; core.GetResult(token); } finally { if (!loopRunning) { TryReturn(); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (calledGetResult) { loopRunning = false; TryReturn(); return false; } if (innerEnumerator == null) // invalid status, returned but loop running? { return false; } if (cancellationToken.IsCancellationRequested) { loopRunning = false; core.TrySetCanceled(cancellationToken); return false; } if (initialFrame == -1) { // Time can not touch in threadpool. if (PlayerLoopHelper.IsMainThread) { initialFrame = Time.frameCount; } } else if (initialFrame == Time.frameCount) { return true; // already executed in first frame, skip. } try { if (innerEnumerator.MoveNext()) { return true; } } catch (Exception ex) { loopRunning = false; core.TrySetException(ex); return false; } loopRunning = false; core.TrySetResult(null); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); innerEnumerator = default; cancellationToken = default; return pool.TryPush(this); } // Unwrap YieldInstructions static IEnumerator ConsumeEnumerator(IEnumerator enumerator) { while (enumerator.MoveNext()) { var current = enumerator.Current; if (current == null) { yield return null; } else if (current is CustomYieldInstruction cyi) { // WWW, WaitForSecondsRealtime while (cyi.keepWaiting) { yield return null; } } else if (current is YieldInstruction) { IEnumerator innerCoroutine = null; switch (current) { case AsyncOperation ao: innerCoroutine = UnwrapWaitAsyncOperation(ao); break; case WaitForSeconds wfs: innerCoroutine = UnwrapWaitForSeconds(wfs); break; } if (innerCoroutine != null) { while (innerCoroutine.MoveNext()) { yield return null; } } else { goto WARN; } } else if (current is IEnumerator e3) { var e4 = ConsumeEnumerator(e3); while (e4.MoveNext()) { yield return null; } } else { goto WARN; } continue; WARN: // WaitForEndOfFrame, WaitForFixedUpdate, others. UnityEngine.Debug.LogWarning($"yield {current.GetType().Name} is not supported on await IEnumerator or IEnumerator.ToUniTask(), please use ToUniTask(MonoBehaviour coroutineRunner) instead."); yield return null; } } static readonly FieldInfo waitForSeconds_Seconds = typeof(WaitForSeconds).GetField("m_Seconds", BindingFlags.Instance | BindingFlags.GetField | BindingFlags.NonPublic); static IEnumerator UnwrapWaitForSeconds(WaitForSeconds waitForSeconds) { var second = (float)waitForSeconds_Seconds.GetValue(waitForSeconds); var elapsed = 0.0f; while (true) { yield return null; elapsed += Time.deltaTime; if (elapsed >= second) { break; } }; } static IEnumerator UnwrapWaitAsyncOperation(AsyncOperation asyncOperation) { while (!asyncOperation.isDone) { yield return null; } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/EnumeratorAsyncExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: bc661232f11e4a741af54ba1c175d5ee MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/ExceptionExtensions.cs ================================================  using System; namespace Cysharp.Threading.Tasks { public static class ExceptionExtensions { public static bool IsOperationCanceledException(this Exception exception) { return exception is OperationCanceledException; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/ExceptionExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 930800098504c0d46958ce23a0495202 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables/AddressablesAsyncExtensions.cs ================================================ // asmdef Version Defines, enabled when com.unity.addressables is imported. #if UNITASK_ADDRESSABLE_SUPPORT using Cysharp.Threading.Tasks.Internal; using System; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Threading; using UnityEngine.AddressableAssets; using UnityEngine.ResourceManagement.AsyncOperations; namespace Cysharp.Threading.Tasks { public static class AddressablesAsyncExtensions { #region AsyncOperationHandle public static UniTask.Awaiter GetAwaiter(this AsyncOperationHandle handle) { return ToUniTask(handle).GetAwaiter(); } public static UniTask WithCancellation(this AsyncOperationHandle handle, CancellationToken cancellationToken, bool cancelImmediately = false, bool autoReleaseWhenCanceled = false) { return ToUniTask(handle, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately, autoReleaseWhenCanceled: autoReleaseWhenCanceled); } public static UniTask ToUniTask(this AsyncOperationHandle handle, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false, bool autoReleaseWhenCanceled = false) { if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (!handle.IsValid()) { // autoReleaseHandle:true handle is invalid(immediately internal handle == null) so return completed. return UniTask.CompletedTask; } if (handle.IsDone) { if (handle.Status == AsyncOperationStatus.Failed) { return UniTask.FromException(handle.OperationException); } return UniTask.CompletedTask; } return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellationToken, cancelImmediately, autoReleaseWhenCanceled, out var token), token); } public struct AsyncOperationHandleAwaiter : ICriticalNotifyCompletion { AsyncOperationHandle handle; Action continuationAction; public AsyncOperationHandleAwaiter(AsyncOperationHandle handle) { this.handle = handle; this.continuationAction = null; } public bool IsCompleted => handle.IsDone; public void GetResult() { if (continuationAction != null) { handle.Completed -= continuationAction; continuationAction = null; } if (handle.Status == AsyncOperationStatus.Failed) { var e = handle.OperationException; handle = default; ExceptionDispatchInfo.Capture(e).Throw(); } var result = handle.Result; handle = default; } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction); continuationAction = PooledDelegate.Create(continuation); handle.Completed += continuationAction; } } sealed class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; AsyncOperationHandleConfiguredSource nextNode; public ref AsyncOperationHandleConfiguredSource NextNode => ref nextNode; static AsyncOperationHandleConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource), () => pool.Size); } readonly Action completedCallback; AsyncOperationHandle handle; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; IProgress progress; bool autoReleaseWhenCanceled; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; AsyncOperationHandleConfiguredSource() { completedCallback = HandleCompleted; } public static IUniTaskSource Create(AsyncOperationHandle handle, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, bool autoReleaseWhenCanceled, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AsyncOperationHandleConfiguredSource(); } result.handle = handle; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.autoReleaseWhenCanceled = autoReleaseWhenCanceled; result.completed = false; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (AsyncOperationHandleConfiguredSource)state; if (promise.autoReleaseWhenCanceled && promise.handle.IsValid()) { Addressables.Release(promise.handle); } promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); handle.Completed += result.completedCallback; token = result.core.Version; return result; } void HandleCompleted(AsyncOperationHandle _) { if (handle.IsValid()) { handle.Completed -= completedCallback; } if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { if (autoReleaseWhenCanceled && handle.IsValid()) { Addressables.Release(handle); } core.TrySetCanceled(cancellationToken); } else if (handle.Status == AsyncOperationStatus.Failed) { core.TrySetException(handle.OperationException); } else { core.TrySetResult(AsyncUnit.Default); } } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (completed) { return false; } if (cancellationToken.IsCancellationRequested) { completed = true; if (autoReleaseWhenCanceled && handle.IsValid()) { Addressables.Release(handle); } core.TrySetCanceled(cancellationToken); return false; } if (progress != null && handle.IsValid()) { progress.Report(handle.GetDownloadStatus().Percent); } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); handle = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); return pool.TryPush(this); } } #endregion #region AsyncOperationHandle_T public static UniTask.Awaiter GetAwaiter(this AsyncOperationHandle handle) { return ToUniTask(handle).GetAwaiter(); } public static UniTask WithCancellation(this AsyncOperationHandle handle, CancellationToken cancellationToken, bool cancelImmediately = false, bool autoReleaseWhenCanceled = false) { return ToUniTask(handle, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately, autoReleaseWhenCanceled: autoReleaseWhenCanceled); } public static UniTask ToUniTask(this AsyncOperationHandle handle, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false, bool autoReleaseWhenCanceled = false) { if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (!handle.IsValid()) { throw new Exception("Attempting to use an invalid operation handle"); } if (handle.IsDone) { if (handle.Status == AsyncOperationStatus.Failed) { return UniTask.FromException(handle.OperationException); } return UniTask.FromResult(handle.Result); } return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellationToken, cancelImmediately, autoReleaseWhenCanceled, out var token), token); } sealed class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode> { static TaskPool> pool; AsyncOperationHandleConfiguredSource nextNode; public ref AsyncOperationHandleConfiguredSource NextNode => ref nextNode; static AsyncOperationHandleConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AsyncOperationHandleConfiguredSource), () => pool.Size); } readonly Action> completedCallback; AsyncOperationHandle handle; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; IProgress progress; bool autoReleaseWhenCanceled; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; AsyncOperationHandleConfiguredSource() { completedCallback = HandleCompleted; } public static IUniTaskSource Create(AsyncOperationHandle handle, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, bool autoReleaseWhenCanceled, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AsyncOperationHandleConfiguredSource(); } result.handle = handle; result.cancellationToken = cancellationToken; result.completed = false; result.progress = progress; result.autoReleaseWhenCanceled = autoReleaseWhenCanceled; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (AsyncOperationHandleConfiguredSource)state; if (promise.autoReleaseWhenCanceled && promise.handle.IsValid()) { Addressables.Release(promise.handle); } promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); handle.Completed += result.completedCallback; token = result.core.Version; return result; } void HandleCompleted(AsyncOperationHandle argHandle) { if (handle.IsValid()) { handle.Completed -= completedCallback; } if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { if (autoReleaseWhenCanceled && handle.IsValid()) { Addressables.Release(handle); } core.TrySetCanceled(cancellationToken); } else if (argHandle.Status == AsyncOperationStatus.Failed) { core.TrySetException(argHandle.OperationException); } else { core.TrySetResult(argHandle.Result); } } public T GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (completed) { return false; } if (cancellationToken.IsCancellationRequested) { completed = true; if (autoReleaseWhenCanceled && handle.IsValid()) { Addressables.Release(handle); } core.TrySetCanceled(cancellationToken); return false; } if (progress != null && handle.IsValid()) { progress.Report(handle.GetDownloadStatus().Percent); } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); handle = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); return pool.TryPush(this); } } #endregion } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables/AddressablesAsyncExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 3dc6441f9094f354b931dc3c79fb99e5 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables/UniTask.Addressables.asmdef ================================================ { "name": "UniTask.Addressables", "references": [ "UniTask", "Unity.ResourceManager", "Unity.Addressables" ], "includePlatforms": [], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": false, "precompiledReferences": [], "autoReferenced": true, "defineConstraints": [], "versionDefines": [ { "name": "com.unity.addressables", "expression": "", "define": "UNITASK_ADDRESSABLE_SUPPORT" }, { "name": "com.unity.addressables.cn", "expression": "", "define": "UNITASK_ADDRESSABLE_SUPPORT" } ], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables/UniTask.Addressables.asmdef.meta ================================================ fileFormatVersion: 2 guid: 593a5b492d29ac6448b1ebf7f035ef33 AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/Addressables.meta ================================================ fileFormatVersion: 2 guid: a5b9231662e24c942b544bd85d4b39cb folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween/DOTweenAsyncExtensions.cs ================================================ // asmdef Version Defines, enabled when com.demigiant.dotween is imported. #if UNITASK_DOTWEEN_SUPPORT using Cysharp.Threading.Tasks.Internal; using DG.Tweening; using System; using System.Collections.Concurrent; using System.Runtime.CompilerServices; using System.Threading; namespace Cysharp.Threading.Tasks { public enum TweenCancelBehaviour { Kill, KillWithCompleteCallback, Complete, CompleteWithSequenceCallback, CancelAwait, // AndCancelAwait KillAndCancelAwait, KillWithCompleteCallbackAndCancelAwait, CompleteAndCancelAwait, CompleteWithSequenceCallbackAndCancelAwait } public static class DOTweenAsyncExtensions { enum CallbackType { Kill, Complete, Pause, Play, Rewind, StepComplete } public static TweenAwaiter GetAwaiter(this Tween tween) { return new TweenAwaiter(tween); } public static UniTask WithCancellation(this Tween tween, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(tween, nameof(tween)); if (!tween.IsActive()) return UniTask.CompletedTask; return new UniTask(TweenConfiguredSource.Create(tween, TweenCancelBehaviour.Kill, cancellationToken, CallbackType.Kill, out var token), token); } public static UniTask ToUniTask(this Tween tween, TweenCancelBehaviour tweenCancelBehaviour = TweenCancelBehaviour.Kill, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(tween, nameof(tween)); if (!tween.IsActive()) return UniTask.CompletedTask; return new UniTask(TweenConfiguredSource.Create(tween, tweenCancelBehaviour, cancellationToken, CallbackType.Kill, out var token), token); } public static UniTask AwaitForComplete(this Tween tween, TweenCancelBehaviour tweenCancelBehaviour = TweenCancelBehaviour.Kill, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(tween, nameof(tween)); if (!tween.IsActive()) return UniTask.CompletedTask; return new UniTask(TweenConfiguredSource.Create(tween, tweenCancelBehaviour, cancellationToken, CallbackType.Complete, out var token), token); } public static UniTask AwaitForPause(this Tween tween, TweenCancelBehaviour tweenCancelBehaviour = TweenCancelBehaviour.Kill, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(tween, nameof(tween)); if (!tween.IsActive()) return UniTask.CompletedTask; return new UniTask(TweenConfiguredSource.Create(tween, tweenCancelBehaviour, cancellationToken, CallbackType.Pause, out var token), token); } public static UniTask AwaitForPlay(this Tween tween, TweenCancelBehaviour tweenCancelBehaviour = TweenCancelBehaviour.Kill, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(tween, nameof(tween)); if (!tween.IsActive()) return UniTask.CompletedTask; return new UniTask(TweenConfiguredSource.Create(tween, tweenCancelBehaviour, cancellationToken, CallbackType.Play, out var token), token); } public static UniTask AwaitForRewind(this Tween tween, TweenCancelBehaviour tweenCancelBehaviour = TweenCancelBehaviour.Kill, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(tween, nameof(tween)); if (!tween.IsActive()) return UniTask.CompletedTask; return new UniTask(TweenConfiguredSource.Create(tween, tweenCancelBehaviour, cancellationToken, CallbackType.Rewind, out var token), token); } public static UniTask AwaitForStepComplete(this Tween tween, TweenCancelBehaviour tweenCancelBehaviour = TweenCancelBehaviour.Kill, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(tween, nameof(tween)); if (!tween.IsActive()) return UniTask.CompletedTask; return new UniTask(TweenConfiguredSource.Create(tween, tweenCancelBehaviour, cancellationToken, CallbackType.StepComplete, out var token), token); } public struct TweenAwaiter : ICriticalNotifyCompletion { readonly Tween tween; // killed(non active) as completed. public bool IsCompleted => !tween.IsActive(); public TweenAwaiter(Tween tween) { this.tween = tween; } public TweenAwaiter GetAwaiter() { return this; } public void GetResult() { } public void OnCompleted(System.Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(System.Action continuation) { // onKill is called after OnCompleted, both Complete(false/true) and Kill(false/true). tween.onKill = PooledTweenCallback.Create(continuation); } } sealed class TweenConfiguredSource : IUniTaskSource, ITaskPoolNode { static TaskPool pool; TweenConfiguredSource nextNode; public ref TweenConfiguredSource NextNode => ref nextNode; static TweenConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(TweenConfiguredSource), () => pool.Size); } readonly TweenCallback onCompleteCallbackDelegate; Tween tween; TweenCancelBehaviour cancelBehaviour; CancellationToken cancellationToken; CancellationTokenRegistration cancellationRegistration; CallbackType callbackType; bool canceled; TweenCallback originalCompleteAction; UniTaskCompletionSourceCore core; TweenConfiguredSource() { onCompleteCallbackDelegate = OnCompleteCallbackDelegate; } public static IUniTaskSource Create(Tween tween, TweenCancelBehaviour cancelBehaviour, CancellationToken cancellationToken, CallbackType callbackType, out short token) { if (cancellationToken.IsCancellationRequested) { DoCancelBeforeCreate(tween, cancelBehaviour); return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new TweenConfiguredSource(); } result.tween = tween; result.cancelBehaviour = cancelBehaviour; result.cancellationToken = cancellationToken; result.callbackType = callbackType; result.canceled = false; switch (callbackType) { case CallbackType.Kill: result.originalCompleteAction = tween.onKill; tween.onKill = result.onCompleteCallbackDelegate; break; case CallbackType.Complete: result.originalCompleteAction = tween.onComplete; tween.onComplete = result.onCompleteCallbackDelegate; break; case CallbackType.Pause: result.originalCompleteAction = tween.onPause; tween.onPause = result.onCompleteCallbackDelegate; break; case CallbackType.Play: result.originalCompleteAction = tween.onPlay; tween.onPlay = result.onCompleteCallbackDelegate; break; case CallbackType.Rewind: result.originalCompleteAction = tween.onRewind; tween.onRewind = result.onCompleteCallbackDelegate; break; case CallbackType.StepComplete: result.originalCompleteAction = tween.onStepComplete; tween.onStepComplete = result.onCompleteCallbackDelegate; break; default: break; } if (result.originalCompleteAction == result.onCompleteCallbackDelegate) { result.originalCompleteAction = null; } if (cancellationToken.CanBeCanceled) { result.cancellationRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(x => { var source = (TweenConfiguredSource)x; switch (source.cancelBehaviour) { case TweenCancelBehaviour.Kill: default: source.tween.Kill(false); break; case TweenCancelBehaviour.KillAndCancelAwait: source.canceled = true; source.tween.Kill(false); break; case TweenCancelBehaviour.KillWithCompleteCallback: source.tween.Kill(true); break; case TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait: source.canceled = true; source.tween.Kill(true); break; case TweenCancelBehaviour.Complete: source.tween.Complete(false); break; case TweenCancelBehaviour.CompleteAndCancelAwait: source.canceled = true; source.tween.Complete(false); break; case TweenCancelBehaviour.CompleteWithSequenceCallback: source.tween.Complete(true); break; case TweenCancelBehaviour.CompleteWithSequenceCallbackAndCancelAwait: source.canceled = true; source.tween.Complete(true); break; case TweenCancelBehaviour.CancelAwait: source.RestoreOriginalCallback(); source.core.TrySetCanceled(source.cancellationToken); break; } }, result); } TaskTracker.TrackActiveTask(result, 3); token = result.core.Version; return result; } void OnCompleteCallbackDelegate() { if (cancellationToken.IsCancellationRequested) { if (this.cancelBehaviour == TweenCancelBehaviour.KillAndCancelAwait || this.cancelBehaviour == TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait || this.cancelBehaviour == TweenCancelBehaviour.CompleteAndCancelAwait || this.cancelBehaviour == TweenCancelBehaviour.CompleteWithSequenceCallbackAndCancelAwait || this.cancelBehaviour == TweenCancelBehaviour.CancelAwait) { canceled = true; } } if (canceled) { core.TrySetCanceled(cancellationToken); } else { originalCompleteAction?.Invoke(); core.TrySetResult(AsyncUnit.Default); } } static void DoCancelBeforeCreate(Tween tween, TweenCancelBehaviour tweenCancelBehaviour) { switch (tweenCancelBehaviour) { case TweenCancelBehaviour.Kill: default: tween.Kill(false); break; case TweenCancelBehaviour.KillAndCancelAwait: tween.Kill(false); break; case TweenCancelBehaviour.KillWithCompleteCallback: tween.Kill(true); break; case TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait: tween.Kill(true); break; case TweenCancelBehaviour.Complete: tween.Complete(false); break; case TweenCancelBehaviour.CompleteAndCancelAwait: tween.Complete(false); break; case TweenCancelBehaviour.CompleteWithSequenceCallback: tween.Complete(true); break; case TweenCancelBehaviour.CompleteWithSequenceCallbackAndCancelAwait: tween.Complete(true); break; case TweenCancelBehaviour.CancelAwait: break; } } public void GetResult(short token) { try { core.GetResult(token); } finally { TryReturn(); } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); cancellationRegistration.Dispose(); RestoreOriginalCallback(); tween = default; cancellationToken = default; originalCompleteAction = default; return pool.TryPush(this); } void RestoreOriginalCallback() { switch (callbackType) { case CallbackType.Kill: tween.onKill = originalCompleteAction; break; case CallbackType.Complete: tween.onComplete = originalCompleteAction; break; case CallbackType.Pause: tween.onPause = originalCompleteAction; break; case CallbackType.Play: tween.onPlay = originalCompleteAction; break; case CallbackType.Rewind: tween.onRewind = originalCompleteAction; break; case CallbackType.StepComplete: tween.onStepComplete = originalCompleteAction; break; default: break; } } } } sealed class PooledTweenCallback { static readonly ConcurrentQueue pool = new ConcurrentQueue(); readonly TweenCallback runDelegate; Action continuation; PooledTweenCallback() { runDelegate = Run; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static TweenCallback Create(Action continuation) { if (!pool.TryDequeue(out var item)) { item = new PooledTweenCallback(); } item.continuation = continuation; return item.runDelegate; } [MethodImpl(MethodImplOptions.AggressiveInlining)] void Run() { var call = continuation; continuation = null; if (call != null) { pool.Enqueue(this); call.Invoke(); } } } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween/DOTweenAsyncExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 1f448d5bc5b232e4f98d89d5d1832e8e MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween/UniTask.DOTween.asmdef ================================================ { "name": "UniTask.DOTween", "references": [ "UniTask", "DOTween.Modules" ], "includePlatforms": [], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": false, "precompiledReferences": [], "autoReferenced": true, "defineConstraints": [], "versionDefines": [ { "name": "com.demigiant.dotween", "expression": "", "define": "UNITASK_DOTWEEN_SUPPORT" } ], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween/UniTask.DOTween.asmdef.meta ================================================ fileFormatVersion: 2 guid: 029c1c1b674aaae47a6841a0b89ad80e AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween.meta ================================================ fileFormatVersion: 2 guid: 25cb2f742bfeb1d48a4e65d3140b955d folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.InputField.cs ================================================ #if UNITASK_TEXTMESHPRO_SUPPORT using System; using System.Threading; using TMPro; namespace Cysharp.Threading.Tasks { public static partial class TextMeshProAsyncExtensions { public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onValueChanged, cancellationToken, false); } public static UniTask OnValueChangedAsync(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnValueChangedAsync(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onValueChanged, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this TMP_InputField inputField) { return new UnityEventHandlerAsyncEnumerable(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(inputField.onValueChanged, cancellationToken); } public static IAsyncEndEditEventHandler GetAsyncEndEditEventHandler(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncEndEditEventHandler GetAsyncEndEditEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onEndEdit, cancellationToken, false); } public static UniTask OnEndEditAsync(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnEndEditAsync(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onEndEdit, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnEndEditAsAsyncEnumerable(this TMP_InputField inputField) { return new UnityEventHandlerAsyncEnumerable(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnEndEditAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(inputField.onEndEdit, cancellationToken); } public static IAsyncEndTextSelectionEventHandler<(string, int, int)> GetAsyncEndTextSelectionEventHandler(this TMP_InputField inputField) { return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncEndTextSelectionEventHandler<(string, int, int)> GetAsyncEndTextSelectionEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), cancellationToken, false); } public static UniTask<(string, int, int)> OnEndTextSelectionAsync(this TMP_InputField inputField) { return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask<(string, int, int)> OnEndTextSelectionAsync(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable<(string, int, int)> OnEndTextSelectionAsAsyncEnumerable(this TMP_InputField inputField) { return new UnityEventHandlerAsyncEnumerable<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable<(string, int, int)> OnEndTextSelectionAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable<(string, int, int)>(new TextSelectionEventConverter(inputField.onEndTextSelection), cancellationToken); } public static IAsyncTextSelectionEventHandler<(string, int, int)> GetAsyncTextSelectionEventHandler(this TMP_InputField inputField) { return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncTextSelectionEventHandler<(string, int, int)> GetAsyncTextSelectionEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), cancellationToken, false); } public static UniTask<(string, int, int)> OnTextSelectionAsync(this TMP_InputField inputField) { return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask<(string, int, int)> OnTextSelectionAsync(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable<(string, int, int)> OnTextSelectionAsAsyncEnumerable(this TMP_InputField inputField) { return new UnityEventHandlerAsyncEnumerable<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable<(string, int, int)> OnTextSelectionAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable<(string, int, int)>(new TextSelectionEventConverter(inputField.onTextSelection), cancellationToken); } public static IAsyncDeselectEventHandler GetAsyncDeselectEventHandler(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onDeselect, inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncDeselectEventHandler GetAsyncDeselectEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onDeselect, cancellationToken, false); } public static UniTask OnDeselectAsync(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onDeselect, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnDeselectAsync(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onDeselect, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnDeselectAsAsyncEnumerable(this TMP_InputField inputField) { return new UnityEventHandlerAsyncEnumerable(inputField.onDeselect, inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnDeselectAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(inputField.onDeselect, cancellationToken); } public static IAsyncSelectEventHandler GetAsyncSelectEventHandler(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onSelect, inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncSelectEventHandler GetAsyncSelectEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onSelect, cancellationToken, false); } public static UniTask OnSelectAsync(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onSelect, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnSelectAsync(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onSelect, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnSelectAsAsyncEnumerable(this TMP_InputField inputField) { return new UnityEventHandlerAsyncEnumerable(inputField.onSelect, inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnSelectAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(inputField.onSelect, cancellationToken); } public static IAsyncSubmitEventHandler GetAsyncSubmitEventHandler(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onSubmit, inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncSubmitEventHandler GetAsyncSubmitEventHandler(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onSubmit, cancellationToken, false); } public static UniTask OnSubmitAsync(this TMP_InputField inputField) { return new AsyncUnityEventHandler(inputField.onSubmit, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnSubmitAsync(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onSubmit, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnSubmitAsAsyncEnumerable(this TMP_InputField inputField) { return new UnityEventHandlerAsyncEnumerable(inputField.onSubmit, inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnSubmitAsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(inputField.onSubmit, cancellationToken); } } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.InputField.cs.meta ================================================ fileFormatVersion: 2 guid: 79f4f2475e0b2c44e97ed1dee760627b MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.InputField.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> <# var handlers = new (string name, string type)[] { ("ValueChanged", "string"), ("EndEdit", "string"), ("EndTextSelection", "(string, int, int)"), ("TextSelection", "(string, int, int)"), ("Deselect", "string"), ("Select", "string"), ("Submit", "string"), }; Func shouldConvert = x => x.EndsWith("TextSelection"); Func eventName = x => shouldConvert(x) ? $"new TextSelectionEventConverter(inputField.on{x})" : $"inputField.on{x}"; #> #if UNITASK_TEXTMESHPRO_SUPPORT using System; using System.Threading; using TMPro; namespace Cysharp.Threading.Tasks { public static partial class TextMeshProAsyncExtensions { <# foreach(var (name, type) in handlers) { #> public static IAsync<#= (name) #>EventHandler<<#= type #>> GetAsync<#= (name) #>EventHandler(this TMP_InputField inputField) { return new AsyncUnityEventHandler<<#= type #>>(<#= eventName(name) #>, inputField.GetCancellationTokenOnDestroy(), false); } public static IAsync<#= (name) #>EventHandler<<#= type #>> GetAsync<#= (name) #>EventHandler(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler<<#= type #>>(<#= eventName(name) #>, cancellationToken, false); } public static UniTask<<#= type #>> On<#= (name) #>Async(this TMP_InputField inputField) { return new AsyncUnityEventHandler<<#= type #>>(<#= eventName(name) #>, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask<<#= type #>> On<#= (name) #>Async(this TMP_InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler<<#= type #>>(<#= eventName(name) #>, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable<<#= type #>> On<#= (name) #>AsAsyncEnumerable(this TMP_InputField inputField) { return new UnityEventHandlerAsyncEnumerable<<#= type #>>(<#= eventName(name) #>, inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable<<#= type #>> On<#= (name) #>AsAsyncEnumerable(this TMP_InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable<<#= type #>>(<#= eventName(name) #>, cancellationToken); } <# } #> } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.InputField.tt.meta ================================================ fileFormatVersion: 2 guid: e9bb9fc551a975d44a7180e022a2debe DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.cs ================================================ #if UNITASK_TEXTMESHPRO_SUPPORT using System; using System.Threading; using TMPro; using UnityEngine.Events; namespace Cysharp.Threading.Tasks { public static partial class TextMeshProAsyncExtensions { // -> Text public static void BindTo(this IUniTaskAsyncEnumerable source, TMP_Text text, bool rebindOnError = true) { BindToCore(source, text, text.GetCancellationTokenOnDestroy(), rebindOnError).Forget(); } public static void BindTo(this IUniTaskAsyncEnumerable source, TMP_Text text, CancellationToken cancellationToken, bool rebindOnError = true) { BindToCore(source, text, cancellationToken, rebindOnError).Forget(); } static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable source, TMP_Text text, CancellationToken cancellationToken, bool rebindOnError) { var repeat = false; BIND_AGAIN: var e = source.GetAsyncEnumerator(cancellationToken); try { while (true) { bool moveNext; try { moveNext = await e.MoveNextAsync(); repeat = false; } catch (Exception ex) { if (ex is OperationCanceledException) return; if (rebindOnError && !repeat) { repeat = true; goto BIND_AGAIN; } else { throw; } } if (!moveNext) return; text.text = e.Current; } } finally { if (e != null) { await e.DisposeAsync(); } } } // -> Text public static void BindTo(this IUniTaskAsyncEnumerable source, TMP_Text text, bool rebindOnError = true) { BindToCore(source, text, text.GetCancellationTokenOnDestroy(), rebindOnError).Forget(); } public static void BindTo(this IUniTaskAsyncEnumerable source, TMP_Text text, CancellationToken cancellationToken, bool rebindOnError = true) { BindToCore(source, text, cancellationToken, rebindOnError).Forget(); } public static void BindTo(this AsyncReactiveProperty source, TMP_Text text, bool rebindOnError = true) { BindToCore(source, text, text.GetCancellationTokenOnDestroy(), rebindOnError).Forget(); } static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable source, TMP_Text text, CancellationToken cancellationToken, bool rebindOnError) { var repeat = false; BIND_AGAIN: var e = source.GetAsyncEnumerator(cancellationToken); try { while (true) { bool moveNext; try { moveNext = await e.MoveNextAsync(); repeat = false; } catch (Exception ex) { if (ex is OperationCanceledException) return; if (rebindOnError && !repeat) { repeat = true; goto BIND_AGAIN; } else { throw; } } if (!moveNext) return; text.text = e.Current.ToString(); } } finally { if (e != null) { await e.DisposeAsync(); } } } } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/TextMeshProAsyncExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: b6ba480edafb67d4e91bb10feb64fae5 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/UniTask.TextMeshPro.asmdef ================================================ { "name": "UniTask.TextMeshPro", "references": [ "UniTask", "Unity.TextMeshPro" ], "includePlatforms": [], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": false, "precompiledReferences": [], "autoReferenced": true, "defineConstraints": [], "versionDefines": [ { "name": "com.unity.textmeshpro", "expression": "", "define": "UNITASK_TEXTMESHPRO_SUPPORT" }, { "name": "com.unity.ugui", "expression": "2.0.0", "define": "UNITASK_TEXTMESHPRO_SUPPORT" } ], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro/UniTask.TextMeshPro.asmdef.meta ================================================ fileFormatVersion: 2 guid: dc47925d1a5fa2946bdd37746b2b5d48 AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External/TextMeshPro.meta ================================================ fileFormatVersion: 2 guid: f89da606bde9a4e4e94ae1189a029887 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/External.meta ================================================ fileFormatVersion: 2 guid: a3e874acee8398745b1dc3eddac09eaa folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/IUniTaskAsyncEnumerable.cs ================================================ using System; using System.Collections.Generic; using System.Runtime.InteropServices; using System.Threading; namespace Cysharp.Threading.Tasks { public interface IUniTaskAsyncEnumerable { IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default); } public interface IUniTaskAsyncEnumerator : IUniTaskAsyncDisposable { T Current { get; } UniTask MoveNextAsync(); } public interface IUniTaskAsyncDisposable { UniTask DisposeAsync(); } public interface IUniTaskOrderedAsyncEnumerable : IUniTaskAsyncEnumerable { IUniTaskOrderedAsyncEnumerable CreateOrderedEnumerable(Func keySelector, IComparer comparer, bool descending); IUniTaskOrderedAsyncEnumerable CreateOrderedEnumerable(Func> keySelector, IComparer comparer, bool descending); IUniTaskOrderedAsyncEnumerable CreateOrderedEnumerable(Func> keySelector, IComparer comparer, bool descending); } public interface IConnectableUniTaskAsyncEnumerable : IUniTaskAsyncEnumerable { IDisposable Connect(); } // don't use AsyncGrouping. //public interface IUniTaskAsyncGrouping : IUniTaskAsyncEnumerable //{ // TKey Key { get; } //} public static class UniTaskAsyncEnumerableExtensions { public static UniTaskCancelableAsyncEnumerable WithCancellation(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { return new UniTaskCancelableAsyncEnumerable(source, cancellationToken); } } [StructLayout(LayoutKind.Auto)] public readonly struct UniTaskCancelableAsyncEnumerable { private readonly IUniTaskAsyncEnumerable enumerable; private readonly CancellationToken cancellationToken; internal UniTaskCancelableAsyncEnumerable(IUniTaskAsyncEnumerable 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 enumerator; internal Enumerator(IUniTaskAsyncEnumerator enumerator) { this.enumerator = enumerator; } public T Current => enumerator.Current; public UniTask MoveNextAsync() { return enumerator.MoveNextAsync(); } public UniTask DisposeAsync() { return enumerator.DisposeAsync(); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/IUniTaskAsyncEnumerable.cs.meta ================================================ fileFormatVersion: 2 guid: b20cf9f02ac585948a4372fa4ee06504 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/IUniTaskSource.cs ================================================ #pragma warning disable CS1591 #pragma warning disable CS0108 #if (UNITASK_NETCORE && !NETSTANDARD2_0) || UNITY_2022_3_OR_NEWER #define SUPPORT_VALUETASK #endif using System; using System.Runtime.CompilerServices; namespace Cysharp.Threading.Tasks { public enum UniTaskStatus { /// The operation has not yet completed. Pending = 0, /// The operation completed successfully. Succeeded = 1, /// The operation completed with an error. Faulted = 2, /// The operation completed due to cancellation. Canceled = 3 } // similar as IValueTaskSource public interface IUniTaskSource #if SUPPORT_VALUETASK : System.Threading.Tasks.Sources.IValueTaskSource #endif { UniTaskStatus GetStatus(short token); void OnCompleted(Action continuation, object state, short token); void GetResult(short token); UniTaskStatus UnsafeGetStatus(); // only for debug use. #if SUPPORT_VALUETASK System.Threading.Tasks.Sources.ValueTaskSourceStatus System.Threading.Tasks.Sources.IValueTaskSource.GetStatus(short token) { return (System.Threading.Tasks.Sources.ValueTaskSourceStatus)(int)((IUniTaskSource)this).GetStatus(token); } void System.Threading.Tasks.Sources.IValueTaskSource.GetResult(short token) { ((IUniTaskSource)this).GetResult(token); } void System.Threading.Tasks.Sources.IValueTaskSource.OnCompleted(Action continuation, object state, short token, System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags flags) { // ignore flags, always none. ((IUniTaskSource)this).OnCompleted(continuation, state, token); } #endif } public interface IUniTaskSource : IUniTaskSource #if SUPPORT_VALUETASK , System.Threading.Tasks.Sources.IValueTaskSource #endif { new T GetResult(short token); #if SUPPORT_VALUETASK new public UniTaskStatus GetStatus(short token) { return ((IUniTaskSource)this).GetStatus(token); } new public void OnCompleted(Action continuation, object state, short token) { ((IUniTaskSource)this).OnCompleted(continuation, state, token); } System.Threading.Tasks.Sources.ValueTaskSourceStatus System.Threading.Tasks.Sources.IValueTaskSource.GetStatus(short token) { return (System.Threading.Tasks.Sources.ValueTaskSourceStatus)(int)((IUniTaskSource)this).GetStatus(token); } T System.Threading.Tasks.Sources.IValueTaskSource.GetResult(short token) { return ((IUniTaskSource)this).GetResult(token); } void System.Threading.Tasks.Sources.IValueTaskSource.OnCompleted(Action continuation, object state, short token, System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags flags) { // ignore flags, always none. ((IUniTaskSource)this).OnCompleted(continuation, state, token); } #endif } public static class UniTaskStatusExtensions { /// status != Pending. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsCompleted(this UniTaskStatus status) { return status != UniTaskStatus.Pending; } /// status == Succeeded. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsCompletedSuccessfully(this UniTaskStatus status) { return status == UniTaskStatus.Succeeded; } /// status == Canceled. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsCanceled(this UniTaskStatus status) { return status == UniTaskStatus.Canceled; } /// status == Faulted. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsFaulted(this UniTaskStatus status) { return status == UniTaskStatus.Faulted; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/IUniTaskSource.cs.meta ================================================ fileFormatVersion: 2 guid: 3e4d023d8404ab742b5e808c98097c3c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ArrayPool.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; namespace Cysharp.Threading.Tasks.Internal { // Same interface as System.Buffers.ArrayPool but only provides Shared. internal sealed class ArrayPool { // Same size as System.Buffers.DefaultArrayPool const int DefaultMaxNumberOfArraysPerBucket = 50; static readonly T[] EmptyArray = new T[0]; public static readonly ArrayPool Shared = new ArrayPool(); readonly MinimumQueue[] buckets; readonly SpinLock[] locks; ArrayPool() { // see: GetQueueIndex buckets = new MinimumQueue[18]; locks = new SpinLock[18]; for (int i = 0; i < buckets.Length; i++) { buckets[i] = new MinimumQueue(4); locks[i] = new SpinLock(false); } } public T[] Rent(int minimumLength) { if (minimumLength < 0) { throw new ArgumentOutOfRangeException("minimumLength"); } else if (minimumLength == 0) { return EmptyArray; } var size = CalculateSize(minimumLength); var index = GetQueueIndex(size); if (index != -1) { var q = buckets[index]; var lockTaken = false; try { locks[index].Enter(ref lockTaken); if (q.Count != 0) { return q.Dequeue(); } } finally { if (lockTaken) locks[index].Exit(false); } } return new T[size]; } public void Return(T[] array, bool clearArray = false) { if (array == null || array.Length == 0) { return; } var index = GetQueueIndex(array.Length); if (index != -1) { if (clearArray) { Array.Clear(array, 0, array.Length); } var q = buckets[index]; var lockTaken = false; try { locks[index].Enter(ref lockTaken); if (q.Count > DefaultMaxNumberOfArraysPerBucket) { return; } q.Enqueue(array); } finally { if (lockTaken) locks[index].Exit(false); } } } static int CalculateSize(int size) { size--; size |= size >> 1; size |= size >> 2; size |= size >> 4; size |= size >> 8; size |= size >> 16; size += 1; if (size < 8) { size = 8; } return size; } static int GetQueueIndex(int size) { switch (size) { case 8: return 0; case 16: return 1; case 32: return 2; case 64: return 3; case 128: return 4; case 256: return 5; case 512: return 6; case 1024: return 7; case 2048: return 8; case 4096: return 9; case 8192: return 10; case 16384: return 11; case 32768: return 12; case 65536: return 13; case 131072: return 14; case 262144: return 15; case 524288: return 16; case 1048576: return 17; // max array length default: return -1; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ArrayPool.cs.meta ================================================ fileFormatVersion: 2 guid: f83ebad81fb89fb4882331616ca6d248 timeCreated: 1532361008 licenseType: Free MonoImporter: serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ArrayPoolUtil.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Runtime.CompilerServices; namespace Cysharp.Threading.Tasks.Internal { internal static class ArrayPoolUtil { [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static void EnsureCapacity(ref T[] array, int index, ArrayPool pool) { if (array.Length <= index) { EnsureCapacityCore(ref array, index, pool); } } [MethodImpl(MethodImplOptions.NoInlining)] static void EnsureCapacityCore(ref T[] array, int index, ArrayPool pool) { if (array.Length <= index) { var newSize = array.Length * 2; var newArray = pool.Rent((index < newSize) ? newSize : (index * 2)); Array.Copy(array, 0, newArray, 0, array.Length); pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); array = newArray; } } public static RentArray Materialize(IEnumerable source) { if (source is T[] array) { return new RentArray(array, array.Length, null); } var defaultCount = 32; if (source is ICollection coll) { if (coll.Count == 0) { return new RentArray(Array.Empty(), 0, null); } defaultCount = coll.Count; var pool = ArrayPool.Shared; var buffer = pool.Rent(defaultCount); coll.CopyTo(buffer, 0); return new RentArray(buffer, coll.Count, pool); } else if (source is IReadOnlyCollection rcoll) { defaultCount = rcoll.Count; } if (defaultCount == 0) { return new RentArray(Array.Empty(), 0, null); } { var pool = ArrayPool.Shared; var index = 0; var buffer = pool.Rent(defaultCount); foreach (var item in source) { EnsureCapacity(ref buffer, index, pool); buffer[index++] = item; } return new RentArray(buffer, index, pool); } } public struct RentArray : IDisposable { public readonly T[] Array; public readonly int Length; ArrayPool pool; public RentArray(T[] array, int length, ArrayPool pool) { this.Array = array; this.Length = length; this.pool = pool; } public void Dispose() { DisposeManually(!RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); } public void DisposeManually(bool clearArray) { if (pool != null) { if (clearArray) { System.Array.Clear(Array, 0, Length); } pool.Return(Array, clearArray: false); pool = null; } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ArrayPoolUtil.cs.meta ================================================ fileFormatVersion: 2 guid: 424cc208fb61d4e448b08fcfa0eee25e timeCreated: 1532361007 licenseType: Free MonoImporter: serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ArrayUtil.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Runtime.CompilerServices; namespace Cysharp.Threading.Tasks.Internal { internal static class ArrayUtil { [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void EnsureCapacity(ref T[] array, int index) { if (array.Length <= index) { EnsureCore(ref array, index); } } // rare case, no inlining. [MethodImpl(MethodImplOptions.NoInlining)] static void EnsureCore(ref T[] array, int index) { var newSize = array.Length * 2; var newArray = new T[(index < newSize) ? newSize : (index * 2)]; Array.Copy(array, 0, newArray, 0, array.Length); array = newArray; } /// /// Optimizing utility to avoid .ToArray() that creates buffer copy(cut to just size). /// public static (T[] array, int length) Materialize(IEnumerable source) { if (source is T[] array) { return (array, array.Length); } var defaultCount = 4; if (source is ICollection coll) { defaultCount = coll.Count; var buffer = new T[defaultCount]; coll.CopyTo(buffer, 0); return (buffer, defaultCount); } else if (source is IReadOnlyCollection rcoll) { defaultCount = rcoll.Count; } if (defaultCount == 0) { return (Array.Empty(), 0); } { var index = 0; var buffer = new T[defaultCount]; foreach (var item in source) { EnsureCapacity(ref buffer, index); buffer[index++] = item; } return (buffer, index); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ArrayUtil.cs.meta ================================================ fileFormatVersion: 2 guid: 23146a82ec99f2542a87971c8d3d7988 timeCreated: 1532361007 licenseType: Free MonoImporter: serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ContinuationQueue.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; namespace Cysharp.Threading.Tasks.Internal { internal sealed class ContinuationQueue { const int MaxArrayLength = 0X7FEFFFFF; const int InitialSize = 16; readonly PlayerLoopTiming timing; SpinLock gate = new SpinLock(false); bool dequing = false; int actionListCount = 0; Action[] actionList = new Action[InitialSize]; int waitingListCount = 0; Action[] waitingList = new Action[InitialSize]; public ContinuationQueue(PlayerLoopTiming timing) { this.timing = timing; } public void Enqueue(Action continuation) { bool lockTaken = false; try { gate.Enter(ref lockTaken); if (dequing) { // Ensure Capacity if (waitingList.Length == waitingListCount) { var newLength = waitingListCount * 2; if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength; var newArray = new Action[newLength]; Array.Copy(waitingList, newArray, waitingListCount); waitingList = newArray; } waitingList[waitingListCount] = continuation; waitingListCount++; } else { // Ensure Capacity if (actionList.Length == actionListCount) { var newLength = actionListCount * 2; if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength; var newArray = new Action[newLength]; Array.Copy(actionList, newArray, actionListCount); actionList = newArray; } actionList[actionListCount] = continuation; actionListCount++; } } finally { if (lockTaken) gate.Exit(false); } } public int Clear() { var rest = actionListCount + waitingListCount; actionListCount = 0; actionList = new Action[InitialSize]; waitingListCount = 0; waitingList = new Action[InitialSize]; return rest; } // 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; #if UNITY_2020_2_OR_NEWER case PlayerLoopTiming.TimeUpdate: TimeUpdate(); break; case PlayerLoopTiming.LastTimeUpdate: LastTimeUpdate(); break; #endif 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(); #if UNITY_2020_2_OR_NEWER void TimeUpdate() => RunCore(); void LastTimeUpdate() => RunCore(); #endif [System.Diagnostics.DebuggerHidden] void RunCore() { { bool lockTaken = false; try { gate.Enter(ref lockTaken); if (actionListCount == 0) return; dequing = true; } finally { if (lockTaken) gate.Exit(false); } } for (int i = 0; i < actionListCount; i++) { var action = actionList[i]; actionList[i] = null; try { action(); } catch (Exception ex) { UnityEngine.Debug.LogException(ex); } } { bool lockTaken = false; try { gate.Enter(ref lockTaken); dequing = false; var swapTempActionList = actionList; actionListCount = waitingListCount; actionList = waitingList; waitingListCount = 0; waitingList = swapTempActionList; } finally { if (lockTaken) gate.Exit(false); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ContinuationQueue.cs.meta ================================================ fileFormatVersion: 2 guid: f66c32454e50f2546b17deadc80a4c77 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/DiagnosticsExtensions.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using System.IO; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Security; using System.Text; using System.Text.RegularExpressions; using System.Threading.Tasks; using UnityEngine; namespace Cysharp.Threading.Tasks.Internal { internal static class DiagnosticsExtensions { static bool displayFilenames = true; static readonly Regex typeBeautifyRegex = new Regex("`.+$", RegexOptions.Compiled); static readonly Dictionary builtInTypeNames = new Dictionary { { typeof(void), "void" }, { typeof(bool), "bool" }, { typeof(byte), "byte" }, { typeof(char), "char" }, { typeof(decimal), "decimal" }, { typeof(double), "double" }, { typeof(float), "float" }, { typeof(int), "int" }, { typeof(long), "long" }, { typeof(object), "object" }, { typeof(sbyte), "sbyte" }, { typeof(short), "short" }, { typeof(string), "string" }, { typeof(uint), "uint" }, { typeof(ulong), "ulong" }, { typeof(ushort), "ushort" }, { typeof(Task), "Task" }, { typeof(UniTask), "UniTask" }, { typeof(UniTaskVoid), "UniTaskVoid" } }; public static string CleanupAsyncStackTrace(this StackTrace stackTrace) { if (stackTrace == null) return ""; var sb = new StringBuilder(); for (int i = 0; i < stackTrace.FrameCount; i++) { var sf = stackTrace.GetFrame(i); var mb = sf.GetMethod(); if (IgnoreLine(mb)) continue; if (IsAsync(mb)) { sb.Append("async "); TryResolveStateMachineMethod(ref mb, out var decType); } // return type if (mb is MethodInfo mi) { sb.Append(BeautifyType(mi.ReturnType, false)); sb.Append(" "); } // method name sb.Append(BeautifyType(mb.DeclaringType, false)); if (!mb.IsConstructor) { sb.Append("."); } sb.Append(mb.Name); if (mb.IsGenericMethod) { sb.Append("<"); foreach (var item in mb.GetGenericArguments()) { sb.Append(BeautifyType(item, true)); } sb.Append(">"); } // parameter sb.Append("("); sb.Append(string.Join(", ", mb.GetParameters().Select(p => BeautifyType(p.ParameterType, true) + " " + p.Name))); sb.Append(")"); // file name if (displayFilenames && (sf.GetILOffset() != -1)) { String fileName = null; try { fileName = sf.GetFileName(); } catch (NotSupportedException) { displayFilenames = false; } catch (SecurityException) { displayFilenames = false; } if (fileName != null) { sb.Append(' '); sb.AppendFormat(CultureInfo.InvariantCulture, "(at {0})", AppendHyperLink(fileName, sf.GetFileLineNumber().ToString())); } } sb.AppendLine(); } return sb.ToString(); } static bool IsAsync(MethodBase methodInfo) { var declareType = methodInfo.DeclaringType; return typeof(IAsyncStateMachine).IsAssignableFrom(declareType); } // code from Ben.Demystifier/EnhancedStackTrace.Frame.cs static bool TryResolveStateMachineMethod(ref MethodBase method, out Type declaringType) { declaringType = method.DeclaringType; var parentType = declaringType.DeclaringType; if (parentType == null) { return false; } var methods = parentType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly); if (methods == null) { return false; } foreach (var candidateMethod in methods) { var attributes = candidateMethod.GetCustomAttributes(false); if (attributes == null) { continue; } foreach (var asma in attributes) { if (asma.StateMachineType == declaringType) { method = candidateMethod; declaringType = candidateMethod.DeclaringType; // Mark the iterator as changed; so it gets the + annotation of the original method // async statemachines resolve directly to their builder methods so aren't marked as changed return asma is IteratorStateMachineAttribute; } } } return false; } static string BeautifyType(Type t, bool shortName) { if (builtInTypeNames.TryGetValue(t, out var builtin)) { return builtin; } if (t.IsGenericParameter) return t.Name; if (t.IsArray) return BeautifyType(t.GetElementType(), shortName) + "[]"; if (t.FullName?.StartsWith("System.ValueTuple") ?? false) { return "(" + string.Join(", ", t.GetGenericArguments().Select(x => BeautifyType(x, true))) + ")"; } if (!t.IsGenericType) return shortName ? t.Name : t.FullName.Replace("Cysharp.Threading.Tasks.Triggers.", "").Replace("Cysharp.Threading.Tasks.Internal.", "").Replace("Cysharp.Threading.Tasks.", "") ?? t.Name; var innerFormat = string.Join(", ", t.GetGenericArguments().Select(x => BeautifyType(x, true))); var genericType = t.GetGenericTypeDefinition().FullName; if (genericType == "System.Threading.Tasks.Task`1") { genericType = "Task"; } return typeBeautifyRegex.Replace(genericType, "").Replace("Cysharp.Threading.Tasks.Triggers.", "").Replace("Cysharp.Threading.Tasks.Internal.", "").Replace("Cysharp.Threading.Tasks.", "") + "<" + innerFormat + ">"; } static bool IgnoreLine(MethodBase methodInfo) { var declareType = methodInfo.DeclaringType.FullName; if (declareType == "System.Threading.ExecutionContext") { return true; } else if (declareType.StartsWith("System.Runtime.CompilerServices")) { return true; } else if (declareType.StartsWith("Cysharp.Threading.Tasks.CompilerServices")) { return true; } else if (declareType == "System.Threading.Tasks.AwaitTaskContinuation") { return true; } else if (declareType.StartsWith("System.Threading.Tasks.Task")) { return true; } else if (declareType.StartsWith("Cysharp.Threading.Tasks.UniTaskCompletionSourceCore")) { return true; } else if (declareType.StartsWith("Cysharp.Threading.Tasks.AwaiterActions")) { return true; } return false; } static string AppendHyperLink(string path, string line) { var fi = new FileInfo(path); if (fi.Directory == null) { return fi.Name; } else { var fname = fi.FullName.Replace(Path.DirectorySeparatorChar, '/').Replace(PlayerLoopHelper.ApplicationDataPath, ""); var withAssetsPath = "Assets/" + fname; return "" + withAssetsPath + ":" + line + ""; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/DiagnosticsExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: f80fb1c9ed4c99447be1b0a47a8d980b MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/Error.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; namespace Cysharp.Threading.Tasks.Internal { internal static class Error { [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void ThrowArgumentNullException(T value, string paramName) where T : class { if (value == null) ThrowArgumentNullExceptionCore(paramName); } [MethodImpl(MethodImplOptions.NoInlining)] static void ThrowArgumentNullExceptionCore(string paramName) { 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(string message) { throw new ArgumentException(message); } [MethodImpl(MethodImplOptions.NoInlining)] public static void ThrowNotYetCompleted() { throw new InvalidOperationException("Not yet completed."); } [MethodImpl(MethodImplOptions.NoInlining)] public static T ThrowNotYetCompleted() { throw new InvalidOperationException("Not yet completed."); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void ThrowWhenContinuationIsAlreadyRegistered(T continuationField) where T : class { if (continuationField != null) ThrowInvalidOperationExceptionCore("continuation is already registered."); } [MethodImpl(MethodImplOptions.NoInlining)] static void ThrowInvalidOperationExceptionCore(string message) { throw new InvalidOperationException(message); } [MethodImpl(MethodImplOptions.NoInlining)] public static void ThrowOperationCanceledException() { throw new OperationCanceledException(); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/Error.cs.meta ================================================ fileFormatVersion: 2 guid: 5f39f495294d4604b8082202faf98554 timeCreated: 1532361007 licenseType: Free MonoImporter: serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/MinimumQueue.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; namespace Cysharp.Threading.Tasks.Internal { // optimized version of Standard Queue. internal class MinimumQueue { const int MinimumGrow = 4; const int GrowFactor = 200; T[] array; int head; int tail; int size; public MinimumQueue(int capacity) { if (capacity < 0) throw new ArgumentOutOfRangeException("capacity"); array = new T[capacity]; head = tail = size = 0; } public int Count { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return size; } } public T Peek() { if (size == 0) ThrowForEmptyQueue(); return array[head]; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Enqueue(T item) { if (size == array.Length) { Grow(); } array[tail] = item; MoveNext(ref tail); size++; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public T Dequeue() { if (size == 0) ThrowForEmptyQueue(); int head = this.head; T[] array = this.array; T removed = array[head]; array[head] = default(T); MoveNext(ref this.head); size--; return removed; } void Grow() { int newcapacity = (int)((long)array.Length * (long)GrowFactor / 100); if (newcapacity < array.Length + MinimumGrow) { newcapacity = array.Length + MinimumGrow; } SetCapacity(newcapacity); } void SetCapacity(int capacity) { T[] newarray = new T[capacity]; if (size > 0) { if (head < tail) { Array.Copy(array, head, newarray, 0, size); } else { Array.Copy(array, head, newarray, 0, array.Length - head); Array.Copy(array, 0, newarray, array.Length - head, tail); } } array = newarray; head = 0; tail = (size == capacity) ? 0 : size; } [MethodImpl(MethodImplOptions.AggressiveInlining)] void MoveNext(ref int index) { int tmp = index + 1; if (tmp == array.Length) { tmp = 0; } index = tmp; } void ThrowForEmptyQueue() { throw new InvalidOperationException("EmptyQueue"); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/MinimumQueue.cs.meta ================================================ fileFormatVersion: 2 guid: 7d63add489ccc99498114d79702b904d MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PlayerLoopRunner.cs ================================================  using System; using UnityEngine; namespace Cysharp.Threading.Tasks.Internal { internal sealed class PlayerLoopRunner { const int InitialSize = 16; readonly PlayerLoopTiming timing; readonly object runningAndQueueLock = new object(); readonly object arrayLock = new object(); readonly Action unhandledExceptionCallback; int tail = 0; bool running = false; IPlayerLoopItem[] loopItems = new IPlayerLoopItem[InitialSize]; MinimumQueue waitQueue = new MinimumQueue(InitialSize); public PlayerLoopRunner(PlayerLoopTiming timing) { this.unhandledExceptionCallback = ex => Debug.LogException(ex); this.timing = timing; } public void AddAction(IPlayerLoopItem item) { lock (runningAndQueueLock) { if (running) { waitQueue.Enqueue(item); return; } } lock (arrayLock) { // Ensure Capacity if (loopItems.Length == tail) { Array.Resize(ref loopItems, checked(tail * 2)); } loopItems[tail++] = item; } } public int Clear() { lock (arrayLock) { var rest = 0; for (var index = 0; index < loopItems.Length; index++) { if (loopItems[index] != null) { rest++; } loopItems[index] = null; } tail = 0; return rest; } } // 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; #if UNITY_2020_2_OR_NEWER case PlayerLoopTiming.TimeUpdate: TimeUpdate(); break; case PlayerLoopTiming.LastTimeUpdate: LastTimeUpdate(); break; #endif 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(); #if UNITY_2020_2_OR_NEWER void TimeUpdate() => RunCore(); void LastTimeUpdate() => RunCore(); #endif [System.Diagnostics.DebuggerHidden] void RunCore() { lock (runningAndQueueLock) { running = true; } lock (arrayLock) { var j = tail - 1; for (int i = 0; i < loopItems.Length; i++) { var action = loopItems[i]; if (action != null) { try { if (!action.MoveNext()) { loopItems[i] = null; } else { continue; // next i } } catch (Exception ex) { loopItems[i] = null; try { unhandledExceptionCallback(ex); } catch { } } } // find null, loop from tail while (i < j) { var fromTail = loopItems[j]; if (fromTail != null) { try { if (!fromTail.MoveNext()) { loopItems[j] = null; j--; continue; // next j } else { // swap loopItems[i] = fromTail; loopItems[j] = null; j--; goto NEXT_LOOP; // next i } } catch (Exception ex) { loopItems[j] = null; j--; try { unhandledExceptionCallback(ex); } catch { } continue; // next j } } else { j--; } } tail = i; // loop end break; // LOOP END NEXT_LOOP: continue; } lock (runningAndQueueLock) { running = false; while (waitQueue.Count != 0) { if (loopItems.Length == tail) { Array.Resize(ref loopItems, checked(tail * 2)); } loopItems[tail++] = waitQueue.Dequeue(); } } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PlayerLoopRunner.cs.meta ================================================ fileFormatVersion: 2 guid: 340c6d420bb4f484aa8683415ea92571 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PooledDelegate.cs ================================================ using System; using System.Runtime.CompilerServices; namespace Cysharp.Threading.Tasks.Internal { internal sealed class PooledDelegate : ITaskPoolNode> { static TaskPool> pool; PooledDelegate nextNode; public ref PooledDelegate NextNode => ref nextNode; static PooledDelegate() { TaskPool.RegisterSizeGetter(typeof(PooledDelegate), () => pool.Size); } readonly Action runDelegate; Action continuation; PooledDelegate() { runDelegate = Run; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Action Create(Action continuation) { if (!pool.TryPop(out var item)) { item = new PooledDelegate(); } item.continuation = continuation; return item.runDelegate; } [MethodImpl(MethodImplOptions.AggressiveInlining)] void Run(T _) { var call = continuation; continuation = null; if (call != null) { pool.TryPush(this); call.Invoke(); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PooledDelegate.cs.meta ================================================ fileFormatVersion: 2 guid: 8932579438742fa40b010edd412dbfba MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/RuntimeHelpersAbstraction.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; #if UNITY_2018_3_OR_NEWER using UnityEngine; #endif namespace Cysharp.Threading.Tasks.Internal { internal static class RuntimeHelpersAbstraction { // If we can use RuntimeHelpers.IsReferenceOrContainsReferences(.NET Core 2.0), use it. public static bool IsWellKnownNoReferenceContainsType() { return WellKnownNoReferenceContainsType.IsWellKnownType; } static bool WellKnownNoReferenceContainsTypeInitialize(Type t) { // The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, and Single. if (t.IsPrimitive) return true; if (t.IsEnum) return true; if (t == typeof(DateTime)) return true; if (t == typeof(DateTimeOffset)) return true; if (t == typeof(Guid)) return true; if (t == typeof(decimal)) return true; // unwrap nullable if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>)) { return WellKnownNoReferenceContainsTypeInitialize(t.GetGenericArguments()[0]); } #if UNITY_2018_3_OR_NEWER // or add other wellknown types(Vector, etc...) here if (t == typeof(Vector2)) return true; if (t == typeof(Vector3)) return true; if (t == typeof(Vector4)) return true; if (t == typeof(Color)) return true; if (t == typeof(Rect)) return true; if (t == typeof(Bounds)) return true; if (t == typeof(Quaternion)) return true; if (t == typeof(Vector2Int)) return true; if (t == typeof(Vector3Int)) return true; #endif return false; } static class WellKnownNoReferenceContainsType { public static readonly bool IsWellKnownType; static WellKnownNoReferenceContainsType() { IsWellKnownType = WellKnownNoReferenceContainsTypeInitialize(typeof(T)); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/RuntimeHelpersAbstraction.cs.meta ================================================ fileFormatVersion: 2 guid: 94975e4d4e0c0ea4ba787d3872ce9bb4 timeCreated: 1532361007 licenseType: Free MonoImporter: serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/StatePool.cs ================================================ using System; using System.Collections.Concurrent; using System.Runtime.CompilerServices; namespace Cysharp.Threading.Tasks.Internal { internal static class StateTuple { public static StateTuple Create(T1 item1) { return StatePool.Create(item1); } public static StateTuple Create(T1 item1, T2 item2) { return StatePool.Create(item1, item2); } public static StateTuple Create(T1 item1, T2 item2, T3 item3) { return StatePool.Create(item1, item2, item3); } } internal class StateTuple : IDisposable { public T1 Item1; public void Deconstruct(out T1 item1) { item1 = this.Item1; } public void Dispose() { StatePool.Return(this); } } internal static class StatePool { static readonly ConcurrentQueue> queue = new ConcurrentQueue>(); [MethodImpl(MethodImplOptions.AggressiveInlining)] public static StateTuple Create(T1 item1) { if (queue.TryDequeue(out var value)) { value.Item1 = item1; return value; } return new StateTuple { Item1 = item1 }; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Return(StateTuple tuple) { tuple.Item1 = default; queue.Enqueue(tuple); } } internal class StateTuple : IDisposable { public T1 Item1; public T2 Item2; public void Deconstruct(out T1 item1, out T2 item2) { item1 = this.Item1; item2 = this.Item2; } public void Dispose() { StatePool.Return(this); } } internal static class StatePool { static readonly ConcurrentQueue> queue = new ConcurrentQueue>(); [MethodImpl(MethodImplOptions.AggressiveInlining)] public static StateTuple Create(T1 item1, T2 item2) { if (queue.TryDequeue(out var value)) { value.Item1 = item1; value.Item2 = item2; return value; } return new StateTuple { Item1 = item1, Item2 = item2 }; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Return(StateTuple tuple) { tuple.Item1 = default; tuple.Item2 = default; queue.Enqueue(tuple); } } internal class StateTuple : IDisposable { public T1 Item1; public T2 Item2; public T3 Item3; public void Deconstruct(out T1 item1, out T2 item2, out T3 item3) { item1 = this.Item1; item2 = this.Item2; item3 = this.Item3; } public void Dispose() { StatePool.Return(this); } } internal static class StatePool { static readonly ConcurrentQueue> queue = new ConcurrentQueue>(); [MethodImpl(MethodImplOptions.AggressiveInlining)] public static StateTuple Create(T1 item1, T2 item2, T3 item3) { if (queue.TryDequeue(out var value)) { value.Item1 = item1; value.Item2 = item2; value.Item3 = item3; return value; } return new StateTuple { Item1 = item1, Item2 = item2, Item3 = item3 }; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Return(StateTuple tuple) { tuple.Item1 = default; tuple.Item2 = default; tuple.Item3 = default; queue.Enqueue(tuple); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/StatePool.cs.meta ================================================ fileFormatVersion: 2 guid: 60cdf0bcaea36b444a7ae7263ae7598f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/TaskTracker.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Diagnostics; using System.Text; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { // public for add user custom. public static class TaskTracker { #if UNITY_EDITOR static int trackingId = 0; public const string EnableAutoReloadKey = "UniTaskTrackerWindow_EnableAutoReloadKey"; public const string EnableTrackingKey = "UniTaskTrackerWindow_EnableTrackingKey"; public const string EnableStackTraceKey = "UniTaskTrackerWindow_EnableStackTraceKey"; public static class EditorEnableState { static bool enableAutoReload; public static bool EnableAutoReload { get { return enableAutoReload; } set { enableAutoReload = value; UnityEditor.EditorPrefs.SetBool(EnableAutoReloadKey, value); } } static bool enableTracking; public static bool EnableTracking { get { return enableTracking; } set { enableTracking = value; UnityEditor.EditorPrefs.SetBool(EnableTrackingKey, value); } } static bool enableStackTrace; public static bool EnableStackTrace { get { return enableStackTrace; } set { enableStackTrace = value; UnityEditor.EditorPrefs.SetBool(EnableStackTraceKey, value); } } } #endif static List> listPool = new List>(); static readonly WeakDictionary tracking = new WeakDictionary(); [Conditional("UNITY_EDITOR")] public static void TrackActiveTask(IUniTaskSource task, int skipFrame) { #if UNITY_EDITOR dirty = true; if (!EditorEnableState.EnableTracking) return; var stackTrace = EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame, true).CleanupAsyncStackTrace() : ""; string typeName; if (EditorEnableState.EnableStackTrace) { var sb = new StringBuilder(); TypeBeautify(task.GetType(), sb); typeName = sb.ToString(); } else { typeName = task.GetType().Name; } tracking.TryAdd(task, (typeName, Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace)); #endif } [Conditional("UNITY_EDITOR")] public static void RemoveTracking(IUniTaskSource task) { #if UNITY_EDITOR dirty = true; if (!EditorEnableState.EnableTracking) return; var success = tracking.TryRemove(task); #endif } static bool dirty; public static bool CheckAndResetDirty() { var current = dirty; dirty = false; return current; } /// (trackingId, awaiterType, awaiterStatus, createdTime, stackTrace) public static void ForEachActiveTask(Action action) { lock (listPool) { var count = tracking.ToList(ref listPool, clear: false); try { for (int i = 0; i < count; i++) { action(listPool[i].Value.trackingId, listPool[i].Value.formattedType, listPool[i].Key.UnsafeGetStatus(), listPool[i].Value.addTime, listPool[i].Value.stackTrace); listPool[i] = default; } } catch { listPool.Clear(); throw; } } } static void TypeBeautify(Type type, StringBuilder sb) { if (type.IsNested) { // TypeBeautify(type.DeclaringType, sb); sb.Append(type.DeclaringType.Name.ToString()); sb.Append("."); } if (type.IsGenericType) { var genericsStart = type.Name.IndexOf("`"); if (genericsStart != -1) { sb.Append(type.Name.Substring(0, genericsStart)); } else { sb.Append(type.Name); } sb.Append("<"); var first = true; foreach (var item in type.GetGenericArguments()) { if (!first) { sb.Append(", "); } first = false; TypeBeautify(item, sb); } sb.Append(">"); } else { sb.Append(type.Name); } } //static string RemoveUniTaskNamespace(string str) //{ // return str.Replace("Cysharp.Threading.Tasks.CompilerServices", "") // .Replace("Cysharp.Threading.Tasks.Linq", "") // .Replace("Cysharp.Threading.Tasks", ""); //} } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/TaskTracker.cs.meta ================================================ fileFormatVersion: 2 guid: a203c73eb4ccdbb44bddfd82d38fdda9 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/UnityEqualityComparer.cs ================================================ using System; using System.Collections.Generic; using UnityEngine; namespace Cysharp.Threading.Tasks.Internal { internal static class UnityEqualityComparer { public static readonly IEqualityComparer Vector2 = new Vector2EqualityComparer(); public static readonly IEqualityComparer Vector3 = new Vector3EqualityComparer(); public static readonly IEqualityComparer Vector4 = new Vector4EqualityComparer(); public static readonly IEqualityComparer Color = new ColorEqualityComparer(); public static readonly IEqualityComparer Color32 = new Color32EqualityComparer(); public static readonly IEqualityComparer Rect = new RectEqualityComparer(); public static readonly IEqualityComparer Bounds = new BoundsEqualityComparer(); public static readonly IEqualityComparer Quaternion = new QuaternionEqualityComparer(); static readonly RuntimeTypeHandle vector2Type = typeof(Vector2).TypeHandle; static readonly RuntimeTypeHandle vector3Type = typeof(Vector3).TypeHandle; static readonly RuntimeTypeHandle vector4Type = typeof(Vector4).TypeHandle; static readonly RuntimeTypeHandle colorType = typeof(Color).TypeHandle; static readonly RuntimeTypeHandle color32Type = typeof(Color32).TypeHandle; static readonly RuntimeTypeHandle rectType = typeof(Rect).TypeHandle; static readonly RuntimeTypeHandle boundsType = typeof(Bounds).TypeHandle; static readonly RuntimeTypeHandle quaternionType = typeof(Quaternion).TypeHandle; #if UNITY_2017_2_OR_NEWER public static readonly IEqualityComparer Vector2Int = new Vector2IntEqualityComparer(); public static readonly IEqualityComparer Vector3Int = new Vector3IntEqualityComparer(); public static readonly IEqualityComparer RangeInt = new RangeIntEqualityComparer(); public static readonly IEqualityComparer RectInt = new RectIntEqualityComparer(); public static readonly IEqualityComparer BoundsInt = new BoundsIntEqualityComparer(); static readonly RuntimeTypeHandle vector2IntType = typeof(Vector2Int).TypeHandle; static readonly RuntimeTypeHandle vector3IntType = typeof(Vector3Int).TypeHandle; static readonly RuntimeTypeHandle rangeIntType = typeof(RangeInt).TypeHandle; static readonly RuntimeTypeHandle rectIntType = typeof(RectInt).TypeHandle; static readonly RuntimeTypeHandle boundsIntType = typeof(BoundsInt).TypeHandle; #endif static class Cache { public static readonly IEqualityComparer Comparer; static Cache() { var comparer = GetDefaultHelper(typeof(T)); if (comparer == null) { Comparer = EqualityComparer.Default; } else { Comparer = (IEqualityComparer)comparer; } } } public static IEqualityComparer GetDefault() { return Cache.Comparer; } static object GetDefaultHelper(Type type) { var t = type.TypeHandle; if (t.Equals(vector2Type)) return (object)UnityEqualityComparer.Vector2; if (t.Equals(vector3Type)) return (object)UnityEqualityComparer.Vector3; if (t.Equals(vector4Type)) return (object)UnityEqualityComparer.Vector4; if (t.Equals(colorType)) return (object)UnityEqualityComparer.Color; if (t.Equals(color32Type)) return (object)UnityEqualityComparer.Color32; if (t.Equals(rectType)) return (object)UnityEqualityComparer.Rect; if (t.Equals(boundsType)) return (object)UnityEqualityComparer.Bounds; if (t.Equals(quaternionType)) return (object)UnityEqualityComparer.Quaternion; #if UNITY_2017_2_OR_NEWER if (t.Equals(vector2IntType)) return (object)UnityEqualityComparer.Vector2Int; if (t.Equals(vector3IntType)) return (object)UnityEqualityComparer.Vector3Int; if (t.Equals(rangeIntType)) return (object)UnityEqualityComparer.RangeInt; if (t.Equals(rectIntType)) return (object)UnityEqualityComparer.RectInt; if (t.Equals(boundsIntType)) return (object)UnityEqualityComparer.BoundsInt; #endif return null; } sealed class Vector2EqualityComparer : IEqualityComparer { public bool Equals(Vector2 self, Vector2 vector) { return self.x.Equals(vector.x) && self.y.Equals(vector.y); } public int GetHashCode(Vector2 obj) { return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2; } } sealed class Vector3EqualityComparer : IEqualityComparer { public bool Equals(Vector3 self, Vector3 vector) { return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z); } public int GetHashCode(Vector3 obj) { return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2; } } sealed class Vector4EqualityComparer : IEqualityComparer { public bool Equals(Vector4 self, Vector4 vector) { return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z) && self.w.Equals(vector.w); } public int GetHashCode(Vector4 obj) { return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2 ^ obj.w.GetHashCode() >> 1; } } sealed class ColorEqualityComparer : IEqualityComparer { public bool Equals(Color self, Color other) { return self.r.Equals(other.r) && self.g.Equals(other.g) && self.b.Equals(other.b) && self.a.Equals(other.a); } public int GetHashCode(Color obj) { return obj.r.GetHashCode() ^ obj.g.GetHashCode() << 2 ^ obj.b.GetHashCode() >> 2 ^ obj.a.GetHashCode() >> 1; } } sealed class RectEqualityComparer : IEqualityComparer { public bool Equals(Rect self, Rect other) { return self.x.Equals(other.x) && self.width.Equals(other.width) && self.y.Equals(other.y) && self.height.Equals(other.height); } public int GetHashCode(Rect obj) { return obj.x.GetHashCode() ^ obj.width.GetHashCode() << 2 ^ obj.y.GetHashCode() >> 2 ^ obj.height.GetHashCode() >> 1; } } sealed class BoundsEqualityComparer : IEqualityComparer { public bool Equals(Bounds self, Bounds vector) { return self.center.Equals(vector.center) && self.extents.Equals(vector.extents); } public int GetHashCode(Bounds obj) { return obj.center.GetHashCode() ^ obj.extents.GetHashCode() << 2; } } sealed class QuaternionEqualityComparer : IEqualityComparer { public bool Equals(Quaternion self, Quaternion vector) { return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z) && self.w.Equals(vector.w); } public int GetHashCode(Quaternion obj) { return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2 ^ obj.w.GetHashCode() >> 1; } } sealed class Color32EqualityComparer : IEqualityComparer { public bool Equals(Color32 self, Color32 vector) { return self.a.Equals(vector.a) && self.r.Equals(vector.r) && self.g.Equals(vector.g) && self.b.Equals(vector.b); } public int GetHashCode(Color32 obj) { return obj.a.GetHashCode() ^ obj.r.GetHashCode() << 2 ^ obj.g.GetHashCode() >> 2 ^ obj.b.GetHashCode() >> 1; } } #if UNITY_2017_2_OR_NEWER sealed class Vector2IntEqualityComparer : IEqualityComparer { public bool Equals(Vector2Int self, Vector2Int vector) { return self.x.Equals(vector.x) && self.y.Equals(vector.y); } public int GetHashCode(Vector2Int obj) { return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2; } } sealed class Vector3IntEqualityComparer : IEqualityComparer { public static readonly Vector3IntEqualityComparer Default = new Vector3IntEqualityComparer(); public bool Equals(Vector3Int self, Vector3Int vector) { return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z); } public int GetHashCode(Vector3Int obj) { return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2; } } sealed class RangeIntEqualityComparer : IEqualityComparer { public bool Equals(RangeInt self, RangeInt vector) { return self.start.Equals(vector.start) && self.length.Equals(vector.length); } public int GetHashCode(RangeInt obj) { return obj.start.GetHashCode() ^ obj.length.GetHashCode() << 2; } } sealed class RectIntEqualityComparer : IEqualityComparer { public bool Equals(RectInt self, RectInt other) { return self.x.Equals(other.x) && self.width.Equals(other.width) && self.y.Equals(other.y) && self.height.Equals(other.height); } public int GetHashCode(RectInt obj) { return obj.x.GetHashCode() ^ obj.width.GetHashCode() << 2 ^ obj.y.GetHashCode() >> 2 ^ obj.height.GetHashCode() >> 1; } } sealed class BoundsIntEqualityComparer : IEqualityComparer { public bool Equals(BoundsInt self, BoundsInt vector) { return Vector3IntEqualityComparer.Default.Equals(self.position, vector.position) && Vector3IntEqualityComparer.Default.Equals(self.size, vector.size); } public int GetHashCode(BoundsInt obj) { return Vector3IntEqualityComparer.Default.GetHashCode(obj.position) ^ Vector3IntEqualityComparer.Default.GetHashCode(obj.size) << 2; } } #endif } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/UnityEqualityComparer.cs.meta ================================================ fileFormatVersion: 2 guid: ebaaf14253c9cfb47b23283218ff9b67 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/UnityWebRequestExtensions.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using UnityEngine.Networking; namespace Cysharp.Threading.Tasks.Internal { #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT) internal static class UnityWebRequestResultExtensions { public static bool IsError(this UnityWebRequest unityWebRequest) { #if UNITY_2020_2_OR_NEWER var result = unityWebRequest.result; return (result == UnityWebRequest.Result.ConnectionError) || (result == UnityWebRequest.Result.DataProcessingError) || (result == UnityWebRequest.Result.ProtocolError); #else return unityWebRequest.isHttpError || unityWebRequest.isNetworkError; #endif } } #endif } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/UnityWebRequestExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 111ba0e639de1d7428af6c823ead4918 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ValueStopwatch.cs ================================================ using System; using System.Diagnostics; namespace Cysharp.Threading.Tasks.Internal { internal readonly struct ValueStopwatch { static readonly double TimestampToTicks = TimeSpan.TicksPerSecond / (double)Stopwatch.Frequency; readonly long startTimestamp; public static ValueStopwatch StartNew() => new ValueStopwatch(Stopwatch.GetTimestamp()); ValueStopwatch(long startTimestamp) { this.startTimestamp = startTimestamp; } public TimeSpan Elapsed => TimeSpan.FromTicks(this.ElapsedTicks); public bool IsInvalid => startTimestamp == 0; public long ElapsedTicks { get { if (startTimestamp == 0) { throw new InvalidOperationException("Detected invalid initialization(use 'default'), only to create from StartNew()."); } var delta = Stopwatch.GetTimestamp() - startTimestamp; return (long)(delta * TimestampToTicks); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ValueStopwatch.cs.meta ================================================ fileFormatVersion: 2 guid: f16fb466974ad034c8732c79c7fd67ea MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/WeakDictionary.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Internal { // Add, Remove, Enumerate with sweep. All operations are thread safe(in spinlock). internal class WeakDictionary where TKey : class { Entry[] buckets; int size; SpinLock gate; // mutable struct(not readonly) readonly float loadFactor; readonly IEqualityComparer keyEqualityComparer; public WeakDictionary(int capacity = 4, float loadFactor = 0.75f, IEqualityComparer keyComparer = null) { var tableSize = CalculateCapacity(capacity, loadFactor); this.buckets = new Entry[tableSize]; this.loadFactor = loadFactor; this.gate = new SpinLock(false); this.keyEqualityComparer = keyComparer ?? EqualityComparer.Default; } public bool TryAdd(TKey key, TValue value) { bool lockTaken = false; try { gate.Enter(ref lockTaken); return TryAddInternal(key, value); } finally { if (lockTaken) gate.Exit(false); } } public bool TryGetValue(TKey key, out TValue value) { bool lockTaken = false; try { gate.Enter(ref lockTaken); if (TryGetEntry(key, out _, out var entry)) { value = entry.Value; return true; } value = default(TValue); return false; } finally { if (lockTaken) gate.Exit(false); } } public bool TryRemove(TKey key) { bool lockTaken = false; try { gate.Enter(ref lockTaken); if (TryGetEntry(key, out var hashIndex, out var entry)) { Remove(hashIndex, entry); return true; } return false; } finally { if (lockTaken) gate.Exit(false); } } bool TryAddInternal(TKey key, TValue value) { var nextCapacity = CalculateCapacity(size + 1, loadFactor); TRY_ADD_AGAIN: if (buckets.Length < nextCapacity) { // rehash var nextBucket = new Entry[nextCapacity]; for (int i = 0; i < buckets.Length; i++) { var e = buckets[i]; while (e != null) { AddToBuckets(nextBucket, key, e.Value, e.Hash); e = e.Next; } } buckets = nextBucket; goto TRY_ADD_AGAIN; } else { // add entry var successAdd = AddToBuckets(buckets, key, value, keyEqualityComparer.GetHashCode(key)); if (successAdd) size++; return successAdd; } } bool AddToBuckets(Entry[] targetBuckets, TKey newKey, TValue value, int keyHash) { var h = keyHash; var hashIndex = h & (targetBuckets.Length - 1); TRY_ADD_AGAIN: if (targetBuckets[hashIndex] == null) { targetBuckets[hashIndex] = new Entry { Key = new WeakReference(newKey, false), Value = value, Hash = h }; return true; } else { // add to last. var entry = targetBuckets[hashIndex]; while (entry != null) { if (entry.Key.TryGetTarget(out var target)) { if (keyEqualityComparer.Equals(newKey, target)) { return false; // duplicate } } else { Remove(hashIndex, entry); if (targetBuckets[hashIndex] == null) goto TRY_ADD_AGAIN; // add new entry } if (entry.Next != null) { entry = entry.Next; } else { // found last entry.Next = new Entry { Key = new WeakReference(newKey, false), Value = value, Hash = h }; entry.Next.Prev = entry; } } return false; } } bool TryGetEntry(TKey key, out int hashIndex, out Entry entry) { var table = buckets; var hash = keyEqualityComparer.GetHashCode(key); hashIndex = hash & table.Length - 1; entry = table[hashIndex]; while (entry != null) { if (entry.Key.TryGetTarget(out var target)) { if (keyEqualityComparer.Equals(key, target)) { return true; } } else { // sweap Remove(hashIndex, entry); } entry = entry.Next; } return false; } void Remove(int hashIndex, Entry entry) { if (entry.Prev == null && entry.Next == null) { buckets[hashIndex] = null; } else { if (entry.Prev == null) { buckets[hashIndex] = entry.Next; } if (entry.Prev != null) { entry.Prev.Next = entry.Next; } if (entry.Next != null) { entry.Next.Prev = entry.Prev; } } size--; } public List> ToList() { var list = new List>(size); ToList(ref list, false); return list; } // avoid allocate everytime. public int ToList(ref List> list, bool clear = true) { if (clear) { list.Clear(); } var listIndex = 0; bool lockTaken = false; try { for (int i = 0; i < buckets.Length; i++) { var entry = buckets[i]; while (entry != null) { if (entry.Key.TryGetTarget(out var target)) { var item = new KeyValuePair(target, entry.Value); if (listIndex < list.Count) { list[listIndex++] = item; } else { list.Add(item); listIndex++; } } else { // sweap Remove(i, entry); } entry = entry.Next; } } } finally { if (lockTaken) gate.Exit(false); } return listIndex; } static int CalculateCapacity(int collectionSize, float loadFactor) { var size = (int)(((float)collectionSize) / loadFactor); size--; size |= size >> 1; size |= size >> 2; size |= size >> 4; size |= size >> 8; size |= size >> 16; size += 1; if (size < 8) { size = 8; } return size; } class Entry { public WeakReference Key; public TValue Value; public int Hash; public Entry Prev; public Entry Next; // debug only public override string ToString() { if (Key.TryGetTarget(out var target)) { return target + "(" + Count() + ")"; } else { return "(Dead)"; } } int Count() { var count = 1; var n = this; while (n.Next != null) { count++; n = n.Next; } return count; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/WeakDictionary.cs.meta ================================================ fileFormatVersion: 2 guid: 6c78563864409714593226af59bcb6f3 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Internal.meta ================================================ fileFormatVersion: 2 guid: 633f49a8aafb6fa43894cd4646c71743 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Aggregate.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask AggregateAsync(this IUniTaskAsyncEnumerable source, Func accumulator, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); return Aggregate.AggregateAsync(source, accumulator, cancellationToken); } public static UniTask AggregateAsync(this IUniTaskAsyncEnumerable source, TAccumulate seed, Func accumulator, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); return Aggregate.AggregateAsync(source, seed, accumulator, cancellationToken); } public static UniTask AggregateAsync(this IUniTaskAsyncEnumerable source, TAccumulate seed, Func accumulator, Func resultSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); Error.ThrowArgumentNullException(accumulator, nameof(resultSelector)); return Aggregate.AggregateAsync(source, seed, accumulator, resultSelector, cancellationToken); } public static UniTask AggregateAwaitAsync(this IUniTaskAsyncEnumerable source, Func> accumulator, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); return Aggregate.AggregateAwaitAsync(source, accumulator, cancellationToken); } public static UniTask AggregateAwaitAsync(this IUniTaskAsyncEnumerable source, TAccumulate seed, Func> accumulator, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); return Aggregate.AggregateAwaitAsync(source, seed, accumulator, cancellationToken); } public static UniTask AggregateAwaitAsync(this IUniTaskAsyncEnumerable source, TAccumulate seed, Func> accumulator, Func> resultSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); Error.ThrowArgumentNullException(accumulator, nameof(resultSelector)); return Aggregate.AggregateAwaitAsync(source, seed, accumulator, resultSelector, cancellationToken); } public static UniTask AggregateAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> accumulator, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); return Aggregate.AggregateAwaitWithCancellationAsync(source, accumulator, cancellationToken); } public static UniTask AggregateAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, TAccumulate seed, Func> accumulator, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); return Aggregate.AggregateAwaitWithCancellationAsync(source, seed, accumulator, cancellationToken); } public static UniTask AggregateAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, TAccumulate seed, Func> accumulator, Func> resultSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(accumulator, nameof(accumulator)); Error.ThrowArgumentNullException(accumulator, nameof(resultSelector)); return Aggregate.AggregateAwaitWithCancellationAsync(source, seed, accumulator, resultSelector, cancellationToken); } } internal static class Aggregate { internal static async UniTask AggregateAsync(IUniTaskAsyncEnumerable source, Func accumulator, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value; if (await e.MoveNextAsync()) { value = e.Current; } else { throw Error.NoElements(); } while (await e.MoveNextAsync()) { value = accumulator(value, e.Current); } return value; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AggregateAsync(IUniTaskAsyncEnumerable source, TAccumulate seed, Func accumulator, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TAccumulate value = seed; while (await e.MoveNextAsync()) { value = accumulator(value, e.Current); } return value; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AggregateAsync(IUniTaskAsyncEnumerable source, TAccumulate seed, Func accumulator, Func resultSelector, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TAccumulate value = seed; while (await e.MoveNextAsync()) { value = accumulator(value, e.Current); } return resultSelector(value); } finally { if (e != null) { await e.DisposeAsync(); } } } // with async internal static async UniTask AggregateAwaitAsync(IUniTaskAsyncEnumerable source, Func> accumulator, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value; if (await e.MoveNextAsync()) { value = e.Current; } else { throw Error.NoElements(); } while (await e.MoveNextAsync()) { value = await accumulator(value, e.Current); } return value; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AggregateAwaitAsync(IUniTaskAsyncEnumerable source, TAccumulate seed, Func> accumulator, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TAccumulate value = seed; while (await e.MoveNextAsync()) { value = await accumulator(value, e.Current); } return value; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AggregateAwaitAsync(IUniTaskAsyncEnumerable source, TAccumulate seed, Func> accumulator, Func> resultSelector, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TAccumulate value = seed; while (await e.MoveNextAsync()) { value = await accumulator(value, e.Current); } return await resultSelector(value); } finally { if (e != null) { await e.DisposeAsync(); } } } // with cancellation internal static async UniTask AggregateAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> accumulator, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value; if (await e.MoveNextAsync()) { value = e.Current; } else { throw Error.NoElements(); } while (await e.MoveNextAsync()) { value = await accumulator(value, e.Current, cancellationToken); } return value; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AggregateAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, TAccumulate seed, Func> accumulator, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TAccumulate value = seed; while (await e.MoveNextAsync()) { value = await accumulator(value, e.Current, cancellationToken); } return value; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AggregateAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, TAccumulate seed, Func> accumulator, Func> resultSelector, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { TAccumulate value = seed; while (await e.MoveNextAsync()) { value = await accumulator(value, e.Current, cancellationToken); } return await resultSelector(value, cancellationToken); } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Aggregate.cs.meta ================================================ fileFormatVersion: 2 guid: 5dc68c05a4228c643937f6ebd185bcca MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/All.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask AllAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return All.AllAsync(source, predicate, cancellationToken); } public static UniTask AllAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return All.AllAwaitAsync(source, predicate, cancellationToken); } public static UniTask AllAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return All.AllAwaitWithCancellationAsync(source, predicate, cancellationToken); } } internal static class All { internal static async UniTask AllAsync(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (!predicate(e.Current)) { return false; } } return true; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AllAwaitAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (!await predicate(e.Current)) { return false; } } return true; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AllAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (!await predicate(e.Current, cancellationToken)) { return false; } } return true; } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/All.cs.meta ================================================ fileFormatVersion: 2 guid: 7271437e0033af2448b600ee248924dd MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Any.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask AnyAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Any.AnyAsync(source, cancellationToken); } public static UniTask AnyAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Any.AnyAsync(source, predicate, cancellationToken); } public static UniTask AnyAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Any.AnyAwaitAsync(source, predicate, cancellationToken); } public static UniTask AnyAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Any.AnyAwaitWithCancellationAsync(source, predicate, cancellationToken); } } internal static class Any { internal static async UniTask AnyAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { if (await e.MoveNextAsync()) { return true; } return false; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AnyAsync(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (predicate(e.Current)) { return true; } } return false; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AnyAwaitAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (await predicate(e.Current)) { return true; } } return false; } finally { if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask AnyAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (await predicate(e.Current, cancellationToken)) { return true; } } return false; } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Any.cs.meta ================================================ fileFormatVersion: 2 guid: e2b2e65745263994fbe34f3e0ec8eb12 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AppendPrepend.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Append(this IUniTaskAsyncEnumerable source, TSource element) { Error.ThrowArgumentNullException(source, nameof(source)); return new AppendPrepend(source, element, true); } public static IUniTaskAsyncEnumerable Prepend(this IUniTaskAsyncEnumerable source, TSource element) { Error.ThrowArgumentNullException(source, nameof(source)); return new AppendPrepend(source, element, false); } } internal sealed class AppendPrepend : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly TSource element; readonly bool append; // or prepend public AppendPrepend(IUniTaskAsyncEnumerable source, TSource element, bool append) { this.source = source; this.element = element; this.append = append; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _AppendPrepend(source, element, append, cancellationToken); } sealed class _AppendPrepend : MoveNextSource, IUniTaskAsyncEnumerator { enum State : byte { None, RequirePrepend, RequireAppend, Completed } static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; readonly TSource element; CancellationToken cancellationToken; State state; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; public _AppendPrepend(IUniTaskAsyncEnumerable source, TSource element, bool append, CancellationToken cancellationToken) { this.source = source; this.element = element; this.state = append ? State.RequireAppend : State.RequirePrepend; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (enumerator == null) { if (state == State.RequirePrepend) { Current = element; state = State.None; return CompletedTasks.True; } enumerator = source.GetAsyncEnumerator(cancellationToken); } if (state == State.Completed) { return CompletedTasks.False; } awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCoreDelegate(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } return new UniTask(this, completionSource.Version); } static void MoveNextCore(object state) { var self = (_AppendPrepend)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.Current = self.enumerator.Current; self.completionSource.TrySetResult(true); } else { if (self.state == State.RequireAppend) { self.state = State.Completed; self.Current = self.element; self.completionSource.TrySetResult(true); } else { self.state = State.Completed; self.completionSource.TrySetResult(false); } } } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AppendPrepend.cs.meta ================================================ fileFormatVersion: 2 guid: 3268ec424b8055f45aa2a26d17c80468 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AsUniTaskAsyncEnumerable.cs ================================================ namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable AsUniTaskAsyncEnumerable(this IUniTaskAsyncEnumerable source) { return source; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AsUniTaskAsyncEnumerable.cs.meta ================================================ fileFormatVersion: 2 guid: 69866e262589ea643bbc62a1d696077a MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AsyncEnumeratorBase.cs ================================================ using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { // note: refactor all inherit class and should remove this. // see Select and Where. internal abstract class AsyncEnumeratorBase : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action moveNextCallbackDelegate = MoveNextCallBack; readonly IUniTaskAsyncEnumerable source; protected CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter sourceMoveNext; public AsyncEnumeratorBase(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 4); } // abstract /// /// If return value is false, continue source.MoveNext. /// protected abstract bool TryMoveNextCore(bool sourceHasCurrent, out bool result); // Util protected TSource SourceCurrent => enumerator.Current; // IUniTaskAsyncEnumerator public TResult Current { get; protected set; } public UniTask MoveNextAsync() { if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); if (!OnFirstIteration()) { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } protected virtual bool OnFirstIteration() { return false; } protected void SourceMoveNext() { CONTINUE: sourceMoveNext = enumerator.MoveNextAsync().GetAwaiter(); if (sourceMoveNext.IsCompleted) { bool result = false; try { if (!TryMoveNextCore(sourceMoveNext.GetResult(), out result)) { goto CONTINUE; } } catch (Exception ex) { completionSource.TrySetException(ex); return; } if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); } else { completionSource.TrySetResult(result); } } else { sourceMoveNext.SourceOnCompleted(moveNextCallbackDelegate, this); } } static void MoveNextCallBack(object state) { var self = (AsyncEnumeratorBase)state; bool result; try { if (!self.TryMoveNextCore(self.sourceMoveNext.GetResult(), out result)) { self.SourceMoveNext(); return; } } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } if (self.cancellationToken.IsCancellationRequested) { self.completionSource.TrySetCanceled(self.cancellationToken); } else { self.completionSource.TrySetResult(result); } } // if require additional resource to dispose, override and call base.DisposeAsync. public virtual UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } internal abstract class AsyncEnumeratorAwaitSelectorBase : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action moveNextCallbackDelegate = MoveNextCallBack; static readonly Action setCurrentCallbackDelegate = SetCurrentCallBack; readonly IUniTaskAsyncEnumerable source; protected CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter sourceMoveNext; UniTask.Awaiter resultAwaiter; public AsyncEnumeratorAwaitSelectorBase(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 4); } // abstract protected abstract UniTask TransformAsync(TSource sourceCurrent); protected abstract bool TrySetCurrentCore(TAwait awaitResult, out bool terminateIteration); // Util protected TSource SourceCurrent { get; private set; } protected (bool waitCallback, bool requireNextIteration) ActionCompleted(bool trySetCurrentResult, out bool moveNextResult) { if (trySetCurrentResult) { moveNextResult = true; return (false, false); } else { moveNextResult = default; return (false, true); } } protected (bool waitCallback, bool requireNextIteration) WaitAwaitCallback(out bool moveNextResult) { moveNextResult = default; return (true, false); } protected (bool waitCallback, bool requireNextIteration) IterateFinished(out bool moveNextResult) { moveNextResult = false; return (false, false); } // IUniTaskAsyncEnumerator public TResult Current { get; protected set; } public UniTask MoveNextAsync() { if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } protected void SourceMoveNext() { CONTINUE: sourceMoveNext = enumerator.MoveNextAsync().GetAwaiter(); if (sourceMoveNext.IsCompleted) { bool result = false; try { (bool waitCallback, bool requireNextIteration) = TryMoveNextCore(sourceMoveNext.GetResult(), out result); if (waitCallback) { return; } if (requireNextIteration) { goto CONTINUE; } else { completionSource.TrySetResult(result); } } catch (Exception ex) { completionSource.TrySetException(ex); return; } } else { sourceMoveNext.SourceOnCompleted(moveNextCallbackDelegate, this); } } (bool waitCallback, bool requireNextIteration) TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { SourceCurrent = enumerator.Current; var task = TransformAsync(SourceCurrent); if (UnwarapTask(task, out var taskResult)) { var currentResult = TrySetCurrentCore(taskResult, out var terminateIteration); if (terminateIteration) { return IterateFinished(out result); } return ActionCompleted(currentResult, out result); } else { return WaitAwaitCallback(out result); } } return IterateFinished(out result); } protected bool UnwarapTask(UniTask taskResult, out TAwait result) { resultAwaiter = taskResult.GetAwaiter(); if (resultAwaiter.IsCompleted) { result = resultAwaiter.GetResult(); return true; } else { resultAwaiter.SourceOnCompleted(setCurrentCallbackDelegate, this); result = default; return false; } } static void MoveNextCallBack(object state) { var self = (AsyncEnumeratorAwaitSelectorBase)state; bool result = false; try { (bool waitCallback, bool requireNextIteration) = self.TryMoveNextCore(self.sourceMoveNext.GetResult(), out result); if (waitCallback) { return; } if (requireNextIteration) { self.SourceMoveNext(); return; } else { self.completionSource.TrySetResult(result); } } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } } static void SetCurrentCallBack(object state) { var self = (AsyncEnumeratorAwaitSelectorBase)state; bool doneSetCurrent; bool terminateIteration; try { var result = self.resultAwaiter.GetResult(); doneSetCurrent = self.TrySetCurrentCore(result, out terminateIteration); } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } if (self.cancellationToken.IsCancellationRequested) { self.completionSource.TrySetCanceled(self.cancellationToken); } else { if (doneSetCurrent) { self.completionSource.TrySetResult(true); } else { if (terminateIteration) { self.completionSource.TrySetResult(false); } else { self.SourceMoveNext(); } } } } // if require additional resource to dispose, override and call base.DisposeAsync. public virtual UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AsyncEnumeratorBase.cs.meta ================================================ fileFormatVersion: 2 guid: 01ba1d3b17e13fb4c95740131c7e6e19 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Average.cs ================================================ using System; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask AverageAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } } internal static class Average { public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Int32 sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += e.Current; count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Int32 sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Int32 sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Int32 sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current, cancellationToken); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Int64 sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += e.Current; count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Int64 sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Int64 sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Int64 sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current, cancellationToken); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Single sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += e.Current; count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (float)(sum / count); } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Single sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (float)(sum / count); } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Single sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (float)(sum / count); } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Single sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current, cancellationToken); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return (float)(sum / count); } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Double sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += e.Current; count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Double sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Double sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Double sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current, cancellationToken); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Decimal sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += e.Current; count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Decimal sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Decimal sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Decimal sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { sum += await selector(e.Current, cancellationToken); count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Int32? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Int32? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Int32? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Int32? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current, cancellationToken); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Int64? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Int64? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Int64? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Int64? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current, cancellationToken); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (double)sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Single? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (float)(sum / count); } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Single? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (float)(sum / count); } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Single? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (float)(sum / count); } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Single? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current, cancellationToken); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return (float)(sum / count); } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Double? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Double? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Double? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Double? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current, cancellationToken); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; Decimal? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { long count = 0; Decimal? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Decimal? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } public static async UniTask AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; Decimal? sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = await selector(e.Current, cancellationToken); if (v.HasValue) { checked { sum += v.Value; count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return sum / count; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Average.cs.meta ================================================ fileFormatVersion: 2 guid: 58499f95012fb3c47bb7bcbc5862e562 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Average.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> <# var types = new[] { (typeof(int), "double"), (typeof(long), "double"), (typeof(float),"float"), (typeof(double),"double"), (typeof(decimal),"decimal"), (typeof(int?),"double?"), (typeof(long?),"double?"), (typeof(float?),"float?"), (typeof(double?),"double?"), (typeof(decimal?),"decimal?"), }; Func IsNullable = x => x.IsGenericType; Func ElementType = x => IsNullable(x) ? x.GetGenericArguments()[0] : x; Func TypeName = x => IsNullable(x) ? x.GetGenericArguments()[0].Name + "?" : x.Name; Func WithSuffix = x => IsNullable(x) ? ".GetValueOrDefault()" : ""; Func CalcResult = x => { var e = ElementType(x); return (e == typeof(int) || e == typeof(long)) ? "(double)sum / count" : (e == typeof(float)) ? "(float)(sum / count)" : "sum / count"; }; #> using System; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { <# foreach(var (t, ret) in types) { #> public static UniTask<<#= ret #>> AverageAsync(this IUniTaskAsyncEnumerable<<#= TypeName(t) #>> source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Average.AverageAsync(source, cancellationToken); } public static UniTask<<#= ret #>> AverageAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAsync(source, selector, cancellationToken); } public static UniTask<<#= ret #>> AverageAwaitAsync(this IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitAsync(source, selector, cancellationToken); } public static UniTask<<#= ret #>> AverageAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Average.AverageAwaitWithCancellationAsync(source, selector, cancellationToken); } <# } #> } internal static class Average { <# foreach(var (t, ret) in types) { #> public static async UniTask<<#= ret #>> AverageAsync(IUniTaskAsyncEnumerable<<#= TypeName(t) #>> source, CancellationToken cancellationToken) { long count = 0; <#= TypeName(t) #> sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { <# if (IsNullable(t)) { #> var v = e.Current; if (v.HasValue) { checked { sum += v.Value; count++; } } <# } else { #> checked { sum += e.Current; count++; } <# } #> } } finally { if (e != null) { await e.DisposeAsync(); } } return <#= CalcResult(t) #>; } public static async UniTask<<#= ret #>> AverageAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { long count = 0; <#= TypeName(t) #> sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { <# if (IsNullable(t)) { #> var v = selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } <# } else { #> checked { sum += selector(e.Current); count++; } <# } #> } } finally { if (e != null) { await e.DisposeAsync(); } } return <#= CalcResult(t) #>; } public static async UniTask<<#= ret #>> AverageAwaitAsync(IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken) { long count = 0; <#= TypeName(t) #> sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { <# if (IsNullable(t)) { #> var v = await selector(e.Current); if (v.HasValue) { checked { sum += v.Value; count++; } } <# } else { #> checked { sum += await selector(e.Current); count++; } <# } #> } } finally { if (e != null) { await e.DisposeAsync(); } } return <#= CalcResult(t) #>; } public static async UniTask<<#= ret #>> AverageAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken) { long count = 0; <#= TypeName(t) #> sum = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { <# if (IsNullable(t)) { #> var v = await selector(e.Current, cancellationToken); if (v.HasValue) { checked { sum += v.Value; count++; } } <# } else { #> checked { sum += await selector(e.Current, cancellationToken); count++; } <# } #> } } finally { if (e != null) { await e.DisposeAsync(); } } return <#= CalcResult(t) #>; } <# } #> } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Average.tt.meta ================================================ fileFormatVersion: 2 guid: 84bce45768c171d4490153eb08630a98 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Buffer.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable> Buffer(this IUniTaskAsyncEnumerable source, Int32 count) { Error.ThrowArgumentNullException(source, nameof(source)); if (count <= 0) throw Error.ArgumentOutOfRange(nameof(count)); return new Buffer(source, count); } public static IUniTaskAsyncEnumerable> Buffer(this IUniTaskAsyncEnumerable source, Int32 count, Int32 skip) { Error.ThrowArgumentNullException(source, nameof(source)); if (count <= 0) throw Error.ArgumentOutOfRange(nameof(count)); if (skip <= 0) throw Error.ArgumentOutOfRange(nameof(skip)); return new BufferSkip(source, count, skip); } } internal sealed class Buffer : IUniTaskAsyncEnumerable> { readonly IUniTaskAsyncEnumerable source; readonly int count; public Buffer(IUniTaskAsyncEnumerable source, int count) { this.source = source; this.count = count; } public IUniTaskAsyncEnumerator> GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Buffer(source, count, cancellationToken); } sealed class _Buffer : MoveNextSource, IUniTaskAsyncEnumerator> { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; readonly int count; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; bool continueNext; bool completed; List buffer; public _Buffer(IUniTaskAsyncEnumerable source, int count, CancellationToken cancellationToken) { this.source = source; this.count = count; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public IList Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); buffer = new List(count); } completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } void SourceMoveNext() { if (completed) { if (buffer != null && buffer.Count > 0) { var ret = buffer; buffer = null; Current = ret; completionSource.TrySetResult(true); return; } else { completionSource.TrySetResult(false); return; } } try { LOOP: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; // avoid recursive } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_Buffer)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.buffer.Add(self.enumerator.Current); if (self.buffer.Count == self.count) { self.Current = self.buffer; self.buffer = new List(self.count); self.continueNext = false; self.completionSource.TrySetResult(true); return; } else { if (!self.continueNext) { self.SourceMoveNext(); } } } else { self.continueNext = false; self.completed = true; self.SourceMoveNext(); } } else { self.continueNext = false; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } internal sealed class BufferSkip : IUniTaskAsyncEnumerable> { readonly IUniTaskAsyncEnumerable source; readonly int count; readonly int skip; public BufferSkip(IUniTaskAsyncEnumerable source, int count, int skip) { this.source = source; this.count = count; this.skip = skip; } public IUniTaskAsyncEnumerator> GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _BufferSkip(source, count, skip, cancellationToken); } sealed class _BufferSkip : MoveNextSource, IUniTaskAsyncEnumerator> { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; readonly int count; readonly int skip; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; bool continueNext; bool completed; Queue> buffers; int index = 0; public _BufferSkip(IUniTaskAsyncEnumerable source, int count, int skip, CancellationToken cancellationToken) { this.source = source; this.count = count; this.skip = skip; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public IList Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); buffers = new Queue>(); } completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } void SourceMoveNext() { if (completed) { if (buffers.Count > 0) { Current = buffers.Dequeue(); completionSource.TrySetResult(true); return; } else { completionSource.TrySetResult(false); return; } } try { LOOP: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; // avoid recursive } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_BufferSkip)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { if (self.index++ % self.skip == 0) { self.buffers.Enqueue(new List(self.count)); } var item = self.enumerator.Current; foreach (var buffer in self.buffers) { buffer.Add(item); } if (self.buffers.Count > 0 && self.buffers.Peek().Count == self.count) { self.Current = self.buffers.Dequeue(); self.continueNext = false; self.completionSource.TrySetResult(true); return; } else { if (!self.continueNext) { self.SourceMoveNext(); } } } else { self.continueNext = false; self.completed = true; self.SourceMoveNext(); } } else { self.continueNext = false; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Buffer.cs.meta ================================================ fileFormatVersion: 2 guid: 951310243334a3148a7872977cb31c5c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Cast.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Cast(this IUniTaskAsyncEnumerable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new Cast(source); } } internal sealed class Cast : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; public Cast(IUniTaskAsyncEnumerable source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Cast(source, cancellationToken); } class _Cast : AsyncEnumeratorBase { public _Cast(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) : base(source, cancellationToken) { } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { Current = (TResult)SourceCurrent; result = true; return true; } result = false; return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Cast.cs.meta ================================================ fileFormatVersion: 2 guid: edebeae8b61352b428abe9ce8f3fc71a MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(source8, nameof(source8)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(source8, nameof(source8)); Error.ThrowArgumentNullException(source9, nameof(source9)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(source8, nameof(source8)); Error.ThrowArgumentNullException(source9, nameof(source9)); Error.ThrowArgumentNullException(source10, nameof(source10)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(source8, nameof(source8)); Error.ThrowArgumentNullException(source9, nameof(source9)); Error.ThrowArgumentNullException(source10, nameof(source10)); Error.ThrowArgumentNullException(source11, nameof(source11)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(source8, nameof(source8)); Error.ThrowArgumentNullException(source9, nameof(source9)); Error.ThrowArgumentNullException(source10, nameof(source10)); Error.ThrowArgumentNullException(source11, nameof(source11)); Error.ThrowArgumentNullException(source12, nameof(source12)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(source8, nameof(source8)); Error.ThrowArgumentNullException(source9, nameof(source9)); Error.ThrowArgumentNullException(source10, nameof(source10)); Error.ThrowArgumentNullException(source11, nameof(source11)); Error.ThrowArgumentNullException(source12, nameof(source12)); Error.ThrowArgumentNullException(source13, nameof(source13)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, IUniTaskAsyncEnumerable source14, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(source8, nameof(source8)); Error.ThrowArgumentNullException(source9, nameof(source9)); Error.ThrowArgumentNullException(source10, nameof(source10)); Error.ThrowArgumentNullException(source11, nameof(source11)); Error.ThrowArgumentNullException(source12, nameof(source12)); Error.ThrowArgumentNullException(source13, nameof(source13)); Error.ThrowArgumentNullException(source14, nameof(source14)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, source14, resultSelector); } public static IUniTaskAsyncEnumerable CombineLatest(this IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, IUniTaskAsyncEnumerable source14, IUniTaskAsyncEnumerable source15, Func resultSelector) { Error.ThrowArgumentNullException(source1, nameof(source1)); Error.ThrowArgumentNullException(source2, nameof(source2)); Error.ThrowArgumentNullException(source3, nameof(source3)); Error.ThrowArgumentNullException(source4, nameof(source4)); Error.ThrowArgumentNullException(source5, nameof(source5)); Error.ThrowArgumentNullException(source6, nameof(source6)); Error.ThrowArgumentNullException(source7, nameof(source7)); Error.ThrowArgumentNullException(source8, nameof(source8)); Error.ThrowArgumentNullException(source9, nameof(source9)); Error.ThrowArgumentNullException(source10, nameof(source10)); Error.ThrowArgumentNullException(source11, nameof(source11)); Error.ThrowArgumentNullException(source12, nameof(source12)); Error.ThrowArgumentNullException(source13, nameof(source13)); Error.ThrowArgumentNullException(source14, nameof(source14)); Error.ThrowArgumentNullException(source15, nameof(source15)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, source14, source15, resultSelector); } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; const int CompleteCount = 2; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running1 || !running2) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2) { result = resultSelector(current1, current2); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; const int CompleteCount = 3; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running1 || !running2 || !running3) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3) { result = resultSelector(current1, current2, current3); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; const int CompleteCount = 4; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running1 || !running2 || !running3 || !running4) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4) { result = resultSelector(current1, current2, current3, current4); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; const int CompleteCount = 5; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5) { result = resultSelector(current1, current2, current3, current4, current5); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; const int CompleteCount = 6; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6) { result = resultSelector(current1, current2, current3, current4, current5, current6); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; const int CompleteCount = 7; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; static readonly Action Completed8Delegate = Completed8; const int CompleteCount = 8; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; IUniTaskAsyncEnumerator enumerator8; UniTask.Awaiter awaiter8; bool hasCurrent8; bool running8; T8 current8; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); enumerator8 = source8.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running8) { running8 = true; awaiter8 = enumerator8.MoveNextAsync().GetAwaiter(); if (awaiter8.IsCompleted) { Completed8(this); } else { awaiter8.SourceOnCompleted(Completed8Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed8(object state) { var self = (_CombineLatest)state; self.running8 = false; try { if (self.awaiter8.GetResult()) { self.hasCurrent8 = true; self.current8 = self.enumerator8.Current; goto SUCCESS; } else { self.running8 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running8 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running8 = true; // as complete, no more call MoveNextAsync. try { self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter8.SourceOnCompleted(Completed8Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } if (enumerator8 != null) { await enumerator8.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; static readonly Action Completed8Delegate = Completed8; static readonly Action Completed9Delegate = Completed9; const int CompleteCount = 9; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; IUniTaskAsyncEnumerator enumerator8; UniTask.Awaiter awaiter8; bool hasCurrent8; bool running8; T8 current8; IUniTaskAsyncEnumerator enumerator9; UniTask.Awaiter awaiter9; bool hasCurrent9; bool running9; T9 current9; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); enumerator8 = source8.GetAsyncEnumerator(cancellationToken); enumerator9 = source9.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running8) { running8 = true; awaiter8 = enumerator8.MoveNextAsync().GetAwaiter(); if (awaiter8.IsCompleted) { Completed8(this); } else { awaiter8.SourceOnCompleted(Completed8Delegate, this); } } if (!running9) { running9 = true; awaiter9 = enumerator9.MoveNextAsync().GetAwaiter(); if (awaiter9.IsCompleted) { Completed9(this); } else { awaiter9.SourceOnCompleted(Completed9Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed8(object state) { var self = (_CombineLatest)state; self.running8 = false; try { if (self.awaiter8.GetResult()) { self.hasCurrent8 = true; self.current8 = self.enumerator8.Current; goto SUCCESS; } else { self.running8 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running8 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running8 = true; // as complete, no more call MoveNextAsync. try { self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter8.SourceOnCompleted(Completed8Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed9(object state) { var self = (_CombineLatest)state; self.running9 = false; try { if (self.awaiter9.GetResult()) { self.hasCurrent9 = true; self.current9 = self.enumerator9.Current; goto SUCCESS; } else { self.running9 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running9 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running9 = true; // as complete, no more call MoveNextAsync. try { self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter9.SourceOnCompleted(Completed9Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } if (enumerator8 != null) { await enumerator8.DisposeAsync(); } if (enumerator9 != null) { await enumerator9.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; static readonly Action Completed8Delegate = Completed8; static readonly Action Completed9Delegate = Completed9; static readonly Action Completed10Delegate = Completed10; const int CompleteCount = 10; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; IUniTaskAsyncEnumerator enumerator8; UniTask.Awaiter awaiter8; bool hasCurrent8; bool running8; T8 current8; IUniTaskAsyncEnumerator enumerator9; UniTask.Awaiter awaiter9; bool hasCurrent9; bool running9; T9 current9; IUniTaskAsyncEnumerator enumerator10; UniTask.Awaiter awaiter10; bool hasCurrent10; bool running10; T10 current10; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); enumerator8 = source8.GetAsyncEnumerator(cancellationToken); enumerator9 = source9.GetAsyncEnumerator(cancellationToken); enumerator10 = source10.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running8) { running8 = true; awaiter8 = enumerator8.MoveNextAsync().GetAwaiter(); if (awaiter8.IsCompleted) { Completed8(this); } else { awaiter8.SourceOnCompleted(Completed8Delegate, this); } } if (!running9) { running9 = true; awaiter9 = enumerator9.MoveNextAsync().GetAwaiter(); if (awaiter9.IsCompleted) { Completed9(this); } else { awaiter9.SourceOnCompleted(Completed9Delegate, this); } } if (!running10) { running10 = true; awaiter10 = enumerator10.MoveNextAsync().GetAwaiter(); if (awaiter10.IsCompleted) { Completed10(this); } else { awaiter10.SourceOnCompleted(Completed10Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed8(object state) { var self = (_CombineLatest)state; self.running8 = false; try { if (self.awaiter8.GetResult()) { self.hasCurrent8 = true; self.current8 = self.enumerator8.Current; goto SUCCESS; } else { self.running8 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running8 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running8 = true; // as complete, no more call MoveNextAsync. try { self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter8.SourceOnCompleted(Completed8Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed9(object state) { var self = (_CombineLatest)state; self.running9 = false; try { if (self.awaiter9.GetResult()) { self.hasCurrent9 = true; self.current9 = self.enumerator9.Current; goto SUCCESS; } else { self.running9 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running9 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running9 = true; // as complete, no more call MoveNextAsync. try { self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter9.SourceOnCompleted(Completed9Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed10(object state) { var self = (_CombineLatest)state; self.running10 = false; try { if (self.awaiter10.GetResult()) { self.hasCurrent10 = true; self.current10 = self.enumerator10.Current; goto SUCCESS; } else { self.running10 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running10 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running10 = true; // as complete, no more call MoveNextAsync. try { self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter10.SourceOnCompleted(Completed10Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } if (enumerator8 != null) { await enumerator8.DisposeAsync(); } if (enumerator9 != null) { await enumerator9.DisposeAsync(); } if (enumerator10 != null) { await enumerator10.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; static readonly Action Completed8Delegate = Completed8; static readonly Action Completed9Delegate = Completed9; static readonly Action Completed10Delegate = Completed10; static readonly Action Completed11Delegate = Completed11; const int CompleteCount = 11; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; IUniTaskAsyncEnumerator enumerator8; UniTask.Awaiter awaiter8; bool hasCurrent8; bool running8; T8 current8; IUniTaskAsyncEnumerator enumerator9; UniTask.Awaiter awaiter9; bool hasCurrent9; bool running9; T9 current9; IUniTaskAsyncEnumerator enumerator10; UniTask.Awaiter awaiter10; bool hasCurrent10; bool running10; T10 current10; IUniTaskAsyncEnumerator enumerator11; UniTask.Awaiter awaiter11; bool hasCurrent11; bool running11; T11 current11; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); enumerator8 = source8.GetAsyncEnumerator(cancellationToken); enumerator9 = source9.GetAsyncEnumerator(cancellationToken); enumerator10 = source10.GetAsyncEnumerator(cancellationToken); enumerator11 = source11.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running8) { running8 = true; awaiter8 = enumerator8.MoveNextAsync().GetAwaiter(); if (awaiter8.IsCompleted) { Completed8(this); } else { awaiter8.SourceOnCompleted(Completed8Delegate, this); } } if (!running9) { running9 = true; awaiter9 = enumerator9.MoveNextAsync().GetAwaiter(); if (awaiter9.IsCompleted) { Completed9(this); } else { awaiter9.SourceOnCompleted(Completed9Delegate, this); } } if (!running10) { running10 = true; awaiter10 = enumerator10.MoveNextAsync().GetAwaiter(); if (awaiter10.IsCompleted) { Completed10(this); } else { awaiter10.SourceOnCompleted(Completed10Delegate, this); } } if (!running11) { running11 = true; awaiter11 = enumerator11.MoveNextAsync().GetAwaiter(); if (awaiter11.IsCompleted) { Completed11(this); } else { awaiter11.SourceOnCompleted(Completed11Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed8(object state) { var self = (_CombineLatest)state; self.running8 = false; try { if (self.awaiter8.GetResult()) { self.hasCurrent8 = true; self.current8 = self.enumerator8.Current; goto SUCCESS; } else { self.running8 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running8 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running8 = true; // as complete, no more call MoveNextAsync. try { self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter8.SourceOnCompleted(Completed8Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed9(object state) { var self = (_CombineLatest)state; self.running9 = false; try { if (self.awaiter9.GetResult()) { self.hasCurrent9 = true; self.current9 = self.enumerator9.Current; goto SUCCESS; } else { self.running9 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running9 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running9 = true; // as complete, no more call MoveNextAsync. try { self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter9.SourceOnCompleted(Completed9Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed10(object state) { var self = (_CombineLatest)state; self.running10 = false; try { if (self.awaiter10.GetResult()) { self.hasCurrent10 = true; self.current10 = self.enumerator10.Current; goto SUCCESS; } else { self.running10 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running10 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running10 = true; // as complete, no more call MoveNextAsync. try { self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter10.SourceOnCompleted(Completed10Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed11(object state) { var self = (_CombineLatest)state; self.running11 = false; try { if (self.awaiter11.GetResult()) { self.hasCurrent11 = true; self.current11 = self.enumerator11.Current; goto SUCCESS; } else { self.running11 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running11 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running11 = true; // as complete, no more call MoveNextAsync. try { self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter11.SourceOnCompleted(Completed11Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } if (enumerator8 != null) { await enumerator8.DisposeAsync(); } if (enumerator9 != null) { await enumerator9.DisposeAsync(); } if (enumerator10 != null) { await enumerator10.DisposeAsync(); } if (enumerator11 != null) { await enumerator11.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly IUniTaskAsyncEnumerable source12; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.source12 = source12; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; static readonly Action Completed8Delegate = Completed8; static readonly Action Completed9Delegate = Completed9; static readonly Action Completed10Delegate = Completed10; static readonly Action Completed11Delegate = Completed11; static readonly Action Completed12Delegate = Completed12; const int CompleteCount = 12; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly IUniTaskAsyncEnumerable source12; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; IUniTaskAsyncEnumerator enumerator8; UniTask.Awaiter awaiter8; bool hasCurrent8; bool running8; T8 current8; IUniTaskAsyncEnumerator enumerator9; UniTask.Awaiter awaiter9; bool hasCurrent9; bool running9; T9 current9; IUniTaskAsyncEnumerator enumerator10; UniTask.Awaiter awaiter10; bool hasCurrent10; bool running10; T10 current10; IUniTaskAsyncEnumerator enumerator11; UniTask.Awaiter awaiter11; bool hasCurrent11; bool running11; T11 current11; IUniTaskAsyncEnumerator enumerator12; UniTask.Awaiter awaiter12; bool hasCurrent12; bool running12; T12 current12; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.source12 = source12; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); enumerator8 = source8.GetAsyncEnumerator(cancellationToken); enumerator9 = source9.GetAsyncEnumerator(cancellationToken); enumerator10 = source10.GetAsyncEnumerator(cancellationToken); enumerator11 = source11.GetAsyncEnumerator(cancellationToken); enumerator12 = source12.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running8) { running8 = true; awaiter8 = enumerator8.MoveNextAsync().GetAwaiter(); if (awaiter8.IsCompleted) { Completed8(this); } else { awaiter8.SourceOnCompleted(Completed8Delegate, this); } } if (!running9) { running9 = true; awaiter9 = enumerator9.MoveNextAsync().GetAwaiter(); if (awaiter9.IsCompleted) { Completed9(this); } else { awaiter9.SourceOnCompleted(Completed9Delegate, this); } } if (!running10) { running10 = true; awaiter10 = enumerator10.MoveNextAsync().GetAwaiter(); if (awaiter10.IsCompleted) { Completed10(this); } else { awaiter10.SourceOnCompleted(Completed10Delegate, this); } } if (!running11) { running11 = true; awaiter11 = enumerator11.MoveNextAsync().GetAwaiter(); if (awaiter11.IsCompleted) { Completed11(this); } else { awaiter11.SourceOnCompleted(Completed11Delegate, this); } } if (!running12) { running12 = true; awaiter12 = enumerator12.MoveNextAsync().GetAwaiter(); if (awaiter12.IsCompleted) { Completed12(this); } else { awaiter12.SourceOnCompleted(Completed12Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11 || !running12) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed8(object state) { var self = (_CombineLatest)state; self.running8 = false; try { if (self.awaiter8.GetResult()) { self.hasCurrent8 = true; self.current8 = self.enumerator8.Current; goto SUCCESS; } else { self.running8 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running8 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running8 = true; // as complete, no more call MoveNextAsync. try { self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter8.SourceOnCompleted(Completed8Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed9(object state) { var self = (_CombineLatest)state; self.running9 = false; try { if (self.awaiter9.GetResult()) { self.hasCurrent9 = true; self.current9 = self.enumerator9.Current; goto SUCCESS; } else { self.running9 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running9 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running9 = true; // as complete, no more call MoveNextAsync. try { self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter9.SourceOnCompleted(Completed9Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed10(object state) { var self = (_CombineLatest)state; self.running10 = false; try { if (self.awaiter10.GetResult()) { self.hasCurrent10 = true; self.current10 = self.enumerator10.Current; goto SUCCESS; } else { self.running10 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running10 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running10 = true; // as complete, no more call MoveNextAsync. try { self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter10.SourceOnCompleted(Completed10Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed11(object state) { var self = (_CombineLatest)state; self.running11 = false; try { if (self.awaiter11.GetResult()) { self.hasCurrent11 = true; self.current11 = self.enumerator11.Current; goto SUCCESS; } else { self.running11 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running11 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running11 = true; // as complete, no more call MoveNextAsync. try { self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter11.SourceOnCompleted(Completed11Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed12(object state) { var self = (_CombineLatest)state; self.running12 = false; try { if (self.awaiter12.GetResult()) { self.hasCurrent12 = true; self.current12 = self.enumerator12.Current; goto SUCCESS; } else { self.running12 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running12 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running12 = true; // as complete, no more call MoveNextAsync. try { self.awaiter12 = self.enumerator12.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter12.SourceOnCompleted(Completed12Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11 && hasCurrent12) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11, current12); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } if (enumerator8 != null) { await enumerator8.DisposeAsync(); } if (enumerator9 != null) { await enumerator9.DisposeAsync(); } if (enumerator10 != null) { await enumerator10.DisposeAsync(); } if (enumerator11 != null) { await enumerator11.DisposeAsync(); } if (enumerator12 != null) { await enumerator12.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly IUniTaskAsyncEnumerable source12; readonly IUniTaskAsyncEnumerable source13; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.source12 = source12; this.source13 = source13; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; static readonly Action Completed8Delegate = Completed8; static readonly Action Completed9Delegate = Completed9; static readonly Action Completed10Delegate = Completed10; static readonly Action Completed11Delegate = Completed11; static readonly Action Completed12Delegate = Completed12; static readonly Action Completed13Delegate = Completed13; const int CompleteCount = 13; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly IUniTaskAsyncEnumerable source12; readonly IUniTaskAsyncEnumerable source13; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; IUniTaskAsyncEnumerator enumerator8; UniTask.Awaiter awaiter8; bool hasCurrent8; bool running8; T8 current8; IUniTaskAsyncEnumerator enumerator9; UniTask.Awaiter awaiter9; bool hasCurrent9; bool running9; T9 current9; IUniTaskAsyncEnumerator enumerator10; UniTask.Awaiter awaiter10; bool hasCurrent10; bool running10; T10 current10; IUniTaskAsyncEnumerator enumerator11; UniTask.Awaiter awaiter11; bool hasCurrent11; bool running11; T11 current11; IUniTaskAsyncEnumerator enumerator12; UniTask.Awaiter awaiter12; bool hasCurrent12; bool running12; T12 current12; IUniTaskAsyncEnumerator enumerator13; UniTask.Awaiter awaiter13; bool hasCurrent13; bool running13; T13 current13; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.source12 = source12; this.source13 = source13; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); enumerator8 = source8.GetAsyncEnumerator(cancellationToken); enumerator9 = source9.GetAsyncEnumerator(cancellationToken); enumerator10 = source10.GetAsyncEnumerator(cancellationToken); enumerator11 = source11.GetAsyncEnumerator(cancellationToken); enumerator12 = source12.GetAsyncEnumerator(cancellationToken); enumerator13 = source13.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running8) { running8 = true; awaiter8 = enumerator8.MoveNextAsync().GetAwaiter(); if (awaiter8.IsCompleted) { Completed8(this); } else { awaiter8.SourceOnCompleted(Completed8Delegate, this); } } if (!running9) { running9 = true; awaiter9 = enumerator9.MoveNextAsync().GetAwaiter(); if (awaiter9.IsCompleted) { Completed9(this); } else { awaiter9.SourceOnCompleted(Completed9Delegate, this); } } if (!running10) { running10 = true; awaiter10 = enumerator10.MoveNextAsync().GetAwaiter(); if (awaiter10.IsCompleted) { Completed10(this); } else { awaiter10.SourceOnCompleted(Completed10Delegate, this); } } if (!running11) { running11 = true; awaiter11 = enumerator11.MoveNextAsync().GetAwaiter(); if (awaiter11.IsCompleted) { Completed11(this); } else { awaiter11.SourceOnCompleted(Completed11Delegate, this); } } if (!running12) { running12 = true; awaiter12 = enumerator12.MoveNextAsync().GetAwaiter(); if (awaiter12.IsCompleted) { Completed12(this); } else { awaiter12.SourceOnCompleted(Completed12Delegate, this); } } if (!running13) { running13 = true; awaiter13 = enumerator13.MoveNextAsync().GetAwaiter(); if (awaiter13.IsCompleted) { Completed13(this); } else { awaiter13.SourceOnCompleted(Completed13Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11 || !running12 || !running13) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed8(object state) { var self = (_CombineLatest)state; self.running8 = false; try { if (self.awaiter8.GetResult()) { self.hasCurrent8 = true; self.current8 = self.enumerator8.Current; goto SUCCESS; } else { self.running8 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running8 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running8 = true; // as complete, no more call MoveNextAsync. try { self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter8.SourceOnCompleted(Completed8Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed9(object state) { var self = (_CombineLatest)state; self.running9 = false; try { if (self.awaiter9.GetResult()) { self.hasCurrent9 = true; self.current9 = self.enumerator9.Current; goto SUCCESS; } else { self.running9 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running9 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running9 = true; // as complete, no more call MoveNextAsync. try { self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter9.SourceOnCompleted(Completed9Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed10(object state) { var self = (_CombineLatest)state; self.running10 = false; try { if (self.awaiter10.GetResult()) { self.hasCurrent10 = true; self.current10 = self.enumerator10.Current; goto SUCCESS; } else { self.running10 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running10 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running10 = true; // as complete, no more call MoveNextAsync. try { self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter10.SourceOnCompleted(Completed10Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed11(object state) { var self = (_CombineLatest)state; self.running11 = false; try { if (self.awaiter11.GetResult()) { self.hasCurrent11 = true; self.current11 = self.enumerator11.Current; goto SUCCESS; } else { self.running11 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running11 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running11 = true; // as complete, no more call MoveNextAsync. try { self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter11.SourceOnCompleted(Completed11Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed12(object state) { var self = (_CombineLatest)state; self.running12 = false; try { if (self.awaiter12.GetResult()) { self.hasCurrent12 = true; self.current12 = self.enumerator12.Current; goto SUCCESS; } else { self.running12 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running12 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running12 = true; // as complete, no more call MoveNextAsync. try { self.awaiter12 = self.enumerator12.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter12.SourceOnCompleted(Completed12Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed13(object state) { var self = (_CombineLatest)state; self.running13 = false; try { if (self.awaiter13.GetResult()) { self.hasCurrent13 = true; self.current13 = self.enumerator13.Current; goto SUCCESS; } else { self.running13 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running13 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running13 = true; // as complete, no more call MoveNextAsync. try { self.awaiter13 = self.enumerator13.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter13.SourceOnCompleted(Completed13Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11 && hasCurrent12 && hasCurrent13) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11, current12, current13); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } if (enumerator8 != null) { await enumerator8.DisposeAsync(); } if (enumerator9 != null) { await enumerator9.DisposeAsync(); } if (enumerator10 != null) { await enumerator10.DisposeAsync(); } if (enumerator11 != null) { await enumerator11.DisposeAsync(); } if (enumerator12 != null) { await enumerator12.DisposeAsync(); } if (enumerator13 != null) { await enumerator13.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly IUniTaskAsyncEnumerable source12; readonly IUniTaskAsyncEnumerable source13; readonly IUniTaskAsyncEnumerable source14; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, IUniTaskAsyncEnumerable source14, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.source12 = source12; this.source13 = source13; this.source14 = source14; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, source14, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; static readonly Action Completed8Delegate = Completed8; static readonly Action Completed9Delegate = Completed9; static readonly Action Completed10Delegate = Completed10; static readonly Action Completed11Delegate = Completed11; static readonly Action Completed12Delegate = Completed12; static readonly Action Completed13Delegate = Completed13; static readonly Action Completed14Delegate = Completed14; const int CompleteCount = 14; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly IUniTaskAsyncEnumerable source12; readonly IUniTaskAsyncEnumerable source13; readonly IUniTaskAsyncEnumerable source14; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; IUniTaskAsyncEnumerator enumerator8; UniTask.Awaiter awaiter8; bool hasCurrent8; bool running8; T8 current8; IUniTaskAsyncEnumerator enumerator9; UniTask.Awaiter awaiter9; bool hasCurrent9; bool running9; T9 current9; IUniTaskAsyncEnumerator enumerator10; UniTask.Awaiter awaiter10; bool hasCurrent10; bool running10; T10 current10; IUniTaskAsyncEnumerator enumerator11; UniTask.Awaiter awaiter11; bool hasCurrent11; bool running11; T11 current11; IUniTaskAsyncEnumerator enumerator12; UniTask.Awaiter awaiter12; bool hasCurrent12; bool running12; T12 current12; IUniTaskAsyncEnumerator enumerator13; UniTask.Awaiter awaiter13; bool hasCurrent13; bool running13; T13 current13; IUniTaskAsyncEnumerator enumerator14; UniTask.Awaiter awaiter14; bool hasCurrent14; bool running14; T14 current14; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, IUniTaskAsyncEnumerable source14, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.source12 = source12; this.source13 = source13; this.source14 = source14; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); enumerator8 = source8.GetAsyncEnumerator(cancellationToken); enumerator9 = source9.GetAsyncEnumerator(cancellationToken); enumerator10 = source10.GetAsyncEnumerator(cancellationToken); enumerator11 = source11.GetAsyncEnumerator(cancellationToken); enumerator12 = source12.GetAsyncEnumerator(cancellationToken); enumerator13 = source13.GetAsyncEnumerator(cancellationToken); enumerator14 = source14.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running8) { running8 = true; awaiter8 = enumerator8.MoveNextAsync().GetAwaiter(); if (awaiter8.IsCompleted) { Completed8(this); } else { awaiter8.SourceOnCompleted(Completed8Delegate, this); } } if (!running9) { running9 = true; awaiter9 = enumerator9.MoveNextAsync().GetAwaiter(); if (awaiter9.IsCompleted) { Completed9(this); } else { awaiter9.SourceOnCompleted(Completed9Delegate, this); } } if (!running10) { running10 = true; awaiter10 = enumerator10.MoveNextAsync().GetAwaiter(); if (awaiter10.IsCompleted) { Completed10(this); } else { awaiter10.SourceOnCompleted(Completed10Delegate, this); } } if (!running11) { running11 = true; awaiter11 = enumerator11.MoveNextAsync().GetAwaiter(); if (awaiter11.IsCompleted) { Completed11(this); } else { awaiter11.SourceOnCompleted(Completed11Delegate, this); } } if (!running12) { running12 = true; awaiter12 = enumerator12.MoveNextAsync().GetAwaiter(); if (awaiter12.IsCompleted) { Completed12(this); } else { awaiter12.SourceOnCompleted(Completed12Delegate, this); } } if (!running13) { running13 = true; awaiter13 = enumerator13.MoveNextAsync().GetAwaiter(); if (awaiter13.IsCompleted) { Completed13(this); } else { awaiter13.SourceOnCompleted(Completed13Delegate, this); } } if (!running14) { running14 = true; awaiter14 = enumerator14.MoveNextAsync().GetAwaiter(); if (awaiter14.IsCompleted) { Completed14(this); } else { awaiter14.SourceOnCompleted(Completed14Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11 || !running12 || !running13 || !running14) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed8(object state) { var self = (_CombineLatest)state; self.running8 = false; try { if (self.awaiter8.GetResult()) { self.hasCurrent8 = true; self.current8 = self.enumerator8.Current; goto SUCCESS; } else { self.running8 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running8 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running8 = true; // as complete, no more call MoveNextAsync. try { self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter8.SourceOnCompleted(Completed8Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed9(object state) { var self = (_CombineLatest)state; self.running9 = false; try { if (self.awaiter9.GetResult()) { self.hasCurrent9 = true; self.current9 = self.enumerator9.Current; goto SUCCESS; } else { self.running9 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running9 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running9 = true; // as complete, no more call MoveNextAsync. try { self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter9.SourceOnCompleted(Completed9Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed10(object state) { var self = (_CombineLatest)state; self.running10 = false; try { if (self.awaiter10.GetResult()) { self.hasCurrent10 = true; self.current10 = self.enumerator10.Current; goto SUCCESS; } else { self.running10 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running10 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running10 = true; // as complete, no more call MoveNextAsync. try { self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter10.SourceOnCompleted(Completed10Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed11(object state) { var self = (_CombineLatest)state; self.running11 = false; try { if (self.awaiter11.GetResult()) { self.hasCurrent11 = true; self.current11 = self.enumerator11.Current; goto SUCCESS; } else { self.running11 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running11 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running11 = true; // as complete, no more call MoveNextAsync. try { self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter11.SourceOnCompleted(Completed11Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed12(object state) { var self = (_CombineLatest)state; self.running12 = false; try { if (self.awaiter12.GetResult()) { self.hasCurrent12 = true; self.current12 = self.enumerator12.Current; goto SUCCESS; } else { self.running12 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running12 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running12 = true; // as complete, no more call MoveNextAsync. try { self.awaiter12 = self.enumerator12.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter12.SourceOnCompleted(Completed12Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed13(object state) { var self = (_CombineLatest)state; self.running13 = false; try { if (self.awaiter13.GetResult()) { self.hasCurrent13 = true; self.current13 = self.enumerator13.Current; goto SUCCESS; } else { self.running13 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running13 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running13 = true; // as complete, no more call MoveNextAsync. try { self.awaiter13 = self.enumerator13.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter13.SourceOnCompleted(Completed13Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed14(object state) { var self = (_CombineLatest)state; self.running14 = false; try { if (self.awaiter14.GetResult()) { self.hasCurrent14 = true; self.current14 = self.enumerator14.Current; goto SUCCESS; } else { self.running14 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running14 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running14 = true; // as complete, no more call MoveNextAsync. try { self.awaiter14 = self.enumerator14.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter14.SourceOnCompleted(Completed14Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11 && hasCurrent12 && hasCurrent13 && hasCurrent14) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11, current12, current13, current14); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } if (enumerator8 != null) { await enumerator8.DisposeAsync(); } if (enumerator9 != null) { await enumerator9.DisposeAsync(); } if (enumerator10 != null) { await enumerator10.DisposeAsync(); } if (enumerator11 != null) { await enumerator11.DisposeAsync(); } if (enumerator12 != null) { await enumerator12.DisposeAsync(); } if (enumerator13 != null) { await enumerator13.DisposeAsync(); } if (enumerator14 != null) { await enumerator14.DisposeAsync(); } } } } internal class CombineLatest : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly IUniTaskAsyncEnumerable source12; readonly IUniTaskAsyncEnumerable source13; readonly IUniTaskAsyncEnumerable source14; readonly IUniTaskAsyncEnumerable source15; readonly Func resultSelector; public CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, IUniTaskAsyncEnumerable source14, IUniTaskAsyncEnumerable source15, Func resultSelector) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.source12 = source12; this.source13 = source13; this.source14 = source14; this.source15 = source15; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(source1, source2, source3, source4, source5, source6, source7, source8, source9, source10, source11, source12, source13, source14, source15, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action Completed1Delegate = Completed1; static readonly Action Completed2Delegate = Completed2; static readonly Action Completed3Delegate = Completed3; static readonly Action Completed4Delegate = Completed4; static readonly Action Completed5Delegate = Completed5; static readonly Action Completed6Delegate = Completed6; static readonly Action Completed7Delegate = Completed7; static readonly Action Completed8Delegate = Completed8; static readonly Action Completed9Delegate = Completed9; static readonly Action Completed10Delegate = Completed10; static readonly Action Completed11Delegate = Completed11; static readonly Action Completed12Delegate = Completed12; static readonly Action Completed13Delegate = Completed13; static readonly Action Completed14Delegate = Completed14; static readonly Action Completed15Delegate = Completed15; const int CompleteCount = 15; readonly IUniTaskAsyncEnumerable source1; readonly IUniTaskAsyncEnumerable source2; readonly IUniTaskAsyncEnumerable source3; readonly IUniTaskAsyncEnumerable source4; readonly IUniTaskAsyncEnumerable source5; readonly IUniTaskAsyncEnumerable source6; readonly IUniTaskAsyncEnumerable source7; readonly IUniTaskAsyncEnumerable source8; readonly IUniTaskAsyncEnumerable source9; readonly IUniTaskAsyncEnumerable source10; readonly IUniTaskAsyncEnumerable source11; readonly IUniTaskAsyncEnumerable source12; readonly IUniTaskAsyncEnumerable source13; readonly IUniTaskAsyncEnumerable source14; readonly IUniTaskAsyncEnumerable source15; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator1; UniTask.Awaiter awaiter1; bool hasCurrent1; bool running1; T1 current1; IUniTaskAsyncEnumerator enumerator2; UniTask.Awaiter awaiter2; bool hasCurrent2; bool running2; T2 current2; IUniTaskAsyncEnumerator enumerator3; UniTask.Awaiter awaiter3; bool hasCurrent3; bool running3; T3 current3; IUniTaskAsyncEnumerator enumerator4; UniTask.Awaiter awaiter4; bool hasCurrent4; bool running4; T4 current4; IUniTaskAsyncEnumerator enumerator5; UniTask.Awaiter awaiter5; bool hasCurrent5; bool running5; T5 current5; IUniTaskAsyncEnumerator enumerator6; UniTask.Awaiter awaiter6; bool hasCurrent6; bool running6; T6 current6; IUniTaskAsyncEnumerator enumerator7; UniTask.Awaiter awaiter7; bool hasCurrent7; bool running7; T7 current7; IUniTaskAsyncEnumerator enumerator8; UniTask.Awaiter awaiter8; bool hasCurrent8; bool running8; T8 current8; IUniTaskAsyncEnumerator enumerator9; UniTask.Awaiter awaiter9; bool hasCurrent9; bool running9; T9 current9; IUniTaskAsyncEnumerator enumerator10; UniTask.Awaiter awaiter10; bool hasCurrent10; bool running10; T10 current10; IUniTaskAsyncEnumerator enumerator11; UniTask.Awaiter awaiter11; bool hasCurrent11; bool running11; T11 current11; IUniTaskAsyncEnumerator enumerator12; UniTask.Awaiter awaiter12; bool hasCurrent12; bool running12; T12 current12; IUniTaskAsyncEnumerator enumerator13; UniTask.Awaiter awaiter13; bool hasCurrent13; bool running13; T13 current13; IUniTaskAsyncEnumerator enumerator14; UniTask.Awaiter awaiter14; bool hasCurrent14; bool running14; T14 current14; IUniTaskAsyncEnumerator enumerator15; UniTask.Awaiter awaiter15; bool hasCurrent15; bool running15; T15 current15; int completedCount; bool syncRunning; TResult result; public _CombineLatest(IUniTaskAsyncEnumerable source1, IUniTaskAsyncEnumerable source2, IUniTaskAsyncEnumerable source3, IUniTaskAsyncEnumerable source4, IUniTaskAsyncEnumerable source5, IUniTaskAsyncEnumerable source6, IUniTaskAsyncEnumerable source7, IUniTaskAsyncEnumerable source8, IUniTaskAsyncEnumerable source9, IUniTaskAsyncEnumerable source10, IUniTaskAsyncEnumerable source11, IUniTaskAsyncEnumerable source12, IUniTaskAsyncEnumerable source13, IUniTaskAsyncEnumerable source14, IUniTaskAsyncEnumerable source15, Func resultSelector, CancellationToken cancellationToken) { this.source1 = source1; this.source2 = source2; this.source3 = source3; this.source4 = source4; this.source5 = source5; this.source6 = source6; this.source7 = source7; this.source8 = source8; this.source9 = source9; this.source10 = source10; this.source11 = source11; this.source12 = source12; this.source13 = source13; this.source14 = source14; this.source15 = source15; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { enumerator1 = source1.GetAsyncEnumerator(cancellationToken); enumerator2 = source2.GetAsyncEnumerator(cancellationToken); enumerator3 = source3.GetAsyncEnumerator(cancellationToken); enumerator4 = source4.GetAsyncEnumerator(cancellationToken); enumerator5 = source5.GetAsyncEnumerator(cancellationToken); enumerator6 = source6.GetAsyncEnumerator(cancellationToken); enumerator7 = source7.GetAsyncEnumerator(cancellationToken); enumerator8 = source8.GetAsyncEnumerator(cancellationToken); enumerator9 = source9.GetAsyncEnumerator(cancellationToken); enumerator10 = source10.GetAsyncEnumerator(cancellationToken); enumerator11 = source11.GetAsyncEnumerator(cancellationToken); enumerator12 = source12.GetAsyncEnumerator(cancellationToken); enumerator13 = source13.GetAsyncEnumerator(cancellationToken); enumerator14 = source14.GetAsyncEnumerator(cancellationToken); enumerator15 = source15.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); AGAIN: syncRunning = true; if (!running1) { running1 = true; awaiter1 = enumerator1.MoveNextAsync().GetAwaiter(); if (awaiter1.IsCompleted) { Completed1(this); } else { awaiter1.SourceOnCompleted(Completed1Delegate, this); } } if (!running2) { running2 = true; awaiter2 = enumerator2.MoveNextAsync().GetAwaiter(); if (awaiter2.IsCompleted) { Completed2(this); } else { awaiter2.SourceOnCompleted(Completed2Delegate, this); } } if (!running3) { running3 = true; awaiter3 = enumerator3.MoveNextAsync().GetAwaiter(); if (awaiter3.IsCompleted) { Completed3(this); } else { awaiter3.SourceOnCompleted(Completed3Delegate, this); } } if (!running4) { running4 = true; awaiter4 = enumerator4.MoveNextAsync().GetAwaiter(); if (awaiter4.IsCompleted) { Completed4(this); } else { awaiter4.SourceOnCompleted(Completed4Delegate, this); } } if (!running5) { running5 = true; awaiter5 = enumerator5.MoveNextAsync().GetAwaiter(); if (awaiter5.IsCompleted) { Completed5(this); } else { awaiter5.SourceOnCompleted(Completed5Delegate, this); } } if (!running6) { running6 = true; awaiter6 = enumerator6.MoveNextAsync().GetAwaiter(); if (awaiter6.IsCompleted) { Completed6(this); } else { awaiter6.SourceOnCompleted(Completed6Delegate, this); } } if (!running7) { running7 = true; awaiter7 = enumerator7.MoveNextAsync().GetAwaiter(); if (awaiter7.IsCompleted) { Completed7(this); } else { awaiter7.SourceOnCompleted(Completed7Delegate, this); } } if (!running8) { running8 = true; awaiter8 = enumerator8.MoveNextAsync().GetAwaiter(); if (awaiter8.IsCompleted) { Completed8(this); } else { awaiter8.SourceOnCompleted(Completed8Delegate, this); } } if (!running9) { running9 = true; awaiter9 = enumerator9.MoveNextAsync().GetAwaiter(); if (awaiter9.IsCompleted) { Completed9(this); } else { awaiter9.SourceOnCompleted(Completed9Delegate, this); } } if (!running10) { running10 = true; awaiter10 = enumerator10.MoveNextAsync().GetAwaiter(); if (awaiter10.IsCompleted) { Completed10(this); } else { awaiter10.SourceOnCompleted(Completed10Delegate, this); } } if (!running11) { running11 = true; awaiter11 = enumerator11.MoveNextAsync().GetAwaiter(); if (awaiter11.IsCompleted) { Completed11(this); } else { awaiter11.SourceOnCompleted(Completed11Delegate, this); } } if (!running12) { running12 = true; awaiter12 = enumerator12.MoveNextAsync().GetAwaiter(); if (awaiter12.IsCompleted) { Completed12(this); } else { awaiter12.SourceOnCompleted(Completed12Delegate, this); } } if (!running13) { running13 = true; awaiter13 = enumerator13.MoveNextAsync().GetAwaiter(); if (awaiter13.IsCompleted) { Completed13(this); } else { awaiter13.SourceOnCompleted(Completed13Delegate, this); } } if (!running14) { running14 = true; awaiter14 = enumerator14.MoveNextAsync().GetAwaiter(); if (awaiter14.IsCompleted) { Completed14(this); } else { awaiter14.SourceOnCompleted(Completed14Delegate, this); } } if (!running15) { running15 = true; awaiter15 = enumerator15.MoveNextAsync().GetAwaiter(); if (awaiter15.IsCompleted) { Completed15(this); } else { awaiter15.SourceOnCompleted(Completed15Delegate, this); } } if (!running1 || !running2 || !running3 || !running4 || !running5 || !running6 || !running7 || !running8 || !running9 || !running10 || !running11 || !running12 || !running13 || !running14 || !running15) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } static void Completed1(object state) { var self = (_CombineLatest)state; self.running1 = false; try { if (self.awaiter1.GetResult()) { self.hasCurrent1 = true; self.current1 = self.enumerator1.Current; goto SUCCESS; } else { self.running1 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running1 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running1 = true; // as complete, no more call MoveNextAsync. try { self.awaiter1 = self.enumerator1.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter1.SourceOnCompleted(Completed1Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed2(object state) { var self = (_CombineLatest)state; self.running2 = false; try { if (self.awaiter2.GetResult()) { self.hasCurrent2 = true; self.current2 = self.enumerator2.Current; goto SUCCESS; } else { self.running2 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running2 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running2 = true; // as complete, no more call MoveNextAsync. try { self.awaiter2 = self.enumerator2.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter2.SourceOnCompleted(Completed2Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed3(object state) { var self = (_CombineLatest)state; self.running3 = false; try { if (self.awaiter3.GetResult()) { self.hasCurrent3 = true; self.current3 = self.enumerator3.Current; goto SUCCESS; } else { self.running3 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running3 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running3 = true; // as complete, no more call MoveNextAsync. try { self.awaiter3 = self.enumerator3.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter3.SourceOnCompleted(Completed3Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed4(object state) { var self = (_CombineLatest)state; self.running4 = false; try { if (self.awaiter4.GetResult()) { self.hasCurrent4 = true; self.current4 = self.enumerator4.Current; goto SUCCESS; } else { self.running4 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running4 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running4 = true; // as complete, no more call MoveNextAsync. try { self.awaiter4 = self.enumerator4.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter4.SourceOnCompleted(Completed4Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed5(object state) { var self = (_CombineLatest)state; self.running5 = false; try { if (self.awaiter5.GetResult()) { self.hasCurrent5 = true; self.current5 = self.enumerator5.Current; goto SUCCESS; } else { self.running5 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running5 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running5 = true; // as complete, no more call MoveNextAsync. try { self.awaiter5 = self.enumerator5.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter5.SourceOnCompleted(Completed5Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed6(object state) { var self = (_CombineLatest)state; self.running6 = false; try { if (self.awaiter6.GetResult()) { self.hasCurrent6 = true; self.current6 = self.enumerator6.Current; goto SUCCESS; } else { self.running6 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running6 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running6 = true; // as complete, no more call MoveNextAsync. try { self.awaiter6 = self.enumerator6.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter6.SourceOnCompleted(Completed6Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed7(object state) { var self = (_CombineLatest)state; self.running7 = false; try { if (self.awaiter7.GetResult()) { self.hasCurrent7 = true; self.current7 = self.enumerator7.Current; goto SUCCESS; } else { self.running7 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running7 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running7 = true; // as complete, no more call MoveNextAsync. try { self.awaiter7 = self.enumerator7.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter7.SourceOnCompleted(Completed7Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed8(object state) { var self = (_CombineLatest)state; self.running8 = false; try { if (self.awaiter8.GetResult()) { self.hasCurrent8 = true; self.current8 = self.enumerator8.Current; goto SUCCESS; } else { self.running8 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running8 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running8 = true; // as complete, no more call MoveNextAsync. try { self.awaiter8 = self.enumerator8.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter8.SourceOnCompleted(Completed8Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed9(object state) { var self = (_CombineLatest)state; self.running9 = false; try { if (self.awaiter9.GetResult()) { self.hasCurrent9 = true; self.current9 = self.enumerator9.Current; goto SUCCESS; } else { self.running9 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running9 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running9 = true; // as complete, no more call MoveNextAsync. try { self.awaiter9 = self.enumerator9.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter9.SourceOnCompleted(Completed9Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed10(object state) { var self = (_CombineLatest)state; self.running10 = false; try { if (self.awaiter10.GetResult()) { self.hasCurrent10 = true; self.current10 = self.enumerator10.Current; goto SUCCESS; } else { self.running10 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running10 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running10 = true; // as complete, no more call MoveNextAsync. try { self.awaiter10 = self.enumerator10.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter10.SourceOnCompleted(Completed10Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed11(object state) { var self = (_CombineLatest)state; self.running11 = false; try { if (self.awaiter11.GetResult()) { self.hasCurrent11 = true; self.current11 = self.enumerator11.Current; goto SUCCESS; } else { self.running11 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running11 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running11 = true; // as complete, no more call MoveNextAsync. try { self.awaiter11 = self.enumerator11.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter11.SourceOnCompleted(Completed11Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed12(object state) { var self = (_CombineLatest)state; self.running12 = false; try { if (self.awaiter12.GetResult()) { self.hasCurrent12 = true; self.current12 = self.enumerator12.Current; goto SUCCESS; } else { self.running12 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running12 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running12 = true; // as complete, no more call MoveNextAsync. try { self.awaiter12 = self.enumerator12.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter12.SourceOnCompleted(Completed12Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed13(object state) { var self = (_CombineLatest)state; self.running13 = false; try { if (self.awaiter13.GetResult()) { self.hasCurrent13 = true; self.current13 = self.enumerator13.Current; goto SUCCESS; } else { self.running13 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running13 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running13 = true; // as complete, no more call MoveNextAsync. try { self.awaiter13 = self.enumerator13.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter13.SourceOnCompleted(Completed13Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed14(object state) { var self = (_CombineLatest)state; self.running14 = false; try { if (self.awaiter14.GetResult()) { self.hasCurrent14 = true; self.current14 = self.enumerator14.Current; goto SUCCESS; } else { self.running14 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running14 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running14 = true; // as complete, no more call MoveNextAsync. try { self.awaiter14 = self.enumerator14.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter14.SourceOnCompleted(Completed14Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } static void Completed15(object state) { var self = (_CombineLatest)state; self.running15 = false; try { if (self.awaiter15.GetResult()) { self.hasCurrent15 = true; self.current15 = self.enumerator15.Current; goto SUCCESS; } else { self.running15 = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running15 = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running15 = true; // as complete, no more call MoveNextAsync. try { self.awaiter15 = self.enumerator15.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter15.SourceOnCompleted(Completed15Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } bool TrySetResult() { if (hasCurrent1 && hasCurrent2 && hasCurrent3 && hasCurrent4 && hasCurrent5 && hasCurrent6 && hasCurrent7 && hasCurrent8 && hasCurrent9 && hasCurrent10 && hasCurrent11 && hasCurrent12 && hasCurrent13 && hasCurrent14 && hasCurrent15) { result = resultSelector(current1, current2, current3, current4, current5, current6, current7, current8, current9, current10, current11, current12, current13, current14, current15); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator1 != null) { await enumerator1.DisposeAsync(); } if (enumerator2 != null) { await enumerator2.DisposeAsync(); } if (enumerator3 != null) { await enumerator3.DisposeAsync(); } if (enumerator4 != null) { await enumerator4.DisposeAsync(); } if (enumerator5 != null) { await enumerator5.DisposeAsync(); } if (enumerator6 != null) { await enumerator6.DisposeAsync(); } if (enumerator7 != null) { await enumerator7.DisposeAsync(); } if (enumerator8 != null) { await enumerator8.DisposeAsync(); } if (enumerator9 != null) { await enumerator9.DisposeAsync(); } if (enumerator10 != null) { await enumerator10.DisposeAsync(); } if (enumerator11 != null) { await enumerator11.DisposeAsync(); } if (enumerator12 != null) { await enumerator12.DisposeAsync(); } if (enumerator13 != null) { await enumerator13.DisposeAsync(); } if (enumerator14 != null) { await enumerator14.DisposeAsync(); } if (enumerator15 != null) { await enumerator15.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.cs.meta ================================================ fileFormatVersion: 2 guid: 6cb07f6e88287e34d9b9301a572284a5 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> <# var tMax = 15; Func typeArgs = x => string.Join(", ", Enumerable.Range(1, x).Select(x => $"T{x}")) + ", TResult"; Func paramArgs = x => string.Join(", ", Enumerable.Range(1, x).Select(x => $"IUniTaskAsyncEnumerable source{x}")); Func parameters = x => string.Join(", ", Enumerable.Range(1, x).Select(x => $"source{x}")); #> using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { <# for(var i = 2; i <= tMax; i++) { #> public static IUniTaskAsyncEnumerable CombineLatest<<#= typeArgs(i) #>>(this <#= paramArgs(i) #>, Func<<#= typeArgs(i) #>> resultSelector) { <# for(var j = 1; j <= i; j++) { #> Error.ThrowArgumentNullException(source<#= j #>, nameof(source<#= j #>)); <# } #> Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new CombineLatest<<#= typeArgs(i) #>>(<#= parameters(i) #>, resultSelector); } <# } #> } <# for(var i = 2; i <= tMax; i++) { #> internal class CombineLatest<<#= typeArgs(i) #>> : IUniTaskAsyncEnumerable { <# for(var j = 1; j <= i; j++) { #> readonly IUniTaskAsyncEnumerable> source<#= j #>; <# } #> readonly Func<<#= typeArgs(i) #>> resultSelector; public CombineLatest(<#= paramArgs(i) #>, Func<<#= typeArgs(i) #>> resultSelector) { <# for(var j = 1; j <= i; j++) { #> this.source<#= j #> = source<#= j #>; <# } #> this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _CombineLatest(<#= parameters(i) #>, resultSelector, cancellationToken); } class _CombineLatest : MoveNextSource, IUniTaskAsyncEnumerator { <# for(var j = 1; j <= i; j++) { #> static readonly Action Completed<#= j #>Delegate = Completed<#= j #>; <# } #> const int CompleteCount = <#= i #>; <# for(var j = 1; j <= i; j++) { #> readonly IUniTaskAsyncEnumerable> source<#= j #>; <# } #> readonly Func<<#= typeArgs(i) #>> resultSelector; CancellationToken cancellationToken; <# for(var j = 1; j <= i; j++) { #> IUniTaskAsyncEnumerator> enumerator<#= j #>; UniTask.Awaiter awaiter<#= j #>; bool hasCurrent<#= j #>; bool running<#= j #>; T<#= j #> current<#= j #>; <# } #> int completedCount; bool syncRunning; TResult result; public _CombineLatest(<#= paramArgs(i) #>, Func<<#= typeArgs(i) #>> resultSelector, CancellationToken cancellationToken) { <# for(var j = 1; j <= i; j++) { #> this.source<#= j #> = source<#= j #>; <# } #> this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current => result; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (completedCount == CompleteCount) return CompletedTasks.False; if (enumerator1 == null) { <# for(var j = 1; j <= i; j++) { #> enumerator<#= j #> = source<#= j #>.GetAsyncEnumerator(cancellationToken); <# } #> } completionSource.Reset(); AGAIN: syncRunning = true; <# for(var j = 1; j <= i; j++) { #> if (!running<#= j #>) { running<#= j #> = true; awaiter<#= j #> = enumerator<#= j #>.MoveNextAsync().GetAwaiter(); if (awaiter<#= j #>.IsCompleted) { Completed<#= j #>(this); } else { awaiter<#= j #>.SourceOnCompleted(Completed<#= j #>Delegate, this); } } <# } #> if (<#= string.Join(" || ", Enumerable.Range(1, i).Select(x => $"!running{x}")) #>) { goto AGAIN; } syncRunning = false; return new UniTask(this, completionSource.Version); } <# for(var j = 1; j <= i; j++) { #> static void Completed<#= j #>(object state) { var self = (_CombineLatest)state; self.running<#= j #> = false; try { if (self.awaiter<#= j #>.GetResult()) { self.hasCurrent<#= j #> = true; self.current<#= j #> = self.enumerator<#= j #>.Current; goto SUCCESS; } else { self.running<#= j #> = true; // as complete, no more call MoveNextAsync. if (Interlocked.Increment(ref self.completedCount) == CompleteCount) { goto COMPLETE; } return; } } catch (Exception ex) { self.running<#= j #> = true; // as complete, no more call MoveNextAsync. self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } SUCCESS: if (!self.TrySetResult()) { if (self.syncRunning) return; self.running<#= j #> = true; // as complete, no more call MoveNextAsync. try { self.awaiter<#= j #> = self.enumerator<#= j #>.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completedCount = CompleteCount; self.completionSource.TrySetException(ex); return; } self.awaiter<#= j #>.SourceOnCompleted(Completed<#= j #>Delegate, self); } return; COMPLETE: self.completionSource.TrySetResult(false); return; } <# } #> bool TrySetResult() { if (<#= string.Join(" && ", Enumerable.Range(1, i).Select(x => $"hasCurrent{x}")) #>) { result = resultSelector(<#= string.Join(", ", Enumerable.Range(1, i).Select(x => $"current{x}")) #>); completionSource.TrySetResult(true); return true; } else { return false; } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); <# for(var j = 1; j <= i; j++) { #> if (enumerator<#= j #> != null) { await enumerator<#= j #>.DisposeAsync(); } <# } #> } } } <# } #> } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/CombineLatest.tt.meta ================================================ fileFormatVersion: 2 guid: b1b8cfa9d17af814a971ee2224aaaaa2 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Concat.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Concat(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); return new Concat(first, second); } } internal sealed class Concat : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; public Concat(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second) { this.first = first; this.second = second; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Concat(first, second, cancellationToken); } sealed class _Concat : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; enum IteratingState { IteratingFirst, IteratingSecond, Complete } readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; CancellationToken cancellationToken; IteratingState iteratingState; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; public _Concat(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, CancellationToken cancellationToken) { this.first = first; this.second = second; this.cancellationToken = cancellationToken; this.iteratingState = IteratingState.IteratingFirst; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (iteratingState == IteratingState.Complete) return CompletedTasks.False; completionSource.Reset(); StartIterate(); return new UniTask(this, completionSource.Version); } void StartIterate() { if (enumerator == null) { if (iteratingState == IteratingState.IteratingFirst) { enumerator = first.GetAsyncEnumerator(cancellationToken); } else if (iteratingState == IteratingState.IteratingSecond) { enumerator = second.GetAsyncEnumerator(cancellationToken); } } try { awaiter = enumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } if (awaiter.IsCompleted) { MoveNextCoreDelegate(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } static void MoveNextCore(object state) { var self = (_Concat)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.Current = self.enumerator.Current; self.completionSource.TrySetResult(true); } else { if (self.iteratingState == IteratingState.IteratingFirst) { self.RunSecondAfterDisposeAsync().Forget(); return; } self.iteratingState = IteratingState.Complete; self.completionSource.TrySetResult(false); } } } async UniTaskVoid RunSecondAfterDisposeAsync() { try { await enumerator.DisposeAsync(); enumerator = null; awaiter = default; iteratingState = IteratingState.IteratingSecond; } catch (Exception ex) { completionSource.TrySetException(ex); } StartIterate(); } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Concat.cs.meta ================================================ fileFormatVersion: 2 guid: 7cb9e19c449127a459851a135ce7d527 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Contains.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask ContainsAsync(this IUniTaskAsyncEnumerable source, TSource value, CancellationToken cancellationToken = default) { return ContainsAsync(source, value, EqualityComparer.Default, cancellationToken); } public static UniTask ContainsAsync(this IUniTaskAsyncEnumerable source, TSource value, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return Contains.ContainsAsync(source, value, comparer, cancellationToken); } } internal static class Contains { internal static async UniTask ContainsAsync(IUniTaskAsyncEnumerable source, TSource value, IEqualityComparer comparer, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (comparer.Equals(value, e.Current)) { return true; } } return false; } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Contains.cs.meta ================================================ fileFormatVersion: 2 guid: 36ab06d30f3223048b4f676e05431a7f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Count.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask CountAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Count.CountAsync(source, cancellationToken); } public static UniTask CountAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Count.CountAsync(source, predicate, cancellationToken); } public static UniTask CountAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Count.CountAwaitAsync(source, predicate, cancellationToken); } public static UniTask CountAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Count.CountAwaitWithCancellationAsync(source, predicate, cancellationToken); } } internal static class Count { internal static async UniTask CountAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { var count = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return count; } internal static async UniTask CountAsync(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) { var count = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (predicate(e.Current)) { checked { count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return count; } internal static async UniTask CountAwaitAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { var count = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (await predicate(e.Current)) { checked { count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return count; } internal static async UniTask CountAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { var count = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (await predicate(e.Current, cancellationToken)) { checked { count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return count; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Count.cs.meta ================================================ fileFormatVersion: 2 guid: e606d38eed688574bb2ba89d983cc9bb MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Create.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Create(Func, CancellationToken, UniTask> create) { Error.ThrowArgumentNullException(create, nameof(create)); return new Create(create); } } public interface IAsyncWriter { UniTask YieldAsync(T value); } internal sealed class Create : IUniTaskAsyncEnumerable { readonly Func, CancellationToken, UniTask> create; public Create(Func, CancellationToken, UniTask> create) { this.create = create; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Create(create, cancellationToken); } sealed class _Create : MoveNextSource, IUniTaskAsyncEnumerator { readonly Func, CancellationToken, UniTask> create; readonly CancellationToken cancellationToken; int state = -1; AsyncWriter writer; public _Create(Func, CancellationToken, UniTask> create, CancellationToken cancellationToken) { this.create = create; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public T Current { get; private set; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); writer.Dispose(); return default; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { try { switch (state) { case -1: // init { writer = new AsyncWriter(this); RunWriterTask(create(writer, cancellationToken)).Forget(); if (Volatile.Read(ref state) == -2) { return; // complete synchronously } state = 0; // wait YieldAsync, it set TrySetResult(true) return; } case 0: writer.SignalWriter(); return; default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; } async UniTaskVoid RunWriterTask(UniTask task) { try { await task; goto DONE; } catch (Exception ex) { Volatile.Write(ref state, -2); completionSource.TrySetException(ex); return; } DONE: Volatile.Write(ref state, -2); completionSource.TrySetResult(false); } public void SetResult(T value) { Current = value; completionSource.TrySetResult(true); } } sealed class AsyncWriter : IUniTaskSource, IAsyncWriter, IDisposable { readonly _Create enumerator; UniTaskCompletionSourceCore core; public AsyncWriter(_Create enumerator) { this.enumerator = enumerator; } public void Dispose() { var status = core.GetStatus(core.Version); if (status == UniTaskStatus.Pending) { core.TrySetCanceled(); } } public void GetResult(short token) { core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTask YieldAsync(T value) { core.Reset(); enumerator.SetResult(value); return new UniTask(this, core.Version); } public void SignalWriter() { core.TrySetResult(AsyncUnit.Default); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Create.cs.meta ================================================ fileFormatVersion: 2 guid: 0202f723469f93945afa063bfb440d15 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/DefaultIfEmpty.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable DefaultIfEmpty(this IUniTaskAsyncEnumerable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new DefaultIfEmpty(source, default); } public static IUniTaskAsyncEnumerable DefaultIfEmpty(this IUniTaskAsyncEnumerable source, TSource defaultValue) { Error.ThrowArgumentNullException(source, nameof(source)); return new DefaultIfEmpty(source, defaultValue); } } internal sealed class DefaultIfEmpty : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly TSource defaultValue; public DefaultIfEmpty(IUniTaskAsyncEnumerable source, TSource defaultValue) { this.source = source; this.defaultValue = defaultValue; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _DefaultIfEmpty(source, defaultValue, cancellationToken); } sealed class _DefaultIfEmpty : MoveNextSource, IUniTaskAsyncEnumerator { enum IteratingState : byte { Empty, Iterating, Completed } static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; readonly TSource defaultValue; CancellationToken cancellationToken; IteratingState iteratingState; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; public _DefaultIfEmpty(IUniTaskAsyncEnumerable source, TSource defaultValue, CancellationToken cancellationToken) { this.source = source; this.defaultValue = defaultValue; this.cancellationToken = cancellationToken; this.iteratingState = IteratingState.Empty; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (iteratingState == IteratingState.Completed) { return CompletedTasks.False; } if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); } awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } return new UniTask(this, completionSource.Version); } static void MoveNextCore(object state) { var self = (_DefaultIfEmpty)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.iteratingState = IteratingState.Iterating; self.Current = self.enumerator.Current; self.completionSource.TrySetResult(true); } else { if (self.iteratingState == IteratingState.Empty) { self.iteratingState = IteratingState.Completed; self.Current = self.defaultValue; self.completionSource.TrySetResult(true); } else { self.completionSource.TrySetResult(false); } } } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/DefaultIfEmpty.cs.meta ================================================ fileFormatVersion: 2 guid: 19e437c039ad7e1478dbce1779ef8660 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Distinct.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Distinct(this IUniTaskAsyncEnumerable source) { return Distinct(source, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable Distinct(this IUniTaskAsyncEnumerable source, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new Distinct(source, comparer); } public static IUniTaskAsyncEnumerable Distinct(this IUniTaskAsyncEnumerable source, Func keySelector) { return Distinct(source, keySelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable Distinct(this IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new Distinct(source, keySelector, comparer); } public static IUniTaskAsyncEnumerable DistinctAwait(this IUniTaskAsyncEnumerable source, Func> keySelector) { return DistinctAwait(source, keySelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable DistinctAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new DistinctAwait(source, keySelector, comparer); } public static IUniTaskAsyncEnumerable DistinctAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector) { return DistinctAwaitWithCancellation(source, keySelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable DistinctAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new DistinctAwaitWithCancellation(source, keySelector, comparer); } } internal sealed class Distinct : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly IEqualityComparer comparer; public Distinct(IUniTaskAsyncEnumerable source, IEqualityComparer comparer) { this.source = source; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Distinct(source, comparer, cancellationToken); } class _Distinct : AsyncEnumeratorBase { readonly HashSet set; public _Distinct(IUniTaskAsyncEnumerable source, IEqualityComparer comparer, CancellationToken cancellationToken) : base(source, cancellationToken) { this.set = new HashSet(comparer); } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { var v = SourceCurrent; if (set.Add(v)) { Current = v; result = true; return true; } else { result = default; return false; } } result = false; return true; } } } internal sealed class Distinct : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func keySelector; readonly IEqualityComparer comparer; public Distinct(IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Distinct(source, keySelector, comparer, cancellationToken); } class _Distinct : AsyncEnumeratorBase { readonly HashSet set; readonly Func keySelector; public _Distinct(IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) : base(source, cancellationToken) { this.set = new HashSet(comparer); this.keySelector = keySelector; } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { var v = SourceCurrent; if (set.Add(keySelector(v))) { Current = v; result = true; return true; } else { result = default; return false; } } result = false; return true; } } } internal sealed class DistinctAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly IEqualityComparer comparer; public DistinctAwait(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _DistinctAwait(source, keySelector, comparer, cancellationToken); } class _DistinctAwait : AsyncEnumeratorAwaitSelectorBase { readonly HashSet set; readonly Func> keySelector; public _DistinctAwait(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) : base(source, cancellationToken) { this.set = new HashSet(comparer); this.keySelector = keySelector; } protected override UniTask TransformAsync(TSource sourceCurrent) { return keySelector(sourceCurrent); } protected override bool TrySetCurrentCore(TKey awaitResult, out bool terminateIteration) { if (set.Add(awaitResult)) { Current = SourceCurrent; terminateIteration = false; return true; } else { terminateIteration = false; return false; } } } } internal sealed class DistinctAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly IEqualityComparer comparer; public DistinctAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _DistinctAwaitWithCancellation(source, keySelector, comparer, cancellationToken); } class _DistinctAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase { readonly HashSet set; readonly Func> keySelector; public _DistinctAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) : base(source, cancellationToken) { this.set = new HashSet(comparer); this.keySelector = keySelector; } protected override UniTask TransformAsync(TSource sourceCurrent) { return keySelector(sourceCurrent, cancellationToken); } protected override bool TrySetCurrentCore(TKey awaitResult, out bool terminateIteration) { if (set.Add(awaitResult)) { Current = SourceCurrent; terminateIteration = false; return true; } else { terminateIteration = false; return false; } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Distinct.cs.meta ================================================ fileFormatVersion: 2 guid: 8f09903be66e5d943b243d7c19cb3811 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/DistinctUntilChanged.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable DistinctUntilChanged(this IUniTaskAsyncEnumerable source) { return DistinctUntilChanged(source, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable DistinctUntilChanged(this IUniTaskAsyncEnumerable source, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new DistinctUntilChanged(source, comparer); } public static IUniTaskAsyncEnumerable DistinctUntilChanged(this IUniTaskAsyncEnumerable source, Func keySelector) { return DistinctUntilChanged(source, keySelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable DistinctUntilChanged(this IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new DistinctUntilChanged(source, keySelector, comparer); } public static IUniTaskAsyncEnumerable DistinctUntilChangedAwait(this IUniTaskAsyncEnumerable source, Func> keySelector) { return DistinctUntilChangedAwait(source, keySelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable DistinctUntilChangedAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new DistinctUntilChangedAwait(source, keySelector, comparer); } public static IUniTaskAsyncEnumerable DistinctUntilChangedAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector) { return DistinctUntilChangedAwaitWithCancellation(source, keySelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable DistinctUntilChangedAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new DistinctUntilChangedAwaitWithCancellation(source, keySelector, comparer); } } internal sealed class DistinctUntilChanged : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly IEqualityComparer comparer; public DistinctUntilChanged(IUniTaskAsyncEnumerable source, IEqualityComparer comparer) { this.source = source; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _DistinctUntilChanged(source, comparer, cancellationToken); } sealed class _DistinctUntilChanged : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly IEqualityComparer comparer; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; Action moveNextAction; public _DistinctUntilChanged(IUniTaskAsyncEnumerable source, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.comparer = comparer; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case -3; } else { state = -3; awaiter.UnsafeOnCompleted(moveNextAction); return; } case -3: // first if (awaiter.GetResult()) { Current = enumerator.Current; goto CONTINUE; } else { goto DONE; } case 0: // normal awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { var v = enumerator.Current; if (!comparer.Equals(Current, v)) { Current = v; goto CONTINUE; } else { state = 0; goto REPEAT; } } else { goto DONE; } case -2: default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { return enumerator.DisposeAsync(); } } } internal sealed class DistinctUntilChanged : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func keySelector; readonly IEqualityComparer comparer; public DistinctUntilChanged(IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _DistinctUntilChanged(source, keySelector, comparer, cancellationToken); } sealed class _DistinctUntilChanged : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func keySelector; readonly IEqualityComparer comparer; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; Action moveNextAction; TKey prev; public _DistinctUntilChanged(IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case -3; } else { state = -3; awaiter.UnsafeOnCompleted(moveNextAction); return; } case -3: // first if (awaiter.GetResult()) { Current = enumerator.Current; goto CONTINUE; } else { goto DONE; } case 0: // normal awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { var v = enumerator.Current; var key = keySelector(v); if (!comparer.Equals(prev, key)) { prev = key; Current = v; goto CONTINUE; } else { state = 0; goto REPEAT; } } else { goto DONE; } case -2: default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { return enumerator.DisposeAsync(); } } } internal sealed class DistinctUntilChangedAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly IEqualityComparer comparer; public DistinctUntilChangedAwait(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _DistinctUntilChangedAwait(source, keySelector, comparer, cancellationToken); } sealed class _DistinctUntilChangedAwait : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly IEqualityComparer comparer; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; TSource enumeratorCurrent; TKey prev; public _DistinctUntilChangedAwait(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case -3; } else { state = -3; awaiter.UnsafeOnCompleted(moveNextAction); return; } case -3: // first if (awaiter.GetResult()) { Current = enumerator.Current; goto CONTINUE; } else { goto DONE; } case 0: // normal awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { enumeratorCurrent = enumerator.Current; awaiter2 = keySelector(enumeratorCurrent).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: var key = awaiter2.GetResult(); if (!comparer.Equals(prev, key)) { prev = key; Current = enumeratorCurrent; goto CONTINUE; } else { state = 0; goto REPEAT; } case -2: default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { return enumerator.DisposeAsync(); } } } internal sealed class DistinctUntilChangedAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly IEqualityComparer comparer; public DistinctUntilChangedAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _DistinctUntilChangedAwaitWithCancellation(source, keySelector, comparer, cancellationToken); } sealed class _DistinctUntilChangedAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly IEqualityComparer comparer; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; TSource enumeratorCurrent; TKey prev; public _DistinctUntilChangedAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.comparer = comparer; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case -3; } else { state = -3; awaiter.UnsafeOnCompleted(moveNextAction); return; } case -3: // first if (awaiter.GetResult()) { Current = enumerator.Current; goto CONTINUE; } else { goto DONE; } case 0: // normal awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { enumeratorCurrent = enumerator.Current; awaiter2 = keySelector(enumeratorCurrent, cancellationToken).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: var key = awaiter2.GetResult(); if (!comparer.Equals(prev, key)) { prev = key; Current = enumeratorCurrent; goto CONTINUE; } else { state = 0; goto REPEAT; } case -2: default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { return enumerator.DisposeAsync(); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/DistinctUntilChanged.cs.meta ================================================ fileFormatVersion: 2 guid: 0351f6767df7e644b935d4d599968162 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Do.cs ================================================ using Cysharp.Threading.Tasks; using Cysharp.Threading.Tasks.Internal; using Cysharp.Threading.Tasks.Linq; using System; using System.Threading; using System.Threading.Tasks; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Do(this IUniTaskAsyncEnumerable source, Action onNext) { Error.ThrowArgumentNullException(source, nameof(source)); return source.Do(onNext, null, null); } public static IUniTaskAsyncEnumerable Do(this IUniTaskAsyncEnumerable source, Action onNext, Action onError) { Error.ThrowArgumentNullException(source, nameof(source)); return source.Do(onNext, onError, null); } public static IUniTaskAsyncEnumerable Do(this IUniTaskAsyncEnumerable source, Action onNext, Action onCompleted) { Error.ThrowArgumentNullException(source, nameof(source)); return source.Do(onNext, null, onCompleted); } public static IUniTaskAsyncEnumerable Do(this IUniTaskAsyncEnumerable source, Action onNext, Action onError, Action onCompleted) { Error.ThrowArgumentNullException(source, nameof(source)); return new Do(source, onNext, onError, onCompleted); } public static IUniTaskAsyncEnumerable Do(this IUniTaskAsyncEnumerable source, IObserver observer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(observer, nameof(observer)); return source.Do(observer.OnNext, observer.OnError, observer.OnCompleted); // alloc delegate. } // not yet impl. //public static IUniTaskAsyncEnumerable DoAwait(this IUniTaskAsyncEnumerable source, Func onNext) //{ // throw new NotImplementedException(); //} //public static IUniTaskAsyncEnumerable DoAwait(this IUniTaskAsyncEnumerable source, Func onNext, Func onError) //{ // throw new NotImplementedException(); //} //public static IUniTaskAsyncEnumerable DoAwait(this IUniTaskAsyncEnumerable source, Func onNext, Func onCompleted) //{ // throw new NotImplementedException(); //} //public static IUniTaskAsyncEnumerable DoAwait(this IUniTaskAsyncEnumerable source, Func onNext, Func onError, Func onCompleted) //{ // throw new NotImplementedException(); //} //public static IUniTaskAsyncEnumerable DoAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func onNext) //{ // throw new NotImplementedException(); //} //public static IUniTaskAsyncEnumerable DoAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func onNext, Func onError) //{ // throw new NotImplementedException(); //} //public static IUniTaskAsyncEnumerable DoAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func onNext, Func onCompleted) //{ // throw new NotImplementedException(); //} //public static IUniTaskAsyncEnumerable DoAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func onNext, Func onError, Func onCompleted) //{ // throw new NotImplementedException(); //} } internal sealed class Do : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Action onNext; readonly Action onError; readonly Action onCompleted; public Do(IUniTaskAsyncEnumerable source, Action onNext, Action onError, Action onCompleted) { this.source = source; this.onNext = onNext; this.onError = onError; this.onCompleted = onCompleted; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Do(source, onNext, onError, onCompleted, cancellationToken); } sealed class _Do : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; readonly Action onNext; readonly Action onError; readonly Action onCompleted; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; public _Do(IUniTaskAsyncEnumerable source, Action onNext, Action onError, Action onCompleted, CancellationToken cancellationToken) { this.source = source; this.onNext = onNext; this.onError = onError; this.onCompleted = onCompleted; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); bool isCompleted = false; try { if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); } awaiter = enumerator.MoveNextAsync().GetAwaiter(); isCompleted = awaiter.IsCompleted; } catch (Exception ex) { CallTrySetExceptionAfterNotification(ex); return new UniTask(this, completionSource.Version); } if (isCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } return new UniTask(this, completionSource.Version); } void CallTrySetExceptionAfterNotification(Exception ex) { if (onError != null) { try { onError(ex); } catch (Exception ex2) { completionSource.TrySetException(ex2); return; } } completionSource.TrySetException(ex); } bool TryGetResultWithNotification(UniTask.Awaiter awaiter, out T result) { try { result = awaiter.GetResult(); return true; } catch (Exception ex) { CallTrySetExceptionAfterNotification(ex); result = default; return false; } } static void MoveNextCore(object state) { var self = (_Do)state; if (self.TryGetResultWithNotification(self.awaiter, out var result)) { if (result) { var v = self.enumerator.Current; if (self.onNext != null) { try { self.onNext(v); } catch (Exception ex) { self.CallTrySetExceptionAfterNotification(ex); } } self.Current = v; self.completionSource.TrySetResult(true); } else { if (self.onCompleted != null) { try { self.onCompleted(); } catch (Exception ex) { self.CallTrySetExceptionAfterNotification(ex); return; } } self.completionSource.TrySetResult(false); } } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Do.cs.meta ================================================ fileFormatVersion: 2 guid: dd83c8e12dedf75409b829b93146d130 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ElementAt.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask ElementAtAsync(this IUniTaskAsyncEnumerable source, int index, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return ElementAt.ElementAtAsync(source, index, cancellationToken, false); } public static UniTask ElementAtOrDefaultAsync(this IUniTaskAsyncEnumerable source, int index, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return ElementAt.ElementAtAsync(source, index, cancellationToken, true); } } internal static class ElementAt { public static async UniTask ElementAtAsync(IUniTaskAsyncEnumerable source, int index, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { int i = 0; while (await e.MoveNextAsync()) { if (i++ == index) { return e.Current; } } if (defaultIfEmpty) { return default; } else { throw Error.ArgumentOutOfRange(nameof(index)); } } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ElementAt.cs.meta ================================================ fileFormatVersion: 2 guid: c835bd2dd8555234c8919c7b8ef3b69a MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Empty.cs ================================================ using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Empty() { return Cysharp.Threading.Tasks.Linq.Empty.Instance; } } internal class Empty : IUniTaskAsyncEnumerable { public static readonly IUniTaskAsyncEnumerable Instance = new Empty(); Empty() { } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return _Empty.Instance; } class _Empty : IUniTaskAsyncEnumerator { public static readonly IUniTaskAsyncEnumerator Instance = new _Empty(); _Empty() { } public T Current => default; public UniTask MoveNextAsync() { return CompletedTasks.False; } public UniTask DisposeAsync() { return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Empty.cs.meta ================================================ fileFormatVersion: 2 guid: 4fa123ad6258abb4184721b719a13810 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Except.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Except(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); return new Except(first, second, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable Except(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new Except(first, second, comparer); } } internal sealed class Except : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; readonly IEqualityComparer comparer; public Except(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer) { this.first = first; this.second = second; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Except(first, second, comparer, cancellationToken); } class _Except : AsyncEnumeratorBase { static Action HashSetAsyncCoreDelegate = HashSetAsyncCore; readonly IEqualityComparer comparer; readonly IUniTaskAsyncEnumerable second; HashSet set; UniTask>.Awaiter awaiter; public _Except(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer, CancellationToken cancellationToken) : base(first, cancellationToken) { this.second = second; this.comparer = comparer; } protected override bool OnFirstIteration() { if (set != null) return false; awaiter = second.ToHashSetAsync(cancellationToken).GetAwaiter(); if (awaiter.IsCompleted) { set = awaiter.GetResult(); SourceMoveNext(); } else { awaiter.SourceOnCompleted(HashSetAsyncCoreDelegate, this); } return true; } static void HashSetAsyncCore(object state) { var self = (_Except)state; if (self.TryGetResult(self.awaiter, out var result)) { self.set = result; self.SourceMoveNext(); } } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { var v = SourceCurrent; if (set.Add(v)) { Current = v; result = true; return true; } else { result = default; return false; } } result = false; return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Except.cs.meta ================================================ fileFormatVersion: 2 guid: 38c1c4129f59dcb49a5b864eaf4ec63c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/First.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask FirstAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return First.FirstAsync(source, cancellationToken, false); } public static UniTask FirstAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return First.FirstAsync(source, predicate, cancellationToken, false); } public static UniTask FirstAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return First.FirstAwaitAsync(source, predicate, cancellationToken, false); } public static UniTask FirstAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return First.FirstAwaitWithCancellationAsync(source, predicate, cancellationToken, false); } public static UniTask FirstOrDefaultAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return First.FirstAsync(source, cancellationToken, true); } public static UniTask FirstOrDefaultAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return First.FirstAsync(source, predicate, cancellationToken, true); } public static UniTask FirstOrDefaultAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return First.FirstAwaitAsync(source, predicate, cancellationToken, true); } public static UniTask FirstOrDefaultAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return First.FirstAwaitWithCancellationAsync(source, predicate, cancellationToken, true); } } internal static class First { public static async UniTask FirstAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { if (await e.MoveNextAsync()) { return e.Current; } else { if (defaultIfEmpty) { return default; } else { throw Error.NoElements(); } } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask FirstAsync(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; if (predicate(v)) { return v; } } if (defaultIfEmpty) { return default; } else { throw Error.NoElements(); } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask FirstAwaitAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; if (await predicate(v)) { return v; } } if (defaultIfEmpty) { return default; } else { throw Error.NoElements(); } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask FirstAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; if (await predicate(v, cancellationToken)) { return v; } } if (defaultIfEmpty) { return default; } else { throw Error.NoElements(); } } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/First.cs.meta ================================================ fileFormatVersion: 2 guid: 417946e97e9eed84db6f840f57037ca6 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ForEach.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask ForEachAsync(this IUniTaskAsyncEnumerable source, Action action, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); return Cysharp.Threading.Tasks.Linq.ForEach.ForEachAsync(source, action, cancellationToken); } public static UniTask ForEachAsync(this IUniTaskAsyncEnumerable source, Action action, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); return Cysharp.Threading.Tasks.Linq.ForEach.ForEachAsync(source, action, cancellationToken); } /// Obsolete(Error), Use Use ForEachAwaitAsync instead. [Obsolete("Use ForEachAwaitAsync instead.", true)] [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] public static UniTask ForEachAsync(this IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken = default) { throw new NotSupportedException("Use ForEachAwaitAsync instead."); } /// Obsolete(Error), Use Use ForEachAwaitAsync instead. [Obsolete("Use ForEachAwaitAsync instead.", true)] [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] public static UniTask ForEachAsync(this IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken = default) { throw new NotSupportedException("Use ForEachAwaitAsync instead."); } public static UniTask ForEachAwaitAsync(this IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); return Cysharp.Threading.Tasks.Linq.ForEach.ForEachAwaitAsync(source, action, cancellationToken); } public static UniTask ForEachAwaitAsync(this IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); return Cysharp.Threading.Tasks.Linq.ForEach.ForEachAwaitAsync(source, action, cancellationToken); } public static UniTask ForEachAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); return Cysharp.Threading.Tasks.Linq.ForEach.ForEachAwaitWithCancellationAsync(source, action, cancellationToken); } public static UniTask ForEachAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); return Cysharp.Threading.Tasks.Linq.ForEach.ForEachAwaitWithCancellationAsync(source, action, cancellationToken); } } internal static class ForEach { public static async UniTask ForEachAsync(IUniTaskAsyncEnumerable source, Action action, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { action(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask ForEachAsync(IUniTaskAsyncEnumerable source, Action action, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { int index = 0; while (await e.MoveNextAsync()) { action(e.Current, checked(index++)); } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask ForEachAwaitAsync(IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { await action(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask ForEachAwaitAsync(IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { int index = 0; while (await e.MoveNextAsync()) { await action(e.Current, checked(index++)); } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask ForEachAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { await action(e.Current, cancellationToken); } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask ForEachAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { int index = 0; while (await e.MoveNextAsync()) { await action(e.Current, checked(index++), cancellationToken); } } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ForEach.cs.meta ================================================ fileFormatVersion: 2 guid: ca8d7f8177ba16140920af405aea3fd4 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/GroupBy.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Linq; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { // Ix-Async returns IGrouping but it is competely waste, use standard IGrouping. public static IUniTaskAsyncEnumerable> GroupBy(this IUniTaskAsyncEnumerable source, Func keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new GroupBy(source, keySelector, x => x, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable> GroupBy(this IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupBy(source, keySelector, x => x, comparer); } public static IUniTaskAsyncEnumerable> GroupBy(this IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return new GroupBy(source, keySelector, elementSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable> GroupBy(this IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupBy(source, keySelector, elementSelector, comparer); } public static IUniTaskAsyncEnumerable GroupBy(this IUniTaskAsyncEnumerable source, Func keySelector, Func, TResult> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupBy(source, keySelector, x => x, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupBy(this IUniTaskAsyncEnumerable source, Func keySelector, Func, TResult> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupBy(source, keySelector, x => x, resultSelector, comparer); } public static IUniTaskAsyncEnumerable GroupBy(this IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupBy(source, keySelector, elementSelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupBy(this IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupBy(source, keySelector, elementSelector, resultSelector, comparer); } // await public static IUniTaskAsyncEnumerable> GroupByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new GroupByAwait(source, keySelector, x => UniTask.FromResult(x), EqualityComparer.Default); } public static IUniTaskAsyncEnumerable> GroupByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupByAwait(source, keySelector, x => UniTask.FromResult(x), comparer); } public static IUniTaskAsyncEnumerable> GroupByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return new GroupByAwait(source, keySelector, elementSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable> GroupByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupByAwait(source, keySelector, elementSelector, comparer); } public static IUniTaskAsyncEnumerable GroupByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, Func, UniTask> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupByAwait(source, keySelector, x => UniTask.FromResult(x), resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, Func, UniTask> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupByAwait(source, keySelector, elementSelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, Func, UniTask> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupByAwait(source, keySelector, x => UniTask.FromResult(x), resultSelector, comparer); } public static IUniTaskAsyncEnumerable GroupByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, Func, UniTask> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupByAwait(source, keySelector, elementSelector, resultSelector, comparer); } // with ct public static IUniTaskAsyncEnumerable> GroupByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new GroupByAwaitWithCancellation(source, keySelector, (x, _) => UniTask.FromResult(x), EqualityComparer.Default); } public static IUniTaskAsyncEnumerable> GroupByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupByAwaitWithCancellation(source, keySelector, (x, _) => UniTask.FromResult(x), comparer); } public static IUniTaskAsyncEnumerable> GroupByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return new GroupByAwaitWithCancellation(source, keySelector, elementSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable> GroupByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupByAwaitWithCancellation(source, keySelector, elementSelector, comparer); } public static IUniTaskAsyncEnumerable GroupByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, Func, CancellationToken, UniTask> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupByAwaitWithCancellation(source, keySelector, (x, _) => UniTask.FromResult(x), resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, Func, CancellationToken, UniTask> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupByAwaitWithCancellation(source, keySelector, elementSelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, Func, CancellationToken, UniTask> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupByAwaitWithCancellation(source, keySelector, (x, _) => UniTask.FromResult(x), resultSelector, comparer); } public static IUniTaskAsyncEnumerable GroupByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, Func, CancellationToken, UniTask> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupByAwaitWithCancellation(source, keySelector, elementSelector, resultSelector, comparer); } } internal sealed class GroupBy : IUniTaskAsyncEnumerable> { readonly IUniTaskAsyncEnumerable source; readonly Func keySelector; readonly Func elementSelector; readonly IEqualityComparer comparer; public GroupBy(IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator> GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupBy(source, keySelector, elementSelector, comparer, cancellationToken); } sealed class _GroupBy : MoveNextSource, IUniTaskAsyncEnumerator> { readonly IUniTaskAsyncEnumerable source; readonly Func keySelector; readonly Func elementSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; IEnumerator> groupEnumerator; public _GroupBy(IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public IGrouping Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (groupEnumerator == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { var lookup = await source.ToLookupAsync(keySelector, elementSelector, comparer, cancellationToken); groupEnumerator = lookup.GetEnumerator(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { if (groupEnumerator.MoveNext()) { Current = groupEnumerator.Current as IGrouping; completionSource.TrySetResult(true); } else { completionSource.TrySetResult(false); } } catch (Exception ex) { completionSource.TrySetException(ex); return; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (groupEnumerator != null) { groupEnumerator.Dispose(); } return default; } } } internal sealed class GroupBy : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func keySelector; readonly Func elementSelector; readonly Func, TResult> resultSelector; readonly IEqualityComparer comparer; public GroupBy(IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupBy(source, keySelector, elementSelector, resultSelector, comparer, cancellationToken); } sealed class _GroupBy : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func keySelector; readonly Func elementSelector; readonly Func, TResult> resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; IEnumerator> groupEnumerator; public _GroupBy(IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, Func, TResult> resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (groupEnumerator == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { var lookup = await source.ToLookupAsync(keySelector, elementSelector, comparer, cancellationToken); groupEnumerator = lookup.GetEnumerator(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { if (groupEnumerator.MoveNext()) { var current = groupEnumerator.Current; Current = resultSelector(current.Key, current); completionSource.TrySetResult(true); } else { completionSource.TrySetResult(false); } } catch (Exception ex) { completionSource.TrySetException(ex); return; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (groupEnumerator != null) { groupEnumerator.Dispose(); } return default; } } } internal sealed class GroupByAwait : IUniTaskAsyncEnumerable> { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly Func> elementSelector; readonly IEqualityComparer comparer; public GroupByAwait(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator> GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupByAwait(source, keySelector, elementSelector, comparer, cancellationToken); } sealed class _GroupByAwait : MoveNextSource, IUniTaskAsyncEnumerator> { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly Func> elementSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; IEnumerator> groupEnumerator; public _GroupByAwait(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public IGrouping Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (groupEnumerator == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { var lookup = await source.ToLookupAwaitAsync(keySelector, elementSelector, comparer, cancellationToken); groupEnumerator = lookup.GetEnumerator(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { if (groupEnumerator.MoveNext()) { Current = groupEnumerator.Current as IGrouping; completionSource.TrySetResult(true); } else { completionSource.TrySetResult(false); } } catch (Exception ex) { completionSource.TrySetException(ex); return; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (groupEnumerator != null) { groupEnumerator.Dispose(); } return default; } } } internal sealed class GroupByAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly Func> elementSelector; readonly Func, UniTask> resultSelector; readonly IEqualityComparer comparer; public GroupByAwait(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, Func, UniTask> resultSelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupByAwait(source, keySelector, elementSelector, resultSelector, comparer, cancellationToken); } sealed class _GroupByAwait : MoveNextSource, IUniTaskAsyncEnumerator { readonly static Action ResultSelectCoreDelegate = ResultSelectCore; readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly Func> elementSelector; readonly Func, UniTask> resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; IEnumerator> groupEnumerator; UniTask.Awaiter awaiter; public _GroupByAwait(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, Func, UniTask> resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (groupEnumerator == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { var lookup = await source.ToLookupAwaitAsync(keySelector, elementSelector, comparer, cancellationToken); groupEnumerator = lookup.GetEnumerator(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { if (groupEnumerator.MoveNext()) { var current = groupEnumerator.Current; awaiter = resultSelector(current.Key, current).GetAwaiter(); if (awaiter.IsCompleted) { ResultSelectCore(this); } else { awaiter.SourceOnCompleted(ResultSelectCoreDelegate, this); } return; } else { completionSource.TrySetResult(false); } } catch (Exception ex) { completionSource.TrySetException(ex); return; } } static void ResultSelectCore(object state) { var self = (_GroupByAwait)state; if (self.TryGetResult(self.awaiter, out var result)) { self.Current = result; self.completionSource.TrySetResult(true); } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (groupEnumerator != null) { groupEnumerator.Dispose(); } return default; } } } internal sealed class GroupByAwaitWithCancellation : IUniTaskAsyncEnumerable> { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly Func> elementSelector; readonly IEqualityComparer comparer; public GroupByAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator> GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupByAwaitWithCancellation(source, keySelector, elementSelector, comparer, cancellationToken); } sealed class _GroupByAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator> { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly Func> elementSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; IEnumerator> groupEnumerator; public _GroupByAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public IGrouping Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (groupEnumerator == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { var lookup = await source.ToLookupAwaitWithCancellationAsync(keySelector, elementSelector, comparer, cancellationToken); groupEnumerator = lookup.GetEnumerator(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { if (groupEnumerator.MoveNext()) { Current = groupEnumerator.Current as IGrouping; completionSource.TrySetResult(true); } else { completionSource.TrySetResult(false); } } catch (Exception ex) { completionSource.TrySetException(ex); return; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (groupEnumerator != null) { groupEnumerator.Dispose(); } return default; } } } internal sealed class GroupByAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly Func> elementSelector; readonly Func, CancellationToken, UniTask> resultSelector; readonly IEqualityComparer comparer; public GroupByAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, Func, CancellationToken, UniTask> resultSelector, IEqualityComparer comparer) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupByAwaitWithCancellation(source, keySelector, elementSelector, resultSelector, comparer, cancellationToken); } sealed class _GroupByAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { readonly static Action ResultSelectCoreDelegate = ResultSelectCore; readonly IUniTaskAsyncEnumerable source; readonly Func> keySelector; readonly Func> elementSelector; readonly Func, CancellationToken, UniTask> resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; IEnumerator> groupEnumerator; UniTask.Awaiter awaiter; public _GroupByAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, Func, CancellationToken, UniTask> resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.source = source; this.keySelector = keySelector; this.elementSelector = elementSelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (groupEnumerator == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { var lookup = await source.ToLookupAwaitWithCancellationAsync(keySelector, elementSelector, comparer, cancellationToken); groupEnumerator = lookup.GetEnumerator(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { if (groupEnumerator.MoveNext()) { var current = groupEnumerator.Current; awaiter = resultSelector(current.Key, current, cancellationToken).GetAwaiter(); if (awaiter.IsCompleted) { ResultSelectCore(this); } else { awaiter.SourceOnCompleted(ResultSelectCoreDelegate, this); } return; } else { completionSource.TrySetResult(false); } } catch (Exception ex) { completionSource.TrySetException(ex); return; } } static void ResultSelectCore(object state) { var self = (_GroupByAwaitWithCancellation)state; if (self.TryGetResult(self.awaiter, out var result)) { self.Current = result; self.completionSource.TrySetResult(true); } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (groupEnumerator != null) { groupEnumerator.Dispose(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/GroupBy.cs.meta ================================================ fileFormatVersion: 2 guid: a2de80df1cc8a1240ab0ee7badd334d0 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/GroupJoin.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Linq; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable GroupJoin(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupJoin(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupJoin(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupJoin(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); } public static IUniTaskAsyncEnumerable GroupJoinAwait(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func, UniTask> resultSelector) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupJoinAwait(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupJoinAwait(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func, UniTask> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupJoinAwait(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); } public static IUniTaskAsyncEnumerable GroupJoinAwaitWithCancellation(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func, CancellationToken, UniTask> resultSelector) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new GroupJoinAwaitWithCancellation(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable GroupJoinAwaitWithCancellation(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func, CancellationToken, UniTask> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new GroupJoinAwaitWithCancellation(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); } } internal sealed class GroupJoin : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func outerKeySelector; readonly Func innerKeySelector; readonly Func, TResult> resultSelector; readonly IEqualityComparer comparer; public GroupJoin(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector, IEqualityComparer comparer) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupJoin(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken); } sealed class _GroupJoin : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func outerKeySelector; readonly Func innerKeySelector; readonly Func, TResult> resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; ILookup lookup; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; public _GroupJoin(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func, TResult> resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (lookup == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { lookup = await inner.ToLookupAsync(innerKeySelector, comparer, cancellationToken); enumerator = outer.GetAsyncEnumerator(cancellationToken); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_GroupJoin)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { var outer = self.enumerator.Current; var key = self.outerKeySelector(outer); var values = self.lookup[key]; self.Current = self.resultSelector(outer, values); self.completionSource.TrySetResult(true); } else { self.completionSource.TrySetResult(false); } } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } internal sealed class GroupJoinAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func> outerKeySelector; readonly Func> innerKeySelector; readonly Func, UniTask> resultSelector; readonly IEqualityComparer comparer; public GroupJoinAwait(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func, UniTask> resultSelector, IEqualityComparer comparer) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupJoinAwait(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken); } sealed class _GroupJoinAwait : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly static Action ResultSelectCoreDelegate = ResultSelectCore; readonly static Action OuterKeySelectCoreDelegate = OuterKeySelectCore; readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func> outerKeySelector; readonly Func> innerKeySelector; readonly Func, UniTask> resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; ILookup lookup; IUniTaskAsyncEnumerator enumerator; TOuter outerValue; UniTask.Awaiter awaiter; UniTask.Awaiter outerKeyAwaiter; UniTask.Awaiter resultAwaiter; public _GroupJoinAwait(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func, UniTask> resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (lookup == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { lookup = await inner.ToLookupAwaitAsync(innerKeySelector, comparer, cancellationToken); enumerator = outer.GetAsyncEnumerator(cancellationToken); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_GroupJoinAwait)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { try { self.outerValue = self.enumerator.Current; self.outerKeyAwaiter = self.outerKeySelector(self.outerValue).GetAwaiter(); if (self.outerKeyAwaiter.IsCompleted) { OuterKeySelectCore(self); } else { self.outerKeyAwaiter.SourceOnCompleted(OuterKeySelectCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); } } else { self.completionSource.TrySetResult(false); } } } static void OuterKeySelectCore(object state) { var self = (_GroupJoinAwait)state; if (self.TryGetResult(self.outerKeyAwaiter, out var result)) { try { var values = self.lookup[result]; self.resultAwaiter = self.resultSelector(self.outerValue, values).GetAwaiter(); if (self.resultAwaiter.IsCompleted) { ResultSelectCore(self); } else { self.resultAwaiter.SourceOnCompleted(ResultSelectCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); } } } static void ResultSelectCore(object state) { var self = (_GroupJoinAwait)state; if (self.TryGetResult(self.resultAwaiter, out var result)) { self.Current = result; self.completionSource.TrySetResult(true); } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } internal sealed class GroupJoinAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func> outerKeySelector; readonly Func> innerKeySelector; readonly Func, CancellationToken, UniTask> resultSelector; readonly IEqualityComparer comparer; public GroupJoinAwaitWithCancellation(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func, CancellationToken, UniTask> resultSelector, IEqualityComparer comparer) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _GroupJoinAwaitWithCancellation(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken); } sealed class _GroupJoinAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly static Action ResultSelectCoreDelegate = ResultSelectCore; readonly static Action OuterKeySelectCoreDelegate = OuterKeySelectCore; readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func> outerKeySelector; readonly Func> innerKeySelector; readonly Func, CancellationToken, UniTask> resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; ILookup lookup; IUniTaskAsyncEnumerator enumerator; TOuter outerValue; UniTask.Awaiter awaiter; UniTask.Awaiter outerKeyAwaiter; UniTask.Awaiter resultAwaiter; public _GroupJoinAwaitWithCancellation(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func, CancellationToken, UniTask> resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (lookup == null) { CreateLookup().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateLookup() { try { lookup = await inner.ToLookupAwaitWithCancellationAsync(innerKeySelector, comparer, cancellationToken); enumerator = outer.GetAsyncEnumerator(cancellationToken); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_GroupJoinAwaitWithCancellation)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { try { self.outerValue = self.enumerator.Current; self.outerKeyAwaiter = self.outerKeySelector(self.outerValue, self.cancellationToken).GetAwaiter(); if (self.outerKeyAwaiter.IsCompleted) { OuterKeySelectCore(self); } else { self.outerKeyAwaiter.SourceOnCompleted(OuterKeySelectCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); } } else { self.completionSource.TrySetResult(false); } } } static void OuterKeySelectCore(object state) { var self = (_GroupJoinAwaitWithCancellation)state; if (self.TryGetResult(self.outerKeyAwaiter, out var result)) { try { var values = self.lookup[result]; self.resultAwaiter = self.resultSelector(self.outerValue, values, self.cancellationToken).GetAwaiter(); if (self.resultAwaiter.IsCompleted) { ResultSelectCore(self); } else { self.resultAwaiter.SourceOnCompleted(ResultSelectCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); } } } static void ResultSelectCore(object state) { var self = (_GroupJoinAwaitWithCancellation)state; if (self.TryGetResult(self.resultAwaiter, out var result)) { self.Current = result; self.completionSource.TrySetResult(true); } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/GroupJoin.cs.meta ================================================ fileFormatVersion: 2 guid: 7bf7759d03bf3f64190d3ae83b182c2c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Intersect.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Intersect(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); return new Intersect(first, second, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable Intersect(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new Intersect(first, second, comparer); } } internal sealed class Intersect : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; readonly IEqualityComparer comparer; public Intersect(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer) { this.first = first; this.second = second; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Intersect(first, second, comparer, cancellationToken); } class _Intersect : AsyncEnumeratorBase { static Action HashSetAsyncCoreDelegate = HashSetAsyncCore; readonly IEqualityComparer comparer; readonly IUniTaskAsyncEnumerable second; HashSet set; UniTask>.Awaiter awaiter; public _Intersect(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer, CancellationToken cancellationToken) : base(first, cancellationToken) { this.second = second; this.comparer = comparer; } protected override bool OnFirstIteration() { if (set != null) return false; awaiter = second.ToHashSetAsync(cancellationToken).GetAwaiter(); if (awaiter.IsCompleted) { set = awaiter.GetResult(); SourceMoveNext(); } else { awaiter.SourceOnCompleted(HashSetAsyncCoreDelegate, this); } return true; } static void HashSetAsyncCore(object state) { var self = (_Intersect)state; if (self.TryGetResult(self.awaiter, out var result)) { self.set = result; self.SourceMoveNext(); } } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { var v = SourceCurrent; if (set.Remove(v)) { Current = v; result = true; return true; } else { result = default; return false; } } result = false; return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Intersect.cs.meta ================================================ fileFormatVersion: 2 guid: 93999a70f5d57134bbe971f3e988c4f2 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Join.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Linq; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Join(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new Join(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable Join(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new Join(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); } public static IUniTaskAsyncEnumerable JoinAwait(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func> resultSelector) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new JoinAwait(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable JoinAwait(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new JoinAwait(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); } public static IUniTaskAsyncEnumerable JoinAwaitWithCancellation(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func> resultSelector) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new JoinAwaitWithCancellation(outer, inner, outerKeySelector, innerKeySelector, resultSelector, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable JoinAwaitWithCancellation(this IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func> resultSelector, IEqualityComparer comparer) { Error.ThrowArgumentNullException(outer, nameof(outer)); Error.ThrowArgumentNullException(inner, nameof(inner)); Error.ThrowArgumentNullException(outerKeySelector, nameof(outerKeySelector)); Error.ThrowArgumentNullException(innerKeySelector, nameof(innerKeySelector)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new JoinAwaitWithCancellation(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); } } internal sealed class Join : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func outerKeySelector; readonly Func innerKeySelector; readonly Func resultSelector; readonly IEqualityComparer comparer; public Join(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector, IEqualityComparer comparer) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Join(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken); } sealed class _Join : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func outerKeySelector; readonly Func innerKeySelector; readonly Func resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; ILookup lookup; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; TOuter currentOuterValue; IEnumerator valueEnumerator; bool continueNext; public _Join(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func outerKeySelector, Func innerKeySelector, Func resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (lookup == null) { CreateInnerHashSet().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateInnerHashSet() { try { lookup = await inner.ToLookupAsync(innerKeySelector, comparer, cancellationToken); enumerator = outer.GetAsyncEnumerator(cancellationToken); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { LOOP: if (valueEnumerator != null) { if (valueEnumerator.MoveNext()) { Current = resultSelector(currentOuterValue, valueEnumerator.Current); goto TRY_SET_RESULT_TRUE; } else { valueEnumerator.Dispose(); valueEnumerator = null; } } awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; // avoid recursive } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } return; TRY_SET_RESULT_TRUE: completionSource.TrySetResult(true); } static void MoveNextCore(object state) { var self = (_Join)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.currentOuterValue = self.enumerator.Current; var key = self.outerKeySelector(self.currentOuterValue); self.valueEnumerator = self.lookup[key].GetEnumerator(); if (self.continueNext) { return; } else { self.SourceMoveNext(); } } else { self.continueNext = false; self.completionSource.TrySetResult(false); } } else { self.continueNext = false; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (valueEnumerator != null) { valueEnumerator.Dispose(); } if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } internal sealed class JoinAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func> outerKeySelector; readonly Func> innerKeySelector; readonly Func> resultSelector; readonly IEqualityComparer comparer; public JoinAwait(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func> resultSelector, IEqualityComparer comparer) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _JoinAwait(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken); } sealed class _JoinAwait : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; static readonly Action OuterSelectCoreDelegate = OuterSelectCore; static readonly Action ResultSelectCoreDelegate = ResultSelectCore; readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func> outerKeySelector; readonly Func> innerKeySelector; readonly Func> resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; ILookup lookup; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; TOuter currentOuterValue; IEnumerator valueEnumerator; UniTask.Awaiter resultAwaiter; UniTask.Awaiter outerKeyAwaiter; bool continueNext; public _JoinAwait(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func> resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (lookup == null) { CreateInnerHashSet().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateInnerHashSet() { try { lookup = await inner.ToLookupAwaitAsync(innerKeySelector, comparer, cancellationToken); enumerator = outer.GetAsyncEnumerator(cancellationToken); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { LOOP: if (valueEnumerator != null) { if (valueEnumerator.MoveNext()) { resultAwaiter = resultSelector(currentOuterValue, valueEnumerator.Current).GetAwaiter(); if (resultAwaiter.IsCompleted) { ResultSelectCore(this); } else { resultAwaiter.SourceOnCompleted(ResultSelectCoreDelegate, this); } return; } else { valueEnumerator.Dispose(); valueEnumerator = null; } } awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; // avoid recursive } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_JoinAwait)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.currentOuterValue = self.enumerator.Current; self.outerKeyAwaiter = self.outerKeySelector(self.currentOuterValue).GetAwaiter(); if (self.outerKeyAwaiter.IsCompleted) { OuterSelectCore(self); } else { self.continueNext = false; self.outerKeyAwaiter.SourceOnCompleted(OuterSelectCoreDelegate, self); } } else { self.continueNext = false; self.completionSource.TrySetResult(false); } } else { self.continueNext = false; } } static void OuterSelectCore(object state) { var self = (_JoinAwait)state; if (self.TryGetResult(self.outerKeyAwaiter, out var key)) { self.valueEnumerator = self.lookup[key].GetEnumerator(); if (self.continueNext) { return; } else { self.SourceMoveNext(); } } else { self.continueNext = false; } } static void ResultSelectCore(object state) { var self = (_JoinAwait)state; if (self.TryGetResult(self.resultAwaiter, out var result)) { self.Current = result; self.completionSource.TrySetResult(true); } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (valueEnumerator != null) { valueEnumerator.Dispose(); } if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } internal sealed class JoinAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func> outerKeySelector; readonly Func> innerKeySelector; readonly Func> resultSelector; readonly IEqualityComparer comparer; public JoinAwaitWithCancellation(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func> resultSelector, IEqualityComparer comparer) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _JoinAwaitWithCancellation(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer, cancellationToken); } sealed class _JoinAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; static readonly Action OuterSelectCoreDelegate = OuterSelectCore; static readonly Action ResultSelectCoreDelegate = ResultSelectCore; readonly IUniTaskAsyncEnumerable outer; readonly IUniTaskAsyncEnumerable inner; readonly Func> outerKeySelector; readonly Func> innerKeySelector; readonly Func> resultSelector; readonly IEqualityComparer comparer; CancellationToken cancellationToken; ILookup lookup; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; TOuter currentOuterValue; IEnumerator valueEnumerator; UniTask.Awaiter resultAwaiter; UniTask.Awaiter outerKeyAwaiter; bool continueNext; public _JoinAwaitWithCancellation(IUniTaskAsyncEnumerable outer, IUniTaskAsyncEnumerable inner, Func> outerKeySelector, Func> innerKeySelector, Func> resultSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { this.outer = outer; this.inner = inner; this.outerKeySelector = outerKeySelector; this.innerKeySelector = innerKeySelector; this.resultSelector = resultSelector; this.comparer = comparer; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (lookup == null) { CreateInnerHashSet().Forget(); } else { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } async UniTaskVoid CreateInnerHashSet() { try { lookup = await inner.ToLookupAwaitWithCancellationAsync(innerKeySelector, comparer, cancellationToken: cancellationToken); enumerator = outer.GetAsyncEnumerator(cancellationToken); } catch (Exception ex) { completionSource.TrySetException(ex); return; } SourceMoveNext(); } void SourceMoveNext() { try { LOOP: if (valueEnumerator != null) { if (valueEnumerator.MoveNext()) { resultAwaiter = resultSelector(currentOuterValue, valueEnumerator.Current, cancellationToken).GetAwaiter(); if (resultAwaiter.IsCompleted) { ResultSelectCore(this); } else { resultAwaiter.SourceOnCompleted(ResultSelectCoreDelegate, this); } return; } else { valueEnumerator.Dispose(); valueEnumerator = null; } } awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; // avoid recursive } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_JoinAwaitWithCancellation)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.currentOuterValue = self.enumerator.Current; self.outerKeyAwaiter = self.outerKeySelector(self.currentOuterValue, self.cancellationToken).GetAwaiter(); if (self.outerKeyAwaiter.IsCompleted) { OuterSelectCore(self); } else { self.continueNext = false; self.outerKeyAwaiter.SourceOnCompleted(OuterSelectCoreDelegate, self); } } else { self.continueNext = false; self.completionSource.TrySetResult(false); } } else { self.continueNext = false; } } static void OuterSelectCore(object state) { var self = (_JoinAwaitWithCancellation)state; if (self.TryGetResult(self.outerKeyAwaiter, out var key)) { self.valueEnumerator = self.lookup[key].GetEnumerator(); if (self.continueNext) { return; } else { self.SourceMoveNext(); } } else { self.continueNext = false; } } static void ResultSelectCore(object state) { var self = (_JoinAwaitWithCancellation)state; if (self.TryGetResult(self.resultAwaiter, out var result)) { self.Current = result; self.completionSource.TrySetResult(true); } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (valueEnumerator != null) { valueEnumerator.Dispose(); } if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Join.cs.meta ================================================ fileFormatVersion: 2 guid: dc4ff8cb6d7c9a64896f2f082124d6b3 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Last.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask LastAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Last.LastAsync(source, cancellationToken, false); } public static UniTask LastAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Last.LastAsync(source, predicate, cancellationToken, false); } public static UniTask LastAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Last.LastAwaitAsync(source, predicate, cancellationToken, false); } public static UniTask LastAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Last.LastAwaitWithCancellationAsync(source, predicate, cancellationToken, false); } public static UniTask LastOrDefaultAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Last.LastAsync(source, cancellationToken, true); } public static UniTask LastOrDefaultAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Last.LastAsync(source, predicate, cancellationToken, true); } public static UniTask LastOrDefaultAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Last.LastAwaitAsync(source, predicate, cancellationToken, true); } public static UniTask LastOrDefaultAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return Last.LastAwaitWithCancellationAsync(source, predicate, cancellationToken, true); } } internal static class Last { public static async UniTask LastAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value = default; if (await e.MoveNextAsync()) { value = e.Current; } else { if (defaultIfEmpty) { return value; } else { throw Error.NoElements(); } } while (await e.MoveNextAsync()) { value = e.Current; } return value; } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask LastAsync(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value = default; bool found = false; while (await e.MoveNextAsync()) { var v = e.Current; if (predicate(v)) { found = true; value = v; } } if (defaultIfEmpty) { return value; } else { if (found) { return value; } else { throw Error.NoElements(); } } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask LastAwaitAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value = default; bool found = false; while (await e.MoveNextAsync()) { var v = e.Current; if (await predicate(v)) { found = true; value = v; } } if (defaultIfEmpty) { return value; } else { if (found) { return value; } else { throw Error.NoElements(); } } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask LastAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value = default; bool found = false; while (await e.MoveNextAsync()) { var v = e.Current; if (await predicate(v, cancellationToken)) { found = true; value = v; } } if (defaultIfEmpty) { return value; } else { if (found) { return value; } else { throw Error.NoElements(); } } } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Last.cs.meta ================================================ fileFormatVersion: 2 guid: a0ccc93be1387fa4a975f06310127c11 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/LongCount.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask LongCountAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return LongCount.LongCountAsync(source, cancellationToken); } public static UniTask LongCountAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return LongCount.LongCountAsync(source, predicate, cancellationToken); } public static UniTask LongCountAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return LongCount.LongCountAwaitAsync(source, predicate, cancellationToken); } public static UniTask LongCountAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return LongCount.LongCountAwaitWithCancellationAsync(source, predicate, cancellationToken); } } internal static class LongCount { internal static async UniTask LongCountAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { long count = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { checked { count++; } } } finally { if (e != null) { await e.DisposeAsync(); } } return count; } internal static async UniTask LongCountAsync(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) { long count = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (predicate(e.Current)) { checked { count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return count; } internal static async UniTask LongCountAwaitAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { long count = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (await predicate(e.Current)) { checked { count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return count; } internal static async UniTask LongCountAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { long count = 0; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { if (await predicate(e.Current, cancellationToken)) { checked { count++; } } } } finally { if (e != null) { await e.DisposeAsync(); } } return count; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/LongCount.cs.meta ================================================ fileFormatVersion: 2 guid: 198b39e58ced3ab4f97ccbe0916787d5 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Max.cs ================================================ using System; using System.Collections.Generic; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } } internal static partial class Max { public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { TSource value = default; var comparer = Comparer.Default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } return value; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (comparer.Compare(value, x) < 0) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { TResult value = default; var comparer = Comparer.Default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } return value; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (comparer.Compare(value, x) < 0) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { TResult value = default; var comparer = Comparer.Default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } return value; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (comparer.Compare(value, x) < 0) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { TResult value = default; var comparer = Comparer.Default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } return value; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (comparer.Compare(value, x) < 0) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Max.cs.meta ================================================ fileFormatVersion: 2 guid: 5c8a118a6b664c441820b8a87d7f6e28 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Merge.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Merge(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); return new Merge(new [] { first, second }); } public static IUniTaskAsyncEnumerable Merge(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IUniTaskAsyncEnumerable third) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); Error.ThrowArgumentNullException(third, nameof(third)); return new Merge(new[] { first, second, third }); } public static IUniTaskAsyncEnumerable Merge(this IEnumerable> sources) { return sources is IUniTaskAsyncEnumerable[] array ? new Merge(array) : new Merge(sources.ToArray()); } public static IUniTaskAsyncEnumerable Merge(params IUniTaskAsyncEnumerable[] sources) { return new Merge(sources); } } internal sealed class Merge : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable[] sources; public Merge(IUniTaskAsyncEnumerable[] sources) { if (sources.Length <= 0) { Error.ThrowArgumentException("No source async enumerable to merge"); } this.sources = sources; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) => new _Merge(sources, cancellationToken); enum MergeSourceState { Pending, Running, Completed, } sealed class _Merge : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action GetResultAtAction = GetResultAt; readonly int length; readonly IUniTaskAsyncEnumerator[] enumerators; readonly MergeSourceState[] states; readonly Queue<(T, Exception, bool)> queuedResult = new Queue<(T, Exception, bool)>(); readonly CancellationToken cancellationToken; int moveNextCompleted; public T Current { get; private set; } public _Merge(IUniTaskAsyncEnumerable[] sources, CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; length = sources.Length; states = ArrayPool.Shared.Rent(length); enumerators = ArrayPool>.Shared.Rent(length); for (var i = 0; i < length; i++) { enumerators[i] = sources[i].GetAsyncEnumerator(cancellationToken); states[i] = (int)MergeSourceState.Pending;; } } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); Interlocked.Exchange(ref moveNextCompleted, 0); if (HasQueuedResult() && Interlocked.CompareExchange(ref moveNextCompleted, 1, 0) == 0) { (T, Exception, bool) value; lock (states) { value = queuedResult.Dequeue(); } var resultValue = value.Item1; var exception = value.Item2; var hasNext = value.Item3; if (exception != null) { completionSource.TrySetException(exception); } else { Current = resultValue; completionSource.TrySetResult(hasNext); } return new UniTask(this, completionSource.Version); } for (var i = 0; i < length; i++) { lock (states) { if (states[i] == MergeSourceState.Pending) { states[i] = MergeSourceState.Running; } else { continue; } } var awaiter = enumerators[i].MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { GetResultAt(i, awaiter); } else { awaiter.SourceOnCompleted(GetResultAtAction, StateTuple.Create(this, i, awaiter)); } } return new UniTask(this, completionSource.Version); } public async UniTask DisposeAsync() { for (var i = 0; i < length; i++) { await enumerators[i].DisposeAsync(); } ArrayPool.Shared.Return(states, true); ArrayPool>.Shared.Return(enumerators, true); } static void GetResultAt(object state) { using (var tuple = (StateTuple<_Merge, int, UniTask.Awaiter>)state) { tuple.Item1.GetResultAt(tuple.Item2, tuple.Item3); } } void GetResultAt(int index, UniTask.Awaiter awaiter) { bool hasNext; bool completedAll; try { hasNext = awaiter.GetResult(); } catch (Exception ex) { if (Interlocked.CompareExchange(ref moveNextCompleted, 1, 0) == 0) { completionSource.TrySetException(ex); } else { lock (states) { queuedResult.Enqueue((default, ex, default)); } } return; } lock (states) { states[index] = hasNext ? MergeSourceState.Pending : MergeSourceState.Completed; completedAll = !hasNext && IsCompletedAll(); } if (hasNext || completedAll) { if (Interlocked.CompareExchange(ref moveNextCompleted, 1, 0) == 0) { Current = enumerators[index].Current; completionSource.TrySetResult(!completedAll); } else { lock (states) { queuedResult.Enqueue((enumerators[index].Current, null, !completedAll)); } } } } bool HasQueuedResult() { lock (states) { return queuedResult.Count > 0; } } bool IsCompletedAll() { lock (states) { for (var i = 0; i < length; i++) { if (states[i] != MergeSourceState.Completed) { return false; } } } return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Merge.cs.meta ================================================ fileFormatVersion: 2 guid: ca56812f160c45d0bacb4339819edf1a timeCreated: 1694133666 ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Min.cs ================================================ using System; using System.Collections.Generic; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } } internal static partial class Min { public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { TSource value = default; var comparer = Comparer.Default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } return value; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (comparer.Compare(value, x) > 0) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { TResult value = default; var comparer = Comparer.Default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } return value; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (comparer.Compare(value, x) > 0) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { TResult value = default; var comparer = Comparer.Default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } return value; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (comparer.Compare(value, x) > 0) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { TResult value = default; var comparer = Comparer.Default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } return value; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (comparer.Compare(value, x) > 0) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Min.cs.meta ================================================ fileFormatVersion: 2 guid: 57ac9da21d3457849a8e45548290a508 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/MinMax.cs ================================================ using System; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Min.MinAsync(source, cancellationToken); } public static UniTask MinAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAsync(source, selector, cancellationToken); } public static UniTask MinAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitAsync(source, selector, cancellationToken); } public static UniTask MinAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Min.MinAwaitWithCancellationAsync(source, selector, cancellationToken); } } internal static partial class Min { public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int32 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int32 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int64 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int64 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Single value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Single value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Double value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Double value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Decimal value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Decimal value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int32? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int32? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int64? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int64? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Single? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Single? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Double? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Double? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Decimal? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Decimal? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MinAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value > x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } } public static partial class UniTaskAsyncEnumerable { public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Max.MaxAsync(source, cancellationToken); } public static UniTask MaxAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitAsync(source, selector, cancellationToken); } public static UniTask MaxAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Max.MaxAwaitWithCancellationAsync(source, selector, cancellationToken); } } internal static partial class Max { public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int32 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int32 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int64 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int64 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64 value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Single value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Single value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Double value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Double value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Decimal value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Decimal value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); goto NEXT_LOOP; } throw Error.NoElements(); NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int32? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int32? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int64? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int64? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Single? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Single? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Double? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Double? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Decimal? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Decimal? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask MaxAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal? value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); if(value == null) continue; goto NEXT_LOOP; } return default; NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); if( x == null) continue; if (value < x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/MinMax.cs.meta ================================================ fileFormatVersion: 2 guid: 2d6da02d9ab970e4999daf7147d98e36 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/MinMax.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> <# var types = new[] { typeof(int), typeof(long), typeof(float), typeof(double), typeof(decimal), typeof(int?), typeof(long?), typeof(float?), typeof(double?), typeof(decimal?), }; Func IsNullable = x => x.IsGenericType; Func TypeName = x => IsNullable(x) ? x.GetGenericArguments()[0].Name + "?" : x.Name; Func WithSuffix = x => IsNullable(x) ? ".GetValueOrDefault()" : ""; #> using System; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { <# foreach(var (minMax, op) in new[]{("Min",">"), ("Max", "<")}) { #> public static partial class UniTaskAsyncEnumerable { <# foreach(var t in types) { #> public static UniTask<<#= TypeName(t) #>> <#= minMax #>Async(this IUniTaskAsyncEnumerable<<#= TypeName(t) #>> source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return <#= minMax #>.<#= minMax #>Async(source, cancellationToken); } public static UniTask<<#= TypeName(t) #>> <#= minMax #>Async(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return <#= minMax #>.<#= minMax #>Async(source, selector, cancellationToken); } public static UniTask<<#= TypeName(t) #>> <#= minMax #>AwaitAsync(this IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return <#= minMax #>.<#= minMax #>AwaitAsync(source, selector, cancellationToken); } public static UniTask<<#= TypeName(t) #>> <#= minMax #>AwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return <#= minMax #>.<#= minMax #>AwaitWithCancellationAsync(source, selector, cancellationToken); } <# } #> } internal static partial class <#= minMax #> { <# foreach(var t in types) { #> public static async UniTask<<#= TypeName(t) #>> <#= minMax #>Async(IUniTaskAsyncEnumerable<<#= TypeName(t) #>> source, CancellationToken cancellationToken) { <#= TypeName(t) #> value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = e.Current; <# if (IsNullable(t)) { #> if(value == null) continue; <# } #> goto NEXT_LOOP; } <# if (IsNullable(t)) { #> return default; <# } else { #> throw Error.NoElements(); <# } #> NEXT_LOOP: while (await e.MoveNextAsync()) { var x = e.Current; <# if (IsNullable(t)) { #> if( x == null) continue; <# } #> if (value <#= op #> x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask<<#= TypeName(t) #>> <#= minMax #>Async(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { <#= TypeName(t) #> value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = selector(e.Current); <# if (IsNullable(t)) { #> if(value == null) continue; <# } #> goto NEXT_LOOP; } <# if (IsNullable(t)) { #> return default; <# } else { #> throw Error.NoElements(); <# } #> NEXT_LOOP: while (await e.MoveNextAsync()) { var x = selector(e.Current); <# if (IsNullable(t)) { #> if( x == null) continue; <# } #> if (value <#= op #> x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask<<#= TypeName(t) #>> <#= minMax #>AwaitAsync(IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken) { <#= TypeName(t) #> value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current); <# if (IsNullable(t)) { #> if(value == null) continue; <# } #> goto NEXT_LOOP; } <# if (IsNullable(t)) { #> return default; <# } else { #> throw Error.NoElements(); <# } #> NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current); <# if (IsNullable(t)) { #> if( x == null) continue; <# } #> if (value <#= op #> x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } public static async UniTask<<#= TypeName(t) #>> <#= minMax #>AwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken) { <#= TypeName(t) #> value = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { value = await selector(e.Current, cancellationToken); <# if (IsNullable(t)) { #> if(value == null) continue; <# } #> goto NEXT_LOOP; } <# if (IsNullable(t)) { #> return default; <# } else { #> throw Error.NoElements(); <# } #> NEXT_LOOP: while (await e.MoveNextAsync()) { var x = await selector(e.Current, cancellationToken); <# if (IsNullable(t)) { #> if( x == null) continue; <# } #> if (value <#= op #> x) { value = x; } } } finally { if (e != null) { await e.DisposeAsync(); } } return value; } <# } #> } <# } #> } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/MinMax.tt.meta ================================================ fileFormatVersion: 2 guid: 18108e9feb2ec40498df573cfef2ea15 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Never.cs ================================================ using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Never() { return Cysharp.Threading.Tasks.Linq.Never.Instance; } } internal class Never : IUniTaskAsyncEnumerable { public static readonly IUniTaskAsyncEnumerable Instance = new Never(); Never() { } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Never(cancellationToken); } class _Never : IUniTaskAsyncEnumerator { CancellationToken cancellationToken; public _Never(CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; } public T Current => default; public UniTask MoveNextAsync() { var tcs = new UniTaskCompletionSource(); cancellationToken.Register(state => { var task = (UniTaskCompletionSource)state; task.TrySetCanceled(cancellationToken); }, tcs); return tcs.Task; } public UniTask DisposeAsync() { return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Never.cs.meta ================================================ fileFormatVersion: 2 guid: 8b307c3d3be71a94da251564bcdefa3d MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/OfType.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable OfType(this IUniTaskAsyncEnumerable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new OfType(source); } } internal sealed class OfType : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; public OfType(IUniTaskAsyncEnumerable source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _OfType(source, cancellationToken); } class _OfType : AsyncEnumeratorBase { public _OfType(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) : base(source, cancellationToken) { } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { if (SourceCurrent is TResult castCurent) { Current = castCurent; result = true; return true; } else { result = default; return false; } } result = false; return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/OfType.cs.meta ================================================ fileFormatVersion: 2 guid: 111ffe87a7d700442a9ef5af554b252c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/OrderBy.cs ================================================ using Cysharp.Threading.Tasks; using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { #region OrderBy_OrderByDescending public static IUniTaskOrderedAsyncEnumerable OrderBy(this IUniTaskAsyncEnumerable source, Func keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new OrderedAsyncEnumerable(source, keySelector, Comparer.Default, false, null); } public static IUniTaskOrderedAsyncEnumerable OrderBy(this IUniTaskAsyncEnumerable source, Func keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new OrderedAsyncEnumerable(source, keySelector, comparer, false, null); } public static IUniTaskOrderedAsyncEnumerable OrderByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new OrderedAsyncEnumerableAwait(source, keySelector, Comparer.Default, false, null); } public static IUniTaskOrderedAsyncEnumerable OrderByAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new OrderedAsyncEnumerableAwait(source, keySelector, comparer, false, null); } public static IUniTaskOrderedAsyncEnumerable OrderByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new OrderedAsyncEnumerableAwaitWithCancellation(source, keySelector, Comparer.Default, false, null); } public static IUniTaskOrderedAsyncEnumerable OrderByAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new OrderedAsyncEnumerableAwaitWithCancellation(source, keySelector, comparer, false, null); } public static IUniTaskOrderedAsyncEnumerable OrderByDescending(this IUniTaskAsyncEnumerable source, Func keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new OrderedAsyncEnumerable(source, keySelector, Comparer.Default, true, null); } public static IUniTaskOrderedAsyncEnumerable OrderByDescending(this IUniTaskAsyncEnumerable source, Func keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new OrderedAsyncEnumerable(source, keySelector, comparer, true, null); } public static IUniTaskOrderedAsyncEnumerable OrderByDescendingAwait(this IUniTaskAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new OrderedAsyncEnumerableAwait(source, keySelector, Comparer.Default, true, null); } public static IUniTaskOrderedAsyncEnumerable OrderByDescendingAwait(this IUniTaskAsyncEnumerable source, Func> keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new OrderedAsyncEnumerableAwait(source, keySelector, comparer, true, null); } public static IUniTaskOrderedAsyncEnumerable OrderByDescendingAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return new OrderedAsyncEnumerableAwaitWithCancellation(source, keySelector, Comparer.Default, true, null); } public static IUniTaskOrderedAsyncEnumerable OrderByDescendingAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return new OrderedAsyncEnumerableAwaitWithCancellation(source, keySelector, comparer, true, null); } #endregion #region ThenBy_ThenByDescending public static IUniTaskOrderedAsyncEnumerable ThenBy(this IUniTaskOrderedAsyncEnumerable source, Func keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return source.CreateOrderedEnumerable(keySelector, Comparer.Default, false); } public static IUniTaskOrderedAsyncEnumerable ThenBy(this IUniTaskOrderedAsyncEnumerable source, Func keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return source.CreateOrderedEnumerable(keySelector, comparer, false); } public static IUniTaskOrderedAsyncEnumerable ThenByAwait(this IUniTaskOrderedAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return source.CreateOrderedEnumerable(keySelector, Comparer.Default, false); } public static IUniTaskOrderedAsyncEnumerable ThenByAwait(this IUniTaskOrderedAsyncEnumerable source, Func> keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return source.CreateOrderedEnumerable(keySelector, comparer, false); } public static IUniTaskOrderedAsyncEnumerable ThenByAwaitWithCancellation(this IUniTaskOrderedAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return source.CreateOrderedEnumerable(keySelector, Comparer.Default, false); } public static IUniTaskOrderedAsyncEnumerable ThenByAwaitWithCancellation(this IUniTaskOrderedAsyncEnumerable source, Func> keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return source.CreateOrderedEnumerable(keySelector, comparer, false); } public static IUniTaskOrderedAsyncEnumerable ThenByDescending(this IUniTaskOrderedAsyncEnumerable source, Func keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return source.CreateOrderedEnumerable(keySelector, Comparer.Default, true); } public static IUniTaskOrderedAsyncEnumerable ThenByDescending(this IUniTaskOrderedAsyncEnumerable source, Func keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return source.CreateOrderedEnumerable(keySelector, comparer, true); } public static IUniTaskOrderedAsyncEnumerable ThenByDescendingAwait(this IUniTaskOrderedAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return source.CreateOrderedEnumerable(keySelector, Comparer.Default, true); } public static IUniTaskOrderedAsyncEnumerable ThenByDescendingAwait(this IUniTaskOrderedAsyncEnumerable source, Func> keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return source.CreateOrderedEnumerable(keySelector, comparer, true); } public static IUniTaskOrderedAsyncEnumerable ThenByDescendingAwaitWithCancellation(this IUniTaskOrderedAsyncEnumerable source, Func> keySelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return source.CreateOrderedEnumerable(keySelector, Comparer.Default, true); } public static IUniTaskOrderedAsyncEnumerable ThenByDescendingAwaitWithCancellation(this IUniTaskOrderedAsyncEnumerable source, Func> keySelector, IComparer comparer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return source.CreateOrderedEnumerable(keySelector, comparer, true); } #endregion } internal abstract class AsyncEnumerableSorter { internal abstract UniTask ComputeKeysAsync(TElement[] elements, int count); internal abstract int CompareKeys(int index1, int index2); internal async UniTask SortAsync(TElement[] elements, int count) { await ComputeKeysAsync(elements, count); int[] map = new int[count]; for (int i = 0; i < count; i++) map[i] = i; QuickSort(map, 0, count - 1); return map; } void QuickSort(int[] map, int left, int right) { do { int i = left; int j = right; int x = map[i + ((j - i) >> 1)]; do { while (i < map.Length && CompareKeys(x, map[i]) > 0) i++; while (j >= 0 && CompareKeys(x, map[j]) < 0) j--; if (i > j) break; if (i < j) { int temp = map[i]; map[i] = map[j]; map[j] = temp; } i++; j--; } while (i <= j); if (j - left <= right - i) { if (left < j) QuickSort(map, left, j); left = i; } else { if (i < right) QuickSort(map, i, right); right = j; } } while (left < right); } } internal class SyncSelectorAsyncEnumerableSorter : AsyncEnumerableSorter { readonly Func keySelector; readonly IComparer comparer; readonly bool descending; readonly AsyncEnumerableSorter next; TKey[] keys; internal SyncSelectorAsyncEnumerableSorter(Func keySelector, IComparer comparer, bool descending, AsyncEnumerableSorter next) { this.keySelector = keySelector; this.comparer = comparer; this.descending = descending; this.next = next; } internal override async UniTask ComputeKeysAsync(TElement[] elements, int count) { keys = new TKey[count]; for (int i = 0; i < count; i++) keys[i] = keySelector(elements[i]); if (next != null) await next.ComputeKeysAsync(elements, count); } internal override int CompareKeys(int index1, int index2) { int c = comparer.Compare(keys[index1], keys[index2]); if (c == 0) { if (next == null) return index1 - index2; return next.CompareKeys(index1, index2); } return descending ? -c : c; } } internal class AsyncSelectorEnumerableSorter : AsyncEnumerableSorter { readonly Func> keySelector; readonly IComparer comparer; readonly bool descending; readonly AsyncEnumerableSorter next; TKey[] keys; internal AsyncSelectorEnumerableSorter(Func> keySelector, IComparer comparer, bool descending, AsyncEnumerableSorter next) { this.keySelector = keySelector; this.comparer = comparer; this.descending = descending; this.next = next; } internal override async UniTask ComputeKeysAsync(TElement[] elements, int count) { keys = new TKey[count]; for (int i = 0; i < count; i++) keys[i] = await keySelector(elements[i]); if (next != null) await next.ComputeKeysAsync(elements, count); } internal override int CompareKeys(int index1, int index2) { int c = comparer.Compare(keys[index1], keys[index2]); if (c == 0) { if (next == null) return index1 - index2; return next.CompareKeys(index1, index2); } return descending ? -c : c; } } internal class AsyncSelectorWithCancellationEnumerableSorter : AsyncEnumerableSorter { readonly Func> keySelector; readonly IComparer comparer; readonly bool descending; readonly AsyncEnumerableSorter next; CancellationToken cancellationToken; TKey[] keys; internal AsyncSelectorWithCancellationEnumerableSorter(Func> keySelector, IComparer comparer, bool descending, AsyncEnumerableSorter next, CancellationToken cancellationToken) { this.keySelector = keySelector; this.comparer = comparer; this.descending = descending; this.next = next; this.cancellationToken = cancellationToken; } internal override async UniTask ComputeKeysAsync(TElement[] elements, int count) { keys = new TKey[count]; for (int i = 0; i < count; i++) keys[i] = await keySelector(elements[i], cancellationToken); if (next != null) await next.ComputeKeysAsync(elements, count); } internal override int CompareKeys(int index1, int index2) { int c = comparer.Compare(keys[index1], keys[index2]); if (c == 0) { if (next == null) return index1 - index2; return next.CompareKeys(index1, index2); } return descending ? -c : c; } } internal abstract class OrderedAsyncEnumerable : IUniTaskOrderedAsyncEnumerable { protected readonly IUniTaskAsyncEnumerable source; public OrderedAsyncEnumerable(IUniTaskAsyncEnumerable source) { this.source = source; } public IUniTaskOrderedAsyncEnumerable CreateOrderedEnumerable(Func keySelector, IComparer comparer, bool descending) { return new OrderedAsyncEnumerable(source, keySelector, comparer, descending, this); } public IUniTaskOrderedAsyncEnumerable CreateOrderedEnumerable(Func> keySelector, IComparer comparer, bool descending) { return new OrderedAsyncEnumerableAwait(source, keySelector, comparer, descending, this); } public IUniTaskOrderedAsyncEnumerable CreateOrderedEnumerable(Func> keySelector, IComparer comparer, bool descending) { return new OrderedAsyncEnumerableAwaitWithCancellation(source, keySelector, comparer, descending, this); } internal abstract AsyncEnumerableSorter GetAsyncEnumerableSorter(AsyncEnumerableSorter next, CancellationToken cancellationToken); public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _OrderedAsyncEnumerator(this, cancellationToken); } class _OrderedAsyncEnumerator : MoveNextSource, IUniTaskAsyncEnumerator { protected readonly OrderedAsyncEnumerable parent; CancellationToken cancellationToken; TElement[] buffer; int[] map; int index; public _OrderedAsyncEnumerator(OrderedAsyncEnumerable parent, CancellationToken cancellationToken) { this.parent = parent; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TElement Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (map == null) { completionSource.Reset(); CreateSortSource().Forget(); return new UniTask(this, completionSource.Version); } if (index < buffer.Length) { Current = buffer[map[index++]]; return CompletedTasks.True; } else { return CompletedTasks.False; } } async UniTaskVoid CreateSortSource() { try { buffer = await parent.source.ToArrayAsync(); if (buffer.Length == 0) { completionSource.TrySetResult(false); return; } var sorter = parent.GetAsyncEnumerableSorter(null, cancellationToken); map = await sorter.SortAsync(buffer, buffer.Length); sorter = null; // set first value Current = buffer[map[index++]]; } catch (Exception ex) { completionSource.TrySetException(ex); return; } completionSource.TrySetResult(true); } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return default; } } } internal class OrderedAsyncEnumerable : OrderedAsyncEnumerable { readonly Func keySelector; readonly IComparer comparer; readonly bool descending; readonly OrderedAsyncEnumerable parent; public OrderedAsyncEnumerable(IUniTaskAsyncEnumerable source, Func keySelector, IComparer comparer, bool descending, OrderedAsyncEnumerable parent) : base(source) { this.keySelector = keySelector; this.comparer = comparer; this.descending = descending; this.parent = parent; } internal override AsyncEnumerableSorter GetAsyncEnumerableSorter(AsyncEnumerableSorter next, CancellationToken cancellationToken) { AsyncEnumerableSorter sorter = new SyncSelectorAsyncEnumerableSorter(keySelector, comparer, descending, next); if (parent != null) sorter = parent.GetAsyncEnumerableSorter(sorter, cancellationToken); return sorter; } } internal class OrderedAsyncEnumerableAwait : OrderedAsyncEnumerable { readonly Func> keySelector; readonly IComparer comparer; readonly bool descending; readonly OrderedAsyncEnumerable parent; public OrderedAsyncEnumerableAwait(IUniTaskAsyncEnumerable source, Func> keySelector, IComparer comparer, bool descending, OrderedAsyncEnumerable parent) : base(source) { this.keySelector = keySelector; this.comparer = comparer; this.descending = descending; this.parent = parent; } internal override AsyncEnumerableSorter GetAsyncEnumerableSorter(AsyncEnumerableSorter next, CancellationToken cancellationToken) { AsyncEnumerableSorter sorter = new AsyncSelectorEnumerableSorter(keySelector, comparer, descending, next); if (parent != null) sorter = parent.GetAsyncEnumerableSorter(sorter, cancellationToken); return sorter; } } internal class OrderedAsyncEnumerableAwaitWithCancellation : OrderedAsyncEnumerable { readonly Func> keySelector; readonly IComparer comparer; readonly bool descending; readonly OrderedAsyncEnumerable parent; public OrderedAsyncEnumerableAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> keySelector, IComparer comparer, bool descending, OrderedAsyncEnumerable parent) : base(source) { this.keySelector = keySelector; this.comparer = comparer; this.descending = descending; this.parent = parent; } internal override AsyncEnumerableSorter GetAsyncEnumerableSorter(AsyncEnumerableSorter next, CancellationToken cancellationToken) { AsyncEnumerableSorter sorter = new AsyncSelectorWithCancellationEnumerableSorter(keySelector, comparer, descending, next, cancellationToken); if (parent != null) sorter = parent.GetAsyncEnumerableSorter(sorter, cancellationToken); return sorter; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/OrderBy.cs.meta ================================================ fileFormatVersion: 2 guid: 413883ceff8546143bdf200aafa4b8f7 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Pairwise.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable<(TSource, TSource)> Pairwise(this IUniTaskAsyncEnumerable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new Pairwise(source); } } internal sealed class Pairwise : IUniTaskAsyncEnumerable<(TSource, TSource)> { readonly IUniTaskAsyncEnumerable source; public Pairwise(IUniTaskAsyncEnumerable source) { this.source = source; } public IUniTaskAsyncEnumerator<(TSource, TSource)> GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Pairwise(source, cancellationToken); } sealed class _Pairwise : MoveNextSource, IUniTaskAsyncEnumerator<(TSource, TSource)> { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; TSource prev; bool isFirst; public _Pairwise(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public (TSource, TSource) Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (enumerator == null) { isFirst = true; enumerator = source.GetAsyncEnumerator(cancellationToken); } completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } void SourceMoveNext() { try { awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_Pairwise)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { if (self.isFirst) { self.isFirst = false; self.prev = self.enumerator.Current; self.SourceMoveNext(); // run again. okay to use recursive(only one more). } else { var p = self.prev; self.prev = self.enumerator.Current; self.Current = (p, self.prev); self.completionSource.TrySetResult(true); } } else { self.completionSource.TrySetResult(false); } } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Pairwise.cs.meta ================================================ fileFormatVersion: 2 guid: cddbf051d2a88f549986c468b23214af MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Publish.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IConnectableUniTaskAsyncEnumerable Publish(this IUniTaskAsyncEnumerable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new Publish(source); } } internal sealed class Publish : IConnectableUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly CancellationTokenSource cancellationTokenSource; TriggerEvent trigger; IUniTaskAsyncEnumerator enumerator; IDisposable connectedDisposable; bool isCompleted; public Publish(IUniTaskAsyncEnumerable source) { this.source = source; this.cancellationTokenSource = new CancellationTokenSource(); } public IDisposable Connect() { if (connectedDisposable != null) return connectedDisposable; if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationTokenSource.Token); } ConsumeEnumerator().Forget(); connectedDisposable = new ConnectDisposable(cancellationTokenSource); return connectedDisposable; } async UniTaskVoid ConsumeEnumerator() { try { try { while (await enumerator.MoveNextAsync()) { trigger.SetResult(enumerator.Current); } trigger.SetCompleted(); } catch (Exception ex) { trigger.SetError(ex); } } finally { isCompleted = true; await enumerator.DisposeAsync(); } } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Publish(this, cancellationToken); } sealed class ConnectDisposable : IDisposable { readonly CancellationTokenSource cancellationTokenSource; public ConnectDisposable(CancellationTokenSource cancellationTokenSource) { this.cancellationTokenSource = cancellationTokenSource; } public void Dispose() { this.cancellationTokenSource.Cancel(); } } sealed class _Publish : MoveNextSource, IUniTaskAsyncEnumerator, ITriggerHandler { static readonly Action CancelDelegate = OnCanceled; readonly Publish parent; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool isDisposed; public _Publish(Publish parent, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) return; this.parent = parent; this.cancellationToken = cancellationToken; if (cancellationToken.CanBeCanceled) { this.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(CancelDelegate, this); } parent.trigger.Add(this); TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } ITriggerHandler ITriggerHandler.Prev { get; set; } ITriggerHandler ITriggerHandler.Next { get; set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (parent.isCompleted) return CompletedTasks.False; completionSource.Reset(); return new UniTask(this, completionSource.Version); } static void OnCanceled(object state) { var self = (_Publish)state; self.completionSource.TrySetCanceled(self.cancellationToken); self.DisposeAsync().Forget(); } public UniTask DisposeAsync() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); cancellationTokenRegistration.Dispose(); parent.trigger.Remove(this); } return default; } public void OnNext(TSource value) { Current = value; completionSource.TrySetResult(true); } public void OnCanceled(CancellationToken cancellationToken) { completionSource.TrySetCanceled(cancellationToken); } public void OnCompleted() { completionSource.TrySetResult(false); } public void OnError(Exception ex) { completionSource.TrySetException(ex); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Publish.cs.meta ================================================ fileFormatVersion: 2 guid: 93c684d1e88c09d4e89b79437d97b810 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Queue.cs ================================================ using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Queue(this IUniTaskAsyncEnumerable source) { return new QueueOperator(source); } } internal sealed class QueueOperator : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; public QueueOperator(IUniTaskAsyncEnumerable source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Queue(source, cancellationToken); } sealed class _Queue : IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; CancellationToken cancellationToken; Channel channel; IUniTaskAsyncEnumerator channelEnumerator; IUniTaskAsyncEnumerator sourceEnumerator; bool channelClosed; public _Queue(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; } public TSource Current => channelEnumerator.Current; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (sourceEnumerator == null) { sourceEnumerator = source.GetAsyncEnumerator(cancellationToken); channel = Channel.CreateSingleConsumerUnbounded(); channelEnumerator = channel.Reader.ReadAllAsync().GetAsyncEnumerator(cancellationToken); ConsumeAll(this, sourceEnumerator, channel).Forget(); } return channelEnumerator.MoveNextAsync(); } static async UniTaskVoid ConsumeAll(_Queue self, IUniTaskAsyncEnumerator enumerator, ChannelWriter writer) { try { while (await enumerator.MoveNextAsync()) { writer.TryWrite(enumerator.Current); } writer.TryComplete(); } catch (Exception ex) { writer.TryComplete(ex); } finally { self.channelClosed = true; await enumerator.DisposeAsync(); } } public async UniTask DisposeAsync() { if (sourceEnumerator != null) { await sourceEnumerator.DisposeAsync(); } if (channelEnumerator != null) { await channelEnumerator.DisposeAsync(); } if (!channelClosed) { channelClosed = true; channel.Writer.TryComplete(new OperationCanceledException()); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Queue.cs.meta ================================================ fileFormatVersion: 2 guid: b7ea1bcf9dbebb042bc99c7816249e02 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Range.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Range(int start, int count) { if (count < 0) throw Error.ArgumentOutOfRange(nameof(count)); var end = (long)start + count - 1L; if (end > int.MaxValue) throw Error.ArgumentOutOfRange(nameof(count)); if (count == 0) UniTaskAsyncEnumerable.Empty(); return new Cysharp.Threading.Tasks.Linq.Range(start, count); } } internal class Range : IUniTaskAsyncEnumerable { readonly int start; readonly int end; public Range(int start, int count) { this.start = start; this.end = start + count; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Range(start, end, cancellationToken); } class _Range : IUniTaskAsyncEnumerator { readonly int start; readonly int end; int current; CancellationToken cancellationToken; public _Range(int start, int end, CancellationToken cancellationToken) { this.start = start; this.end = end; this.cancellationToken = cancellationToken; this.current = start - 1; } public int Current => current; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); current++; if (current != end) { return CompletedTasks.True; } return CompletedTasks.False; } public UniTask DisposeAsync() { return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Range.cs.meta ================================================ fileFormatVersion: 2 guid: d826418a813498648b10542d0a5fb173 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Repeat.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Repeat(TElement element, int count) { if (count < 0) throw Error.ArgumentOutOfRange(nameof(count)); return new Repeat(element, count); } } internal class Repeat : IUniTaskAsyncEnumerable { readonly TElement element; readonly int count; public Repeat(TElement element, int count) { this.element = element; this.count = count; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Repeat(element, count, cancellationToken); } class _Repeat : IUniTaskAsyncEnumerator { readonly TElement element; readonly int count; int remaining; CancellationToken cancellationToken; public _Repeat(TElement element, int count, CancellationToken cancellationToken) { this.element = element; this.count = count; this.cancellationToken = cancellationToken; this.remaining = count; } public TElement Current => element; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (remaining-- != 0) { return CompletedTasks.True; } return CompletedTasks.False; } public UniTask DisposeAsync() { return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Repeat.cs.meta ================================================ fileFormatVersion: 2 guid: 3819a3925165a674d80ee848c8600379 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Return.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Return(TValue value) { return new Return(value); } } internal class Return : IUniTaskAsyncEnumerable { readonly TValue value; public Return(TValue value) { this.value = value; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Return(value, cancellationToken); } class _Return : IUniTaskAsyncEnumerator { readonly TValue value; CancellationToken cancellationToken; bool called; public _Return(TValue value, CancellationToken cancellationToken) { this.value = value; this.cancellationToken = cancellationToken; this.called = false; } public TValue Current => value; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (!called) { called = true; return CompletedTasks.True; } return CompletedTasks.False; } public UniTask DisposeAsync() { return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Return.cs.meta ================================================ fileFormatVersion: 2 guid: 4313cd8ecf705e44f9064ce46e293c2c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Reverse.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System.Collections.Generic; using System.Linq; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Reverse(this IUniTaskAsyncEnumerable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new Reverse(source); } } internal sealed class Reverse : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; public Reverse(IUniTaskAsyncEnumerable source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Reverse(source, cancellationToken); } sealed class _Reverse : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; CancellationToken cancellationToken; TSource[] array; int index; public _Reverse(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } // after consumed array, don't use await so allow async(not require UniTaskCompletionSourceCore). public async UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (array == null) { array = await source.ToArrayAsync(cancellationToken); index = array.Length - 1; } if (index != -1) { Current = array[index]; --index; return true; } else { return false; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Reverse.cs.meta ================================================ fileFormatVersion: 2 guid: b2769e65c729b4f4ca6af9826d9c7b90 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Select.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Select(this IUniTaskAsyncEnumerable source, Func selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new Cysharp.Threading.Tasks.Linq.Select(source, selector); } public static IUniTaskAsyncEnumerable Select(this IUniTaskAsyncEnumerable source, Func selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new Cysharp.Threading.Tasks.Linq.SelectInt(source, selector); } public static IUniTaskAsyncEnumerable SelectAwait(this IUniTaskAsyncEnumerable source, Func> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new Cysharp.Threading.Tasks.Linq.SelectAwait(source, selector); } public static IUniTaskAsyncEnumerable SelectAwait(this IUniTaskAsyncEnumerable source, Func> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new Cysharp.Threading.Tasks.Linq.SelectIntAwait(source, selector); } public static IUniTaskAsyncEnumerable SelectAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new Cysharp.Threading.Tasks.Linq.SelectAwaitWithCancellation(source, selector); } public static IUniTaskAsyncEnumerable SelectAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new Cysharp.Threading.Tasks.Linq.SelectIntAwaitWithCancellation(source, selector); } } internal sealed class Select : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func selector; public Select(IUniTaskAsyncEnumerable source, Func selector) { this.source = source; this.selector = selector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Select(source, selector, cancellationToken); } sealed class _Select : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func selector; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; Action moveNextAction; public _Select(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { this.source = source; this.selector = selector; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { Current = selector(enumerator.Current); goto CONTINUE; } else { goto DONE; } default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class SelectInt : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func selector; public SelectInt(IUniTaskAsyncEnumerable source, Func selector) { this.source = source; this.selector = selector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Select(source, selector, cancellationToken); } sealed class _Select : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func selector; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; Action moveNextAction; int index; public _Select(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { this.source = source; this.selector = selector; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { Current = selector(enumerator.Current, checked(index++)); goto CONTINUE; } else { goto DONE; } default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class SelectAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> selector; public SelectAwait(IUniTaskAsyncEnumerable source, Func> selector) { this.source = source; this.selector = selector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SelectAwait(source, selector, cancellationToken); } sealed class _SelectAwait : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> selector; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; public _SelectAwait(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { this.source = source; this.selector = selector; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { awaiter2 = selector(enumerator.Current).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: Current = awaiter2.GetResult(); goto CONTINUE; default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class SelectIntAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> selector; public SelectIntAwait(IUniTaskAsyncEnumerable source, Func> selector) { this.source = source; this.selector = selector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SelectAwait(source, selector, cancellationToken); } sealed class _SelectAwait : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> selector; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; int index; public _SelectAwait(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { this.source = source; this.selector = selector; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { awaiter2 = selector(enumerator.Current, checked(index++)).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: Current = awaiter2.GetResult(); goto CONTINUE; default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class SelectAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> selector; public SelectAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> selector) { this.source = source; this.selector = selector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SelectAwaitWithCancellation(source, selector, cancellationToken); } sealed class _SelectAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> selector; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; public _SelectAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { this.source = source; this.selector = selector; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { awaiter2 = selector(enumerator.Current, cancellationToken).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: Current = awaiter2.GetResult(); goto CONTINUE; default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class SelectIntAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> selector; public SelectIntAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> selector) { this.source = source; this.selector = selector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SelectAwaitWithCancellation(source, selector, cancellationToken); } sealed class _SelectAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> selector; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; int index; public _SelectAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { this.source = source; this.selector = selector; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { awaiter2 = selector(enumerator.Current, checked(index++), cancellationToken).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: Current = awaiter2.GetResult(); goto CONTINUE; default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Select.cs.meta ================================================ fileFormatVersion: 2 guid: dc68e598ca44a134b988dfaf5e53bfba MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SelectMany.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable SelectMany(this IUniTaskAsyncEnumerable source, Func> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new SelectMany(source, selector, (x, y) => y); } public static IUniTaskAsyncEnumerable SelectMany(this IUniTaskAsyncEnumerable source, Func> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new SelectMany(source, selector, (x, y) => y); } public static IUniTaskAsyncEnumerable SelectMany(this IUniTaskAsyncEnumerable source, Func> collectionSelector, Func resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(collectionSelector, nameof(collectionSelector)); return new SelectMany(source, collectionSelector, resultSelector); } public static IUniTaskAsyncEnumerable SelectMany(this IUniTaskAsyncEnumerable source, Func> collectionSelector, Func resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(collectionSelector, nameof(collectionSelector)); return new SelectMany(source, collectionSelector, resultSelector); } public static IUniTaskAsyncEnumerable SelectManyAwait(this IUniTaskAsyncEnumerable source, Func>> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new SelectManyAwait(source, selector, (x, y) => UniTask.FromResult(y)); } public static IUniTaskAsyncEnumerable SelectManyAwait(this IUniTaskAsyncEnumerable source, Func>> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new SelectManyAwait(source, selector, (x, y) => UniTask.FromResult(y)); } public static IUniTaskAsyncEnumerable SelectManyAwait(this IUniTaskAsyncEnumerable source, Func>> collectionSelector, Func> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(collectionSelector, nameof(collectionSelector)); return new SelectManyAwait(source, collectionSelector, resultSelector); } public static IUniTaskAsyncEnumerable SelectManyAwait(this IUniTaskAsyncEnumerable source, Func>> collectionSelector, Func> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(collectionSelector, nameof(collectionSelector)); return new SelectManyAwait(source, collectionSelector, resultSelector); } public static IUniTaskAsyncEnumerable SelectManyAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func>> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new SelectManyAwaitWithCancellation(source, selector, (x, y, c) => UniTask.FromResult(y)); } public static IUniTaskAsyncEnumerable SelectManyAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func>> selector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new SelectManyAwaitWithCancellation(source, selector, (x, y, c) => UniTask.FromResult(y)); } public static IUniTaskAsyncEnumerable SelectManyAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func>> collectionSelector, Func> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(collectionSelector, nameof(collectionSelector)); return new SelectManyAwaitWithCancellation(source, collectionSelector, resultSelector); } public static IUniTaskAsyncEnumerable SelectManyAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func>> collectionSelector, Func> resultSelector) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(collectionSelector, nameof(collectionSelector)); return new SelectManyAwaitWithCancellation(source, collectionSelector, resultSelector); } } internal sealed class SelectMany : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> selector1; readonly Func> selector2; readonly Func resultSelector; public SelectMany(IUniTaskAsyncEnumerable source, Func> selector, Func resultSelector) { this.source = source; this.selector1 = selector; this.selector2 = null; this.resultSelector = resultSelector; } public SelectMany(IUniTaskAsyncEnumerable source, Func> selector, Func resultSelector) { this.source = source; this.selector1 = null; this.selector2 = selector; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SelectMany(source, selector1, selector2, resultSelector, cancellationToken); } sealed class _SelectMany : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action sourceMoveNextCoreDelegate = SourceMoveNextCore; static readonly Action selectedSourceMoveNextCoreDelegate = SeletedSourceMoveNextCore; static readonly Action selectedEnumeratorDisposeAsyncCoreDelegate = SelectedEnumeratorDisposeAsyncCore; readonly IUniTaskAsyncEnumerable source; readonly Func> selector1; readonly Func> selector2; readonly Func resultSelector; CancellationToken cancellationToken; TSource sourceCurrent; int sourceIndex; IUniTaskAsyncEnumerator sourceEnumerator; IUniTaskAsyncEnumerator selectedEnumerator; UniTask.Awaiter sourceAwaiter; UniTask.Awaiter selectedAwaiter; UniTask.Awaiter selectedDisposeAsyncAwaiter; public _SelectMany(IUniTaskAsyncEnumerable source, Func> selector1, Func> selector2, Func resultSelector, CancellationToken cancellationToken) { this.source = source; this.selector1 = selector1; this.selector2 = selector2; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { completionSource.Reset(); // iterate selected field if (selectedEnumerator != null) { MoveNextSelected(); } else { // iterate source field if (sourceEnumerator == null) { sourceEnumerator = source.GetAsyncEnumerator(cancellationToken); } MoveNextSource(); } return new UniTask(this, completionSource.Version); } void MoveNextSource() { try { sourceAwaiter = sourceEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } if (sourceAwaiter.IsCompleted) { SourceMoveNextCore(this); } else { sourceAwaiter.SourceOnCompleted(sourceMoveNextCoreDelegate, this); } } void MoveNextSelected() { try { selectedAwaiter = selectedEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } if (selectedAwaiter.IsCompleted) { SeletedSourceMoveNextCore(this); } else { selectedAwaiter.SourceOnCompleted(selectedSourceMoveNextCoreDelegate, this); } } static void SourceMoveNextCore(object state) { var self = (_SelectMany)state; if (self.TryGetResult(self.sourceAwaiter, out var result)) { if (result) { try { self.sourceCurrent = self.sourceEnumerator.Current; if (self.selector1 != null) { self.selectedEnumerator = self.selector1(self.sourceCurrent).GetAsyncEnumerator(self.cancellationToken); } else { self.selectedEnumerator = self.selector2(self.sourceCurrent, checked(self.sourceIndex++)).GetAsyncEnumerator(self.cancellationToken); } } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } self.MoveNextSelected(); // iterated selected source. } else { self.completionSource.TrySetResult(false); } } } static void SeletedSourceMoveNextCore(object state) { var self = (_SelectMany)state; if (self.TryGetResult(self.selectedAwaiter, out var result)) { if (result) { try { self.Current = self.resultSelector(self.sourceCurrent, self.selectedEnumerator.Current); } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } self.completionSource.TrySetResult(true); } else { // dispose selected source and try iterate source. try { self.selectedDisposeAsyncAwaiter = self.selectedEnumerator.DisposeAsync().GetAwaiter(); } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } if (self.selectedDisposeAsyncAwaiter.IsCompleted) { SelectedEnumeratorDisposeAsyncCore(self); } else { self.selectedDisposeAsyncAwaiter.SourceOnCompleted(selectedEnumeratorDisposeAsyncCoreDelegate, self); } } } } static void SelectedEnumeratorDisposeAsyncCore(object state) { var self = (_SelectMany)state; if (self.TryGetResult(self.selectedDisposeAsyncAwaiter)) { self.selectedEnumerator = null; self.selectedAwaiter = default; self.MoveNextSource(); // iterate next source } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (selectedEnumerator != null) { await selectedEnumerator.DisposeAsync(); } if (sourceEnumerator != null) { await sourceEnumerator.DisposeAsync(); } } } } internal sealed class SelectManyAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func>> selector1; readonly Func>> selector2; readonly Func> resultSelector; public SelectManyAwait(IUniTaskAsyncEnumerable source, Func>> selector, Func> resultSelector) { this.source = source; this.selector1 = selector; this.selector2 = null; this.resultSelector = resultSelector; } public SelectManyAwait(IUniTaskAsyncEnumerable source, Func>> selector, Func> resultSelector) { this.source = source; this.selector1 = null; this.selector2 = selector; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SelectManyAwait(source, selector1, selector2, resultSelector, cancellationToken); } sealed class _SelectManyAwait : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action sourceMoveNextCoreDelegate = SourceMoveNextCore; static readonly Action selectedSourceMoveNextCoreDelegate = SeletedSourceMoveNextCore; static readonly Action selectedEnumeratorDisposeAsyncCoreDelegate = SelectedEnumeratorDisposeAsyncCore; static readonly Action selectorAwaitCoreDelegate = SelectorAwaitCore; static readonly Action resultSelectorAwaitCoreDelegate = ResultSelectorAwaitCore; readonly IUniTaskAsyncEnumerable source; readonly Func>> selector1; readonly Func>> selector2; readonly Func> resultSelector; CancellationToken cancellationToken; TSource sourceCurrent; int sourceIndex; IUniTaskAsyncEnumerator sourceEnumerator; IUniTaskAsyncEnumerator selectedEnumerator; UniTask.Awaiter sourceAwaiter; UniTask.Awaiter selectedAwaiter; UniTask.Awaiter selectedDisposeAsyncAwaiter; // await additional UniTask>.Awaiter collectionSelectorAwaiter; UniTask.Awaiter resultSelectorAwaiter; public _SelectManyAwait(IUniTaskAsyncEnumerable source, Func>> selector1, Func>> selector2, Func> resultSelector, CancellationToken cancellationToken) { this.source = source; this.selector1 = selector1; this.selector2 = selector2; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { completionSource.Reset(); // iterate selected field if (selectedEnumerator != null) { MoveNextSelected(); } else { // iterate source field if (sourceEnumerator == null) { sourceEnumerator = source.GetAsyncEnumerator(cancellationToken); } MoveNextSource(); } return new UniTask(this, completionSource.Version); } void MoveNextSource() { try { sourceAwaiter = sourceEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } if (sourceAwaiter.IsCompleted) { SourceMoveNextCore(this); } else { sourceAwaiter.SourceOnCompleted(sourceMoveNextCoreDelegate, this); } } void MoveNextSelected() { try { selectedAwaiter = selectedEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } if (selectedAwaiter.IsCompleted) { SeletedSourceMoveNextCore(this); } else { selectedAwaiter.SourceOnCompleted(selectedSourceMoveNextCoreDelegate, this); } } static void SourceMoveNextCore(object state) { var self = (_SelectManyAwait)state; if (self.TryGetResult(self.sourceAwaiter, out var result)) { if (result) { try { self.sourceCurrent = self.sourceEnumerator.Current; if (self.selector1 != null) { self.collectionSelectorAwaiter = self.selector1(self.sourceCurrent).GetAwaiter(); } else { self.collectionSelectorAwaiter = self.selector2(self.sourceCurrent, checked(self.sourceIndex++)).GetAwaiter(); } if (self.collectionSelectorAwaiter.IsCompleted) { SelectorAwaitCore(self); } else { self.collectionSelectorAwaiter.SourceOnCompleted(selectorAwaitCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } } else { self.completionSource.TrySetResult(false); } } } static void SeletedSourceMoveNextCore(object state) { var self = (_SelectManyAwait)state; if (self.TryGetResult(self.selectedAwaiter, out var result)) { if (result) { try { self.resultSelectorAwaiter = self.resultSelector(self.sourceCurrent, self.selectedEnumerator.Current).GetAwaiter(); if (self.resultSelectorAwaiter.IsCompleted) { ResultSelectorAwaitCore(self); } else { self.resultSelectorAwaiter.SourceOnCompleted(resultSelectorAwaitCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } } else { // dispose selected source and try iterate source. try { self.selectedDisposeAsyncAwaiter = self.selectedEnumerator.DisposeAsync().GetAwaiter(); } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } if (self.selectedDisposeAsyncAwaiter.IsCompleted) { SelectedEnumeratorDisposeAsyncCore(self); } else { self.selectedDisposeAsyncAwaiter.SourceOnCompleted(selectedEnumeratorDisposeAsyncCoreDelegate, self); } } } } static void SelectedEnumeratorDisposeAsyncCore(object state) { var self = (_SelectManyAwait)state; if (self.TryGetResult(self.selectedDisposeAsyncAwaiter)) { self.selectedEnumerator = null; self.selectedAwaiter = default; self.MoveNextSource(); // iterate next source } } static void SelectorAwaitCore(object state) { var self = (_SelectManyAwait)state; if (self.TryGetResult(self.collectionSelectorAwaiter, out var result)) { self.selectedEnumerator = result.GetAsyncEnumerator(self.cancellationToken); self.MoveNextSelected(); // iterated selected source. } } static void ResultSelectorAwaitCore(object state) { var self = (_SelectManyAwait)state; if (self.TryGetResult(self.resultSelectorAwaiter, out var result)) { self.Current = result; self.completionSource.TrySetResult(true); } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (selectedEnumerator != null) { await selectedEnumerator.DisposeAsync(); } if (sourceEnumerator != null) { await sourceEnumerator.DisposeAsync(); } } } } internal sealed class SelectManyAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func>> selector1; readonly Func>> selector2; readonly Func> resultSelector; public SelectManyAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func>> selector, Func> resultSelector) { this.source = source; this.selector1 = selector; this.selector2 = null; this.resultSelector = resultSelector; } public SelectManyAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func>> selector, Func> resultSelector) { this.source = source; this.selector1 = null; this.selector2 = selector; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SelectManyAwaitWithCancellation(source, selector1, selector2, resultSelector, cancellationToken); } sealed class _SelectManyAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action sourceMoveNextCoreDelegate = SourceMoveNextCore; static readonly Action selectedSourceMoveNextCoreDelegate = SeletedSourceMoveNextCore; static readonly Action selectedEnumeratorDisposeAsyncCoreDelegate = SelectedEnumeratorDisposeAsyncCore; static readonly Action selectorAwaitCoreDelegate = SelectorAwaitCore; static readonly Action resultSelectorAwaitCoreDelegate = ResultSelectorAwaitCore; readonly IUniTaskAsyncEnumerable source; readonly Func>> selector1; readonly Func>> selector2; readonly Func> resultSelector; CancellationToken cancellationToken; TSource sourceCurrent; int sourceIndex; IUniTaskAsyncEnumerator sourceEnumerator; IUniTaskAsyncEnumerator selectedEnumerator; UniTask.Awaiter sourceAwaiter; UniTask.Awaiter selectedAwaiter; UniTask.Awaiter selectedDisposeAsyncAwaiter; // await additional UniTask>.Awaiter collectionSelectorAwaiter; UniTask.Awaiter resultSelectorAwaiter; public _SelectManyAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func>> selector1, Func>> selector2, Func> resultSelector, CancellationToken cancellationToken) { this.source = source; this.selector1 = selector1; this.selector2 = selector2; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { completionSource.Reset(); // iterate selected field if (selectedEnumerator != null) { MoveNextSelected(); } else { // iterate source field if (sourceEnumerator == null) { sourceEnumerator = source.GetAsyncEnumerator(cancellationToken); } MoveNextSource(); } return new UniTask(this, completionSource.Version); } void MoveNextSource() { try { sourceAwaiter = sourceEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } if (sourceAwaiter.IsCompleted) { SourceMoveNextCore(this); } else { sourceAwaiter.SourceOnCompleted(sourceMoveNextCoreDelegate, this); } } void MoveNextSelected() { try { selectedAwaiter = selectedEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { completionSource.TrySetException(ex); return; } if (selectedAwaiter.IsCompleted) { SeletedSourceMoveNextCore(this); } else { selectedAwaiter.SourceOnCompleted(selectedSourceMoveNextCoreDelegate, this); } } static void SourceMoveNextCore(object state) { var self = (_SelectManyAwaitWithCancellation)state; if (self.TryGetResult(self.sourceAwaiter, out var result)) { if (result) { try { self.sourceCurrent = self.sourceEnumerator.Current; if (self.selector1 != null) { self.collectionSelectorAwaiter = self.selector1(self.sourceCurrent, self.cancellationToken).GetAwaiter(); } else { self.collectionSelectorAwaiter = self.selector2(self.sourceCurrent, checked(self.sourceIndex++), self.cancellationToken).GetAwaiter(); } if (self.collectionSelectorAwaiter.IsCompleted) { SelectorAwaitCore(self); } else { self.collectionSelectorAwaiter.SourceOnCompleted(selectorAwaitCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } } else { self.completionSource.TrySetResult(false); } } } static void SeletedSourceMoveNextCore(object state) { var self = (_SelectManyAwaitWithCancellation)state; if (self.TryGetResult(self.selectedAwaiter, out var result)) { if (result) { try { self.resultSelectorAwaiter = self.resultSelector(self.sourceCurrent, self.selectedEnumerator.Current, self.cancellationToken).GetAwaiter(); if (self.resultSelectorAwaiter.IsCompleted) { ResultSelectorAwaitCore(self); } else { self.resultSelectorAwaiter.SourceOnCompleted(resultSelectorAwaitCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } } else { // dispose selected source and try iterate source. try { self.selectedDisposeAsyncAwaiter = self.selectedEnumerator.DisposeAsync().GetAwaiter(); } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } if (self.selectedDisposeAsyncAwaiter.IsCompleted) { SelectedEnumeratorDisposeAsyncCore(self); } else { self.selectedDisposeAsyncAwaiter.SourceOnCompleted(selectedEnumeratorDisposeAsyncCoreDelegate, self); } } } } static void SelectedEnumeratorDisposeAsyncCore(object state) { var self = (_SelectManyAwaitWithCancellation)state; if (self.TryGetResult(self.selectedDisposeAsyncAwaiter)) { self.selectedEnumerator = null; self.selectedAwaiter = default; self.MoveNextSource(); // iterate next source } } static void SelectorAwaitCore(object state) { var self = (_SelectManyAwaitWithCancellation)state; if (self.TryGetResult(self.collectionSelectorAwaiter, out var result)) { self.selectedEnumerator = result.GetAsyncEnumerator(self.cancellationToken); self.MoveNextSelected(); // iterated selected source. } } static void ResultSelectorAwaitCore(object state) { var self = (_SelectManyAwaitWithCancellation)state; if (self.TryGetResult(self.resultSelectorAwaiter, out var result)) { self.Current = result; self.completionSource.TrySetResult(true); } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (selectedEnumerator != null) { await selectedEnumerator.DisposeAsync(); } if (sourceEnumerator != null) { await sourceEnumerator.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SelectMany.cs.meta ================================================ fileFormatVersion: 2 guid: d81862f0eb12680479ccaaf2ac319d24 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SequenceEqual.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask SequenceEqualAsync(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, CancellationToken cancellationToken = default) { return SequenceEqualAsync(first, second, EqualityComparer.Default, cancellationToken); } public static UniTask SequenceEqualAsync(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return SequenceEqual.SequenceEqualAsync(first, second, comparer, cancellationToken); } } internal static class SequenceEqual { internal static async UniTask SequenceEqualAsync(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer, CancellationToken cancellationToken) { var e1 = first.GetAsyncEnumerator(cancellationToken); try { var e2 = second.GetAsyncEnumerator(cancellationToken); try { while (true) { if (await e1.MoveNextAsync()) { if (await e2.MoveNextAsync()) { if (comparer.Equals(e1.Current, e2.Current)) { continue; } else { return false; } } else { // e2 is finished, but e1 has value return false; } } else { // e1 is finished, e2? if (await e2.MoveNextAsync()) { return false; } else { return true; } } } } finally { if (e2 != null) { await e2.DisposeAsync(); } } } finally { if (e1 != null) { await e1.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SequenceEqual.cs.meta ================================================ fileFormatVersion: 2 guid: b382772aba6128842928cdb6b2e034b0 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Single.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask SingleAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return SingleOperator.SingleAsync(source, cancellationToken, false); } public static UniTask SingleAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return SingleOperator.SingleAsync(source, predicate, cancellationToken, false); } public static UniTask SingleAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return SingleOperator.SingleAwaitAsync(source, predicate, cancellationToken, false); } public static UniTask SingleAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return SingleOperator.SingleAwaitWithCancellationAsync(source, predicate, cancellationToken, false); } public static UniTask SingleOrDefaultAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return SingleOperator.SingleAsync(source, cancellationToken, true); } public static UniTask SingleOrDefaultAsync(this IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return SingleOperator.SingleAsync(source, predicate, cancellationToken, true); } public static UniTask SingleOrDefaultAwaitAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return SingleOperator.SingleAwaitAsync(source, predicate, cancellationToken, true); } public static UniTask SingleOrDefaultAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return SingleOperator.SingleAwaitWithCancellationAsync(source, predicate, cancellationToken, true); } } internal static class SingleOperator { public static async UniTask SingleAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { if (await e.MoveNextAsync()) { var v = e.Current; if (!await e.MoveNextAsync()) { return v; } throw Error.MoreThanOneElement(); } else { if (defaultIfEmpty) { return default; } else { throw Error.NoElements(); } } } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask SingleAsync(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value = default; bool found = false; while (await e.MoveNextAsync()) { var v = e.Current; if (predicate(v)) { if (found) { throw Error.MoreThanOneElement(); } else { found = true; value = v; } } } if (found || defaultIfEmpty) { return value; } throw Error.NoElements(); } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask SingleAwaitAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value = default; bool found = false; while (await e.MoveNextAsync()) { var v = e.Current; if (await predicate(v)) { if (found) { throw Error.MoreThanOneElement(); } else { found = true; value = v; } } } if (found || defaultIfEmpty) { return value; } throw Error.NoElements(); } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTask SingleAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken, bool defaultIfEmpty) { var e = source.GetAsyncEnumerator(cancellationToken); try { TSource value = default; bool found = false; while (await e.MoveNextAsync()) { var v = e.Current; if (await predicate(v, cancellationToken)) { if (found) { throw Error.MoreThanOneElement(); } else { found = true; value = v; } } } if (found || defaultIfEmpty) { return value; } throw Error.NoElements(); } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Single.cs.meta ================================================ fileFormatVersion: 2 guid: 1bcd3928b90472e43a3a92c3ba708967 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Skip.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Skip(this IUniTaskAsyncEnumerable source, Int32 count) { Error.ThrowArgumentNullException(source, nameof(source)); return new Skip(source, count); } } internal sealed class Skip : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly int count; public Skip(IUniTaskAsyncEnumerable source, int count) { this.source = source; this.count = count; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Skip(source, count, cancellationToken); } sealed class _Skip : AsyncEnumeratorBase { readonly int count; int index; public _Skip(IUniTaskAsyncEnumerable source, int count, CancellationToken cancellationToken) : base(source, cancellationToken) { this.count = count; } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { if (count <= checked(index++)) { Current = SourceCurrent; result = true; return true; } else { result = default; return false; } } else { result = false; return true; } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Skip.cs.meta ================================================ fileFormatVersion: 2 guid: 9c46b6c7dce0cb049a73c81084c75154 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipLast.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable SkipLast(this IUniTaskAsyncEnumerable source, Int32 count) { Error.ThrowArgumentNullException(source, nameof(source)); // non skip. if (count <= 0) { return source; } return new SkipLast(source, count); } } internal sealed class SkipLast : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly int count; public SkipLast(IUniTaskAsyncEnumerable source, int count) { this.source = source; this.count = count; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SkipLast(source, count, cancellationToken); } sealed class _SkipLast : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; readonly int count; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; Queue queue; bool continueNext; public _SkipLast(IUniTaskAsyncEnumerable source, int count, CancellationToken cancellationToken) { this.source = source; this.count = count; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); queue = new Queue(); } completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } void SourceMoveNext() { try { LOOP: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; // avoid recursive } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_SkipLast)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { if (self.queue.Count == self.count) { self.continueNext = false; var deq = self.queue.Dequeue(); self.Current = deq; self.queue.Enqueue(self.enumerator.Current); self.completionSource.TrySetResult(true); } else { self.queue.Enqueue(self.enumerator.Current); if (!self.continueNext) { self.SourceMoveNext(); } } } else { self.continueNext = false; self.completionSource.TrySetResult(false); } } else { self.continueNext = false; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipLast.cs.meta ================================================ fileFormatVersion: 2 guid: df1d7f44d4fe7754f972c9e0b6fa72d5 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntil.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable SkipUntil(this IUniTaskAsyncEnumerable source, UniTask other) { Error.ThrowArgumentNullException(source, nameof(source)); return new SkipUntil(source, other, null); } public static IUniTaskAsyncEnumerable SkipUntil(this IUniTaskAsyncEnumerable source, Func other) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(other)); return new SkipUntil(source, default, other); } } internal sealed class SkipUntil : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly UniTask other; readonly Func other2; public SkipUntil(IUniTaskAsyncEnumerable source, UniTask other, Func other2) { this.source = source; this.other = other; this.other2 = other2; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { if (other2 != null) { return new _SkipUntil(source, this.other2(cancellationToken), cancellationToken); } else { return new _SkipUntil(source, this.other, cancellationToken); } } sealed class _SkipUntil : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action CancelDelegate1 = OnCanceled1; static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; CancellationToken cancellationToken1; bool completed; CancellationTokenRegistration cancellationTokenRegistration1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; bool continueNext; Exception exception; public _SkipUntil(IUniTaskAsyncEnumerable source, UniTask other, CancellationToken cancellationToken1) { this.source = source; this.cancellationToken1 = cancellationToken1; if (cancellationToken1.CanBeCanceled) { this.cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this); } TaskTracker.TrackActiveTask(this, 3); RunOther(other).Forget(); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (exception != null) { return UniTask.FromException(exception); } if (cancellationToken1.IsCancellationRequested) { return UniTask.FromCanceled(cancellationToken1); } if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken1); } completionSource.Reset(); if (completed) { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } void SourceMoveNext() { try { LOOP: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_SkipUntil)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.Current = self.enumerator.Current; self.completionSource.TrySetResult(true); if (self.continueNext) { self.SourceMoveNext(); } } else { self.completionSource.TrySetResult(false); } } } async UniTaskVoid RunOther(UniTask other) { try { await other; completed = true; SourceMoveNext(); } catch (Exception ex) { exception = ex; completionSource.TrySetException(ex); } } static void OnCanceled1(object state) { var self = (_SkipUntil)state; self.completionSource.TrySetCanceled(self.cancellationToken1); } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); cancellationTokenRegistration1.Dispose(); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntil.cs.meta ================================================ fileFormatVersion: 2 guid: de932d79c8d9f3841a066d05ff29edc9 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntilCanceled.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable SkipUntilCanceled(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); return new SkipUntilCanceled(source, cancellationToken); } } internal sealed class SkipUntilCanceled : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly CancellationToken cancellationToken; public SkipUntilCanceled(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SkipUntilCanceled(source, this.cancellationToken, cancellationToken); } sealed class _SkipUntilCanceled : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action CancelDelegate1 = OnCanceled1; static readonly Action CancelDelegate2 = OnCanceled2; static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; CancellationToken cancellationToken1; CancellationToken cancellationToken2; CancellationTokenRegistration cancellationTokenRegistration1; CancellationTokenRegistration cancellationTokenRegistration2; int isCanceled; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; bool continueNext; public _SkipUntilCanceled(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken1, CancellationToken cancellationToken2) { this.source = source; this.cancellationToken1 = cancellationToken1; this.cancellationToken2 = cancellationToken2; if (cancellationToken1.CanBeCanceled) { this.cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this); } if (cancellationToken1 != cancellationToken2 && cancellationToken2.CanBeCanceled) { this.cancellationTokenRegistration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(CancelDelegate2, this); } TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (enumerator == null) { if (cancellationToken1.IsCancellationRequested) isCanceled = 1; if (cancellationToken2.IsCancellationRequested) isCanceled = 1; enumerator = source.GetAsyncEnumerator(cancellationToken2); // use only AsyncEnumerator provided token. } completionSource.Reset(); if (isCanceled != 0) { SourceMoveNext(); } return new UniTask(this, completionSource.Version); } void SourceMoveNext() { try { LOOP: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_SkipUntilCanceled)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.Current = self.enumerator.Current; self.completionSource.TrySetResult(true); if (self.continueNext) { self.SourceMoveNext(); } } else { self.completionSource.TrySetResult(false); } } } static void OnCanceled1(object state) { var self = (_SkipUntilCanceled)state; if (self.isCanceled == 0) { if (Interlocked.Increment(ref self.isCanceled) == 1) { self.cancellationTokenRegistration2.Dispose(); self.SourceMoveNext(); } } } static void OnCanceled2(object state) { var self = (_SkipUntilCanceled)state; if (self.isCanceled == 0) { if (Interlocked.Increment(ref self.isCanceled) == 1) { self.cancellationTokenRegistration2.Dispose(); self.SourceMoveNext(); } } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); cancellationTokenRegistration1.Dispose(); cancellationTokenRegistration2.Dispose(); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipUntilCanceled.cs.meta ================================================ fileFormatVersion: 2 guid: 4b1a778aef7150d47b93a49aa1bc34ae MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipWhile.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable SkipWhile(this IUniTaskAsyncEnumerable source, Func predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new SkipWhile(source, predicate); } public static IUniTaskAsyncEnumerable SkipWhile(this IUniTaskAsyncEnumerable source, Func predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new SkipWhileInt(source, predicate); } public static IUniTaskAsyncEnumerable SkipWhileAwait(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new SkipWhileAwait(source, predicate); } public static IUniTaskAsyncEnumerable SkipWhileAwait(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new SkipWhileIntAwait(source, predicate); } public static IUniTaskAsyncEnumerable SkipWhileAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new SkipWhileAwaitWithCancellation(source, predicate); } public static IUniTaskAsyncEnumerable SkipWhileAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new SkipWhileIntAwaitWithCancellation(source, predicate); } } internal sealed class SkipWhile : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func predicate; public SkipWhile(IUniTaskAsyncEnumerable source, Func predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SkipWhile(source, predicate, cancellationToken); } class _SkipWhile : AsyncEnumeratorBase { Func predicate; public _SkipWhile(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { if (predicate == null || !predicate(SourceCurrent)) { predicate = null; Current = SourceCurrent; result = true; return true; } else { result = default; return false; } } result = false; return true; } } } internal sealed class SkipWhileInt : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func predicate; public SkipWhileInt(IUniTaskAsyncEnumerable source, Func predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SkipWhileInt(source, predicate, cancellationToken); } class _SkipWhileInt : AsyncEnumeratorBase { Func predicate; int index; public _SkipWhileInt(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { if (predicate == null || !predicate(SourceCurrent, checked(index++))) { predicate = null; Current = SourceCurrent; result = true; return true; } else { result = default; return false; } } result = false; return true; } } } internal sealed class SkipWhileAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public SkipWhileAwait(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SkipWhileAwait(source, predicate, cancellationToken); } class _SkipWhileAwait : AsyncEnumeratorAwaitSelectorBase { Func> predicate; public _SkipWhileAwait(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override UniTask TransformAsync(TSource sourceCurrent) { if (predicate == null) { return CompletedTasks.False; } return predicate(sourceCurrent); } protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration) { if (!awaitResult) { predicate = null; Current = SourceCurrent; terminateIteration= false; return true; } else { terminateIteration= false; return false; } } } } internal sealed class SkipWhileIntAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public SkipWhileIntAwait(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SkipWhileIntAwait(source, predicate, cancellationToken); } class _SkipWhileIntAwait : AsyncEnumeratorAwaitSelectorBase { Func> predicate; int index; public _SkipWhileIntAwait(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override UniTask TransformAsync(TSource sourceCurrent) { if (predicate == null) { return CompletedTasks.False; } return predicate(sourceCurrent, checked(index++)); } protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration) { terminateIteration= false; if (!awaitResult) { predicate = null; Current = SourceCurrent; return true; } else { return false; } } } } internal sealed class SkipWhileAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public SkipWhileAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SkipWhileAwaitWithCancellation(source, predicate, cancellationToken); } class _SkipWhileAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase { Func> predicate; public _SkipWhileAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override UniTask TransformAsync(TSource sourceCurrent) { if (predicate == null) { return CompletedTasks.False; } return predicate(sourceCurrent, cancellationToken); } protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration) { terminateIteration= false; if (!awaitResult) { predicate = null; Current = SourceCurrent; return true; } else { return false; } } } } internal sealed class SkipWhileIntAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public SkipWhileIntAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _SkipWhileIntAwaitWithCancellation(source, predicate, cancellationToken); } class _SkipWhileIntAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase { Func> predicate; int index; public _SkipWhileIntAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override UniTask TransformAsync(TSource sourceCurrent) { if (predicate == null) { return CompletedTasks.False; } return predicate(sourceCurrent, checked(index++), cancellationToken); } protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration) { terminateIteration= false; if (!awaitResult) { predicate = null; Current = SourceCurrent; return true; } else { return false; } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/SkipWhile.cs.meta ================================================ fileFormatVersion: 2 guid: 0b74b9fe361bf7148b51a29c8b2561e8 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Subscribe.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; using Subscribes = Cysharp.Threading.Tasks.Linq.Subscribe; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { // OnNext public static IDisposable Subscribe(this IUniTaskAsyncEnumerable source, Action action) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeCore(source, action, Subscribes.NopError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static IDisposable Subscribe(this IUniTaskAsyncEnumerable source, Func action) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeCore(source, action, Subscribes.NopError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static IDisposable Subscribe(this IUniTaskAsyncEnumerable source, Func action) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeCore(source, action, Subscribes.NopError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static void Subscribe(this IUniTaskAsyncEnumerable source, Action action, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); Subscribes.SubscribeCore(source, action, Subscribes.NopError, Subscribes.NopCompleted, cancellationToken).Forget(); } public static void Subscribe(this IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); Subscribes.SubscribeCore(source, action, Subscribes.NopError, Subscribes.NopCompleted, cancellationToken).Forget(); } public static void Subscribe(this IUniTaskAsyncEnumerable source, Func action, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(action, nameof(action)); Subscribes.SubscribeCore(source, action, Subscribes.NopError, Subscribes.NopCompleted, cancellationToken).Forget(); } public static IDisposable SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeAwaitCore(source, onNext, Subscribes.NopError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static void SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Subscribes.SubscribeAwaitCore(source, onNext, Subscribes.NopError, Subscribes.NopCompleted, cancellationToken).Forget(); } public static IDisposable SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeAwaitCore(source, onNext, Subscribes.NopError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static void SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Subscribes.SubscribeAwaitCore(source, onNext, Subscribes.NopError, Subscribes.NopCompleted, cancellationToken).Forget(); } // OnNext, OnError public static IDisposable Subscribe(this IUniTaskAsyncEnumerable source, Action onNext, Action onError) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onError, nameof(onError)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeCore(source, onNext, onError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static IDisposable Subscribe(this IUniTaskAsyncEnumerable source, Func onNext, Action onError) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onError, nameof(onError)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeCore(source, onNext, onError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static void Subscribe(this IUniTaskAsyncEnumerable source, Action onNext, Action onError, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onError, nameof(onError)); Subscribes.SubscribeCore(source, onNext, onError, Subscribes.NopCompleted, cancellationToken).Forget(); } public static void Subscribe(this IUniTaskAsyncEnumerable source, Func onNext, Action onError, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onError, nameof(onError)); Subscribes.SubscribeCore(source, onNext, onError, Subscribes.NopCompleted, cancellationToken).Forget(); } public static IDisposable SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, Action onError) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onError, nameof(onError)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeAwaitCore(source, onNext, onError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static void SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, Action onError, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onError, nameof(onError)); Subscribes.SubscribeAwaitCore(source, onNext, onError, Subscribes.NopCompleted, cancellationToken).Forget(); } public static IDisposable SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, Action onError) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onError, nameof(onError)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeAwaitCore(source, onNext, onError, Subscribes.NopCompleted, cts.Token).Forget(); return cts; } public static void SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, Action onError, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onError, nameof(onError)); Subscribes.SubscribeAwaitCore(source, onNext, onError, Subscribes.NopCompleted, cancellationToken).Forget(); } // OnNext, OnCompleted public static IDisposable Subscribe(this IUniTaskAsyncEnumerable source, Action onNext, Action onCompleted) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onCompleted, nameof(onCompleted)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeCore(source, onNext, Subscribes.NopError, onCompleted, cts.Token).Forget(); return cts; } public static IDisposable Subscribe(this IUniTaskAsyncEnumerable source, Func onNext, Action onCompleted) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onCompleted, nameof(onCompleted)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeCore(source, onNext, Subscribes.NopError, onCompleted, cts.Token).Forget(); return cts; } public static void Subscribe(this IUniTaskAsyncEnumerable source, Action onNext, Action onCompleted, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onCompleted, nameof(onCompleted)); Subscribes.SubscribeCore(source, onNext, Subscribes.NopError, onCompleted, cancellationToken).Forget(); } public static void Subscribe(this IUniTaskAsyncEnumerable source, Func onNext, Action onCompleted, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onCompleted, nameof(onCompleted)); Subscribes.SubscribeCore(source, onNext, Subscribes.NopError, onCompleted, cancellationToken).Forget(); } public static IDisposable SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, Action onCompleted) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onCompleted, nameof(onCompleted)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeAwaitCore(source, onNext, Subscribes.NopError, onCompleted, cts.Token).Forget(); return cts; } public static void SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, Action onCompleted, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onCompleted, nameof(onCompleted)); Subscribes.SubscribeAwaitCore(source, onNext, Subscribes.NopError, onCompleted, cancellationToken).Forget(); } public static IDisposable SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, Action onCompleted) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onCompleted, nameof(onCompleted)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeAwaitCore(source, onNext, Subscribes.NopError, onCompleted, cts.Token).Forget(); return cts; } public static void SubscribeAwait(this IUniTaskAsyncEnumerable source, Func onNext, Action onCompleted, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(onNext, nameof(onNext)); Error.ThrowArgumentNullException(onCompleted, nameof(onCompleted)); Subscribes.SubscribeAwaitCore(source, onNext, Subscribes.NopError, onCompleted, cancellationToken).Forget(); } // IObserver public static IDisposable Subscribe(this IUniTaskAsyncEnumerable source, IObserver observer) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(observer, nameof(observer)); var cts = new CancellationTokenDisposable(); Subscribes.SubscribeCore(source, observer, cts.Token).Forget(); return cts; } public static void Subscribe(this IUniTaskAsyncEnumerable source, IObserver observer, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(observer, nameof(observer)); Subscribes.SubscribeCore(source, observer, cancellationToken).Forget(); } } internal sealed class CancellationTokenDisposable : IDisposable { readonly CancellationTokenSource cts = new CancellationTokenSource(); public CancellationToken Token => cts.Token; public void Dispose() { if (!cts.IsCancellationRequested) { cts.Cancel(); } } } internal static class Subscribe { public static readonly Action NopError = _ => { }; public static readonly Action NopCompleted = () => { }; public static async UniTaskVoid SubscribeCore(IUniTaskAsyncEnumerable source, Action onNext, Action onError, Action onCompleted, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { try { onNext(e.Current); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } onCompleted(); } catch (Exception ex) { if (onError == NopError) { UniTaskScheduler.PublishUnobservedTaskException(ex); return; } if (ex is OperationCanceledException) return; onError(ex); } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTaskVoid SubscribeCore(IUniTaskAsyncEnumerable source, Func onNext, Action onError, Action onCompleted, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { try { onNext(e.Current).Forget(); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } onCompleted(); } catch (Exception ex) { if (onError == NopError) { UniTaskScheduler.PublishUnobservedTaskException(ex); return; } if (ex is OperationCanceledException) return; onError(ex); } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTaskVoid SubscribeCore(IUniTaskAsyncEnumerable source, Func onNext, Action onError, Action onCompleted, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { try { onNext(e.Current, cancellationToken).Forget(); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } onCompleted(); } catch (Exception ex) { if (onError == NopError) { UniTaskScheduler.PublishUnobservedTaskException(ex); return; } if (ex is OperationCanceledException) return; onError(ex); } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTaskVoid SubscribeCore(IUniTaskAsyncEnumerable source, IObserver observer, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { try { observer.OnNext(e.Current); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } observer.OnCompleted(); } catch (Exception ex) { if (ex is OperationCanceledException) return; observer.OnError(ex); } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTaskVoid SubscribeAwaitCore(IUniTaskAsyncEnumerable source, Func onNext, Action onError, Action onCompleted, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { try { await onNext(e.Current); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } onCompleted(); } catch (Exception ex) { if (onError == NopError) { UniTaskScheduler.PublishUnobservedTaskException(ex); return; } if (ex is OperationCanceledException) return; onError(ex); } finally { if (e != null) { await e.DisposeAsync(); } } } public static async UniTaskVoid SubscribeAwaitCore(IUniTaskAsyncEnumerable source, Func onNext, Action onError, Action onCompleted, CancellationToken cancellationToken) { var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { try { await onNext(e.Current, cancellationToken); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } onCompleted(); } catch (Exception ex) { if (onError == NopError) { UniTaskScheduler.PublishUnobservedTaskException(ex); return; } if (ex is OperationCanceledException) return; onError(ex); } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Subscribe.cs.meta ================================================ fileFormatVersion: 2 guid: 263479eb04c189741931fc0e2f615c2d MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Sum.cs ================================================ using System; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask SumAsync(this IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } } internal static class Sum { public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int32 sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int32 sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32 sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32 sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int64 sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int64 sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64 sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64 sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Single sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Single sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Double sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Double sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Decimal sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Decimal sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int32? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current.GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int32? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int32? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Int64? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current.GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Int64? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Int64? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Single? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current.GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Single? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Single? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Double? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current.GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Double? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Double? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Decimal? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current.GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAsync(IUniTaskAsyncEnumerable source, Func selector, CancellationToken cancellationToken) { Decimal? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { Decimal? sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken)).GetValueOrDefault(); } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Sum.cs.meta ================================================ fileFormatVersion: 2 guid: 4149754066a21a341be58c04357061f6 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Sum.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> <# var types = new[] { typeof(int), typeof(long), typeof(float), typeof(double), typeof(decimal), typeof(int?), typeof(long?), typeof(float?), typeof(double?), typeof(decimal?), }; Func IsNullable = x => x.IsGenericType; Func TypeName = x => IsNullable(x) ? x.GetGenericArguments()[0].Name + "?" : x.Name; Func WithSuffix = x => IsNullable(x) ? ".GetValueOrDefault()" : ""; #> using System; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { <# foreach(var t in types) { #> public static UniTask<<#= TypeName(t) #>> SumAsync(this IUniTaskAsyncEnumerable<<#= TypeName(t) #>> source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Sum.SumAsync(source, cancellationToken); } public static UniTask<<#= TypeName(t) #>> SumAsync(this IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAsync(source, selector, cancellationToken); } public static UniTask<<#= TypeName(t) #>> SumAwaitAsync(this IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitAsync(source, selector, cancellationToken); } public static UniTask<<#= TypeName(t) #>> SumAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(selector)); return Sum.SumAwaitWithCancellationAsync(source, selector, cancellationToken); } <# } #> } internal static class Sum { <# foreach(var t in types) { #> public static async UniTask<<#= TypeName(t) #>> SumAsync(IUniTaskAsyncEnumerable<<#= TypeName(t) #>> source, CancellationToken cancellationToken) { <#= TypeName(t) #> sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += e.Current<#= WithSuffix(t) #>; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask<<#= TypeName(t) #>> SumAsync(IUniTaskAsyncEnumerable source, Func> selector, CancellationToken cancellationToken) { <#= TypeName(t) #> sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += selector(e.Current)<#= WithSuffix(t) #>; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask<<#= TypeName(t) #>> SumAwaitAsync(IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken) { <#= TypeName(t) #> sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current))<#= WithSuffix(t) #>; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } public static async UniTask<<#= TypeName(t) #>> SumAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func>> selector, CancellationToken cancellationToken) { <#= TypeName(t) #> sum = default; var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { sum += (await selector(e.Current, cancellationToken))<#= WithSuffix(t) #>; } } finally { if (e != null) { await e.DisposeAsync(); } } return sum; } <# } #> } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Sum.tt.meta ================================================ fileFormatVersion: 2 guid: b61271ca8e712494ab1ce2d10b180b6f DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Take.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Take(this IUniTaskAsyncEnumerable source, Int32 count) { Error.ThrowArgumentNullException(source, nameof(source)); return new Take(source, count); } } internal sealed class Take : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly int count; public Take(IUniTaskAsyncEnumerable source, int count) { this.source = source; this.count = count; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Take(source, count, cancellationToken); } sealed class _Take : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; readonly int count; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; int index; public _Take(IUniTaskAsyncEnumerable source, int count, CancellationToken cancellationToken) { this.source = source; this.count = count; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); } if (checked(index) >= count) { return CompletedTasks.False; } completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } void SourceMoveNext() { try { awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_Take)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { self.index++; self.Current = self.enumerator.Current; self.completionSource.TrySetResult(true); } else { self.completionSource.TrySetResult(false); } } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Take.cs.meta ================================================ fileFormatVersion: 2 guid: 42f02cb84e5875b488304755d0e1383d MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeLast.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable TakeLast(this IUniTaskAsyncEnumerable source, Int32 count) { Error.ThrowArgumentNullException(source, nameof(source)); // non take. if (count <= 0) { return Empty(); } return new TakeLast(source, count); } } internal sealed class TakeLast : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly int count; public TakeLast(IUniTaskAsyncEnumerable source, int count) { this.source = source; this.count = count; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TakeLast(source, count, cancellationToken); } sealed class _TakeLast : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; readonly int count; CancellationToken cancellationToken; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; Queue queue; bool iterateCompleted; bool continueNext; public _TakeLast(IUniTaskAsyncEnumerable source, int count, CancellationToken cancellationToken) { this.source = source; this.count = count; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken); queue = new Queue(); } completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } void SourceMoveNext() { if (iterateCompleted) { if (queue.Count > 0) { Current = queue.Dequeue(); completionSource.TrySetResult(true); } else { completionSource.TrySetResult(false); } return; } try { LOOP: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { continueNext = true; MoveNextCore(this); if (continueNext) { continueNext = false; goto LOOP; // avoid recursive } } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_TakeLast)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { if (self.queue.Count < self.count) { self.queue.Enqueue(self.enumerator.Current); if (!self.continueNext) { self.SourceMoveNext(); } } else { self.queue.Dequeue(); self.queue.Enqueue(self.enumerator.Current); if (!self.continueNext) { self.SourceMoveNext(); } } } else { self.continueNext = false; self.iterateCompleted = true; self.SourceMoveNext(); } } else { self.continueNext = false; } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeLast.cs.meta ================================================ fileFormatVersion: 2 guid: 510aa9fd35b45fc40bcdb7e59f01fd1b MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntil.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable TakeUntil(this IUniTaskAsyncEnumerable source, UniTask other) { Error.ThrowArgumentNullException(source, nameof(source)); return new TakeUntil(source, other, null); } public static IUniTaskAsyncEnumerable TakeUntil(this IUniTaskAsyncEnumerable source, Func other) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(source, nameof(other)); return new TakeUntil(source, default, other); } } internal sealed class TakeUntil : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly UniTask other; readonly Func other2; public TakeUntil(IUniTaskAsyncEnumerable source, UniTask other, Func other2) { this.source = source; this.other = other; this.other2 = other2; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { if (other2 != null) { return new _TakeUntil(source, this.other2(cancellationToken), cancellationToken); } else { return new _TakeUntil(source, this.other, cancellationToken); } } sealed class _TakeUntil : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action CancelDelegate1 = OnCanceled1; static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; CancellationToken cancellationToken1; CancellationTokenRegistration cancellationTokenRegistration1; bool completed; Exception exception; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; public _TakeUntil(IUniTaskAsyncEnumerable source, UniTask other, CancellationToken cancellationToken1) { this.source = source; this.cancellationToken1 = cancellationToken1; if (cancellationToken1.CanBeCanceled) { this.cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this); } TaskTracker.TrackActiveTask(this, 3); RunOther(other).Forget(); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (completed) { return CompletedTasks.False; } if (exception != null) { return UniTask.FromException(exception); } if (cancellationToken1.IsCancellationRequested) { return UniTask.FromCanceled(cancellationToken1); } if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken1); } completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } void SourceMoveNext() { try { awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_TakeUntil)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { if (self.exception != null) { self.completionSource.TrySetException(self.exception); } else if (self.cancellationToken1.IsCancellationRequested) { self.completionSource.TrySetCanceled(self.cancellationToken1); } else { self.Current = self.enumerator.Current; self.completionSource.TrySetResult(true); } } else { self.completionSource.TrySetResult(false); } } } async UniTaskVoid RunOther(UniTask other) { try { await other; completed = true; completionSource.TrySetResult(false); } catch (Exception ex) { exception = ex; completionSource.TrySetException(ex); } } static void OnCanceled1(object state) { var self = (_TakeUntil)state; self.completionSource.TrySetCanceled(self.cancellationToken1); } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); cancellationTokenRegistration1.Dispose(); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntil.cs.meta ================================================ fileFormatVersion: 2 guid: 12bda324162f15349afefc2c152ac07f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntilCanceled.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable TakeUntilCanceled(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { Error.ThrowArgumentNullException(source, nameof(source)); return new TakeUntilCanceled(source, cancellationToken); } } internal sealed class TakeUntilCanceled : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly CancellationToken cancellationToken; public TakeUntilCanceled(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TakeUntilCanceled(source, this.cancellationToken, cancellationToken); } sealed class _TakeUntilCanceled : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action CancelDelegate1 = OnCanceled1; static readonly Action CancelDelegate2 = OnCanceled2; static readonly Action MoveNextCoreDelegate = MoveNextCore; readonly IUniTaskAsyncEnumerable source; CancellationToken cancellationToken1; CancellationToken cancellationToken2; CancellationTokenRegistration cancellationTokenRegistration1; CancellationTokenRegistration cancellationTokenRegistration2; bool isCanceled; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; public _TakeUntilCanceled(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken1, CancellationToken cancellationToken2) { this.source = source; this.cancellationToken1 = cancellationToken1; this.cancellationToken2 = cancellationToken2; if (cancellationToken1.CanBeCanceled) { this.cancellationTokenRegistration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(CancelDelegate1, this); } if (cancellationToken1 != cancellationToken2 && cancellationToken2.CanBeCanceled) { this.cancellationTokenRegistration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(CancelDelegate2, this); } TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (cancellationToken1.IsCancellationRequested) isCanceled = true; if (cancellationToken2.IsCancellationRequested) isCanceled = true; if (enumerator == null) { enumerator = source.GetAsyncEnumerator(cancellationToken2); // use only AsyncEnumerator provided token. } if (isCanceled) return CompletedTasks.False; completionSource.Reset(); SourceMoveNext(); return new UniTask(this, completionSource.Version); } void SourceMoveNext() { try { awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { MoveNextCore(this); } else { awaiter.SourceOnCompleted(MoveNextCoreDelegate, this); } } catch (Exception ex) { completionSource.TrySetException(ex); } } static void MoveNextCore(object state) { var self = (_TakeUntilCanceled)state; if (self.TryGetResult(self.awaiter, out var result)) { if (result) { if (self.isCanceled) { self.completionSource.TrySetResult(false); } else { self.Current = self.enumerator.Current; self.completionSource.TrySetResult(true); } } else { self.completionSource.TrySetResult(false); } } } static void OnCanceled1(object state) { var self = (_TakeUntilCanceled)state; if (!self.isCanceled) { self.cancellationTokenRegistration2.Dispose(); self.completionSource.TrySetResult(false); } } static void OnCanceled2(object state) { var self = (_TakeUntilCanceled)state; if (!self.isCanceled) { self.cancellationTokenRegistration1.Dispose(); self.completionSource.TrySetResult(false); } } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); cancellationTokenRegistration1.Dispose(); cancellationTokenRegistration2.Dispose(); if (enumerator != null) { return enumerator.DisposeAsync(); } return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeUntilCanceled.cs.meta ================================================ fileFormatVersion: 2 guid: e82f498cf3a1df04cbf646773fc11319 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeWhile.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable TakeWhile(this IUniTaskAsyncEnumerable source, Func predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new TakeWhile(source, predicate); } public static IUniTaskAsyncEnumerable TakeWhile(this IUniTaskAsyncEnumerable source, Func predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new TakeWhileInt(source, predicate); } public static IUniTaskAsyncEnumerable TakeWhileAwait(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new TakeWhileAwait(source, predicate); } public static IUniTaskAsyncEnumerable TakeWhileAwait(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new TakeWhileIntAwait(source, predicate); } public static IUniTaskAsyncEnumerable TakeWhileAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new TakeWhileAwaitWithCancellation(source, predicate); } public static IUniTaskAsyncEnumerable TakeWhileAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new TakeWhileIntAwaitWithCancellation(source, predicate); } } internal sealed class TakeWhile : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func predicate; public TakeWhile(IUniTaskAsyncEnumerable source, Func predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TakeWhile(source, predicate, cancellationToken); } class _TakeWhile : AsyncEnumeratorBase { Func predicate; public _TakeWhile(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { if (predicate(SourceCurrent)) { Current = SourceCurrent; result = true; return true; } } result = false; return true; } } } internal sealed class TakeWhileInt : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func predicate; public TakeWhileInt(IUniTaskAsyncEnumerable source, Func predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TakeWhileInt(source, predicate, cancellationToken); } class _TakeWhileInt : AsyncEnumeratorBase { readonly Func predicate; int index; public _TakeWhileInt(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override bool TryMoveNextCore(bool sourceHasCurrent, out bool result) { if (sourceHasCurrent) { if (predicate(SourceCurrent, checked(index++))) { Current = SourceCurrent; result = true; return true; } } result = false; return true; } } } internal sealed class TakeWhileAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public TakeWhileAwait(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TakeWhileAwait(source, predicate, cancellationToken); } class _TakeWhileAwait : AsyncEnumeratorAwaitSelectorBase { Func> predicate; public _TakeWhileAwait(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override UniTask TransformAsync(TSource sourceCurrent) { return predicate(sourceCurrent); } protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration) { if (awaitResult) { Current = SourceCurrent; terminateIteration = false; return true; } else { terminateIteration = true; return false; } } } } internal sealed class TakeWhileIntAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public TakeWhileIntAwait(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TakeWhileIntAwait(source, predicate, cancellationToken); } class _TakeWhileIntAwait : AsyncEnumeratorAwaitSelectorBase { readonly Func> predicate; int index; public _TakeWhileIntAwait(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override UniTask TransformAsync(TSource sourceCurrent) { return predicate(sourceCurrent, checked(index++)); } protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration) { if (awaitResult) { Current = SourceCurrent; terminateIteration = false; return true; } else { terminateIteration = true; return false; } } } } internal sealed class TakeWhileAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public TakeWhileAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TakeWhileAwaitWithCancellation(source, predicate, cancellationToken); } class _TakeWhileAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase { Func> predicate; public _TakeWhileAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override UniTask TransformAsync(TSource sourceCurrent) { return predicate(sourceCurrent, cancellationToken); } protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration) { if (awaitResult) { Current = SourceCurrent; terminateIteration = false; return true; } else { terminateIteration = true; return false; } } } } internal sealed class TakeWhileIntAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public TakeWhileIntAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TakeWhileIntAwaitWithCancellation(source, predicate, cancellationToken); } class _TakeWhileIntAwaitWithCancellation : AsyncEnumeratorAwaitSelectorBase { readonly Func> predicate; int index; public _TakeWhileIntAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) : base(source, cancellationToken) { this.predicate = predicate; } protected override UniTask TransformAsync(TSource sourceCurrent) { return predicate(sourceCurrent, checked(index++), cancellationToken); } protected override bool TrySetCurrentCore(bool awaitResult, out bool terminateIteration) { if (awaitResult) { Current = SourceCurrent; terminateIteration = false; return true; } else { terminateIteration = true; return false; } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/TakeWhile.cs.meta ================================================ fileFormatVersion: 2 guid: bca55adabcc4b3141b50b8b09634f764 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Throw.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Throw(Exception exception) { return new Throw(exception); } } internal class Throw : IUniTaskAsyncEnumerable { readonly Exception exception; public Throw(Exception exception) { this.exception = exception; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Throw(exception, cancellationToken); } class _Throw : IUniTaskAsyncEnumerator { readonly Exception exception; CancellationToken cancellationToken; public _Throw(Exception exception, CancellationToken cancellationToken) { this.exception = exception; this.cancellationToken = cancellationToken; } public TValue Current => default; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); return UniTask.FromException(exception); } public UniTask DisposeAsync() { return default; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Throw.cs.meta ================================================ fileFormatVersion: 2 guid: 9d05a7d4f4161e549b4789e1022baae8 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToArray.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask ToArrayAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Cysharp.Threading.Tasks.Linq.ToArray.ToArrayAsync(source, cancellationToken); } } internal static class ToArray { internal static async UniTask ToArrayAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { var pool = ArrayPool.Shared; var array = pool.Rent(16); TSource[] result = default; IUniTaskAsyncEnumerator e = default; try { e = source.GetAsyncEnumerator(cancellationToken); var i = 0; while (await e.MoveNextAsync()) { ArrayPoolUtil.EnsureCapacity(ref array, i, pool); array[i++] = e.Current; } if (i == 0) { result = Array.Empty(); } else { result = new TSource[i]; Array.Copy(array, result, i); } } finally { pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); if (e != null) { await e.DisposeAsync(); } } return result; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToArray.cs.meta ================================================ fileFormatVersion: 2 guid: debb010bbb1622e43b94fe70ec0133dd MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToDictionary.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask> ToDictionaryAsync(this IUniTaskAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return ToDictionary.ToDictionaryAsync(source, keySelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToDictionaryAsync(this IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToDictionary.ToDictionaryAsync(source, keySelector, comparer, cancellationToken); } public static UniTask> ToDictionaryAsync(this IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return ToDictionary.ToDictionaryAsync(source, keySelector, elementSelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToDictionaryAsync(this IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToDictionary.ToDictionaryAsync(source, keySelector, elementSelector, comparer, cancellationToken); } public static UniTask> ToDictionaryAwaitAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return ToDictionary.ToDictionaryAwaitAsync(source, keySelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToDictionaryAwaitAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToDictionary.ToDictionaryAwaitAsync(source, keySelector, comparer, cancellationToken); } public static UniTask> ToDictionaryAwaitAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return ToDictionary.ToDictionaryAwaitAsync(source, keySelector, elementSelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToDictionaryAwaitAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToDictionary.ToDictionaryAwaitAsync(source, keySelector, elementSelector, comparer, cancellationToken); } public static UniTask> ToDictionaryAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return ToDictionary.ToDictionaryAwaitWithCancellationAsync(source, keySelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToDictionaryAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToDictionary.ToDictionaryAwaitWithCancellationAsync(source, keySelector, comparer, cancellationToken); } public static UniTask> ToDictionaryAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return ToDictionary.ToDictionaryAwaitWithCancellationAsync(source, keySelector, elementSelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToDictionaryAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToDictionary.ToDictionaryAwaitWithCancellationAsync(source, keySelector, elementSelector, comparer, cancellationToken); } } internal static class ToDictionary { internal static async UniTask> ToDictionaryAsync(IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var dict = new Dictionary(comparer); var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; var key = keySelector(v); dict.Add(key, v); } } finally { if (e != null) { await e.DisposeAsync(); } } return dict; } internal static async UniTask> ToDictionaryAsync(IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var dict = new Dictionary(comparer); var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; var key = keySelector(v); var value = elementSelector(v); dict.Add(key, value); } } finally { if (e != null) { await e.DisposeAsync(); } } return dict; } // with await internal static async UniTask> ToDictionaryAwaitAsync(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var dict = new Dictionary(comparer); var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; var key = await keySelector(v); dict.Add(key, v); } } finally { if (e != null) { await e.DisposeAsync(); } } return dict; } internal static async UniTask> ToDictionaryAwaitAsync(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var dict = new Dictionary(comparer); var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; var key = await keySelector(v); var value = await elementSelector(v); dict.Add(key, value); } } finally { if (e != null) { await e.DisposeAsync(); } } return dict; } // with cancellation internal static async UniTask> ToDictionaryAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var dict = new Dictionary(comparer); var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; var key = await keySelector(v, cancellationToken); dict.Add(key, v); } } finally { if (e != null) { await e.DisposeAsync(); } } return dict; } internal static async UniTask> ToDictionaryAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var dict = new Dictionary(comparer); var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { var v = e.Current; var key = await keySelector(v, cancellationToken); var value = await elementSelector(v, cancellationToken); dict.Add(key, value); } } finally { if (e != null) { await e.DisposeAsync(); } } return dict; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToDictionary.cs.meta ================================================ fileFormatVersion: 2 guid: 03b109b1fe1f2df46aa56ffb26747654 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToHashSet.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask> ToHashSetAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Cysharp.Threading.Tasks.Linq.ToHashSet.ToHashSetAsync(source, EqualityComparer.Default, cancellationToken); } public static UniTask> ToHashSetAsync(this IUniTaskAsyncEnumerable source, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return Cysharp.Threading.Tasks.Linq.ToHashSet.ToHashSetAsync(source, comparer, cancellationToken); } } internal static class ToHashSet { internal static async UniTask> ToHashSetAsync(IUniTaskAsyncEnumerable source, IEqualityComparer comparer, CancellationToken cancellationToken) { var set = new HashSet(comparer); var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { set.Add(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } return set; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToHashSet.cs.meta ================================================ fileFormatVersion: 2 guid: 7a3e552113af96e4986805ec3c4fc80a MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToList.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask> ToListAsync(this IUniTaskAsyncEnumerable source, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); return Cysharp.Threading.Tasks.Linq.ToList.ToListAsync(source, cancellationToken); } } internal static class ToList { internal static async UniTask> ToListAsync(IUniTaskAsyncEnumerable source, CancellationToken cancellationToken) { var list = new List(); var e = source.GetAsyncEnumerator(cancellationToken); try { while (await e.MoveNextAsync()) { list.Add(e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } return list; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToList.cs.meta ================================================ fileFormatVersion: 2 guid: 3859c1b31e81d9b44b282e7d97e11635 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToLookup.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static UniTask> ToLookupAsync(this IUniTaskAsyncEnumerable source, Func keySelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return ToLookup.ToLookupAsync(source, keySelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToLookupAsync(this IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToLookup.ToLookupAsync(source, keySelector, comparer, cancellationToken); } public static UniTask> ToLookupAsync(this IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return ToLookup.ToLookupAsync(source, keySelector, elementSelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToLookupAsync(this IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToLookup.ToLookupAsync(source, keySelector, elementSelector, comparer, cancellationToken); } public static UniTask> ToLookupAwaitAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return ToLookup.ToLookupAwaitAsync(source, keySelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToLookupAwaitAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToLookup.ToLookupAwaitAsync(source, keySelector, comparer, cancellationToken); } public static UniTask> ToLookupAwaitAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return ToLookup.ToLookupAwaitAsync(source, keySelector, elementSelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToLookupAwaitAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToLookup.ToLookupAwaitAsync(source, keySelector, elementSelector, comparer, cancellationToken); } public static UniTask> ToLookupAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); return ToLookup.ToLookupAwaitWithCancellationAsync(source, keySelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToLookupAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToLookup.ToLookupAwaitWithCancellationAsync(source, keySelector, comparer, cancellationToken); } public static UniTask> ToLookupAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); return ToLookup.ToLookupAwaitWithCancellationAsync(source, keySelector, elementSelector, EqualityComparer.Default, cancellationToken); } public static UniTask> ToLookupAwaitWithCancellationAsync(this IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(keySelector, nameof(keySelector)); Error.ThrowArgumentNullException(elementSelector, nameof(elementSelector)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); return ToLookup.ToLookupAwaitWithCancellationAsync(source, keySelector, elementSelector, comparer, cancellationToken); } } internal static class ToLookup { internal static async UniTask> ToLookupAsync(IUniTaskAsyncEnumerable source, Func keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var pool = ArrayPool.Shared; var array = pool.Rent(16); var e = source.GetAsyncEnumerator(cancellationToken); try { var i = 0; while (await e.MoveNextAsync()) { ArrayPoolUtil.EnsureCapacity(ref array, i, pool); array[i++] = e.Current; } if (i == 0) { return Lookup.CreateEmpty(); } else { return Lookup.Create(new ArraySegment(array, 0, i), keySelector, comparer); } } finally { pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask> ToLookupAsync(IUniTaskAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var pool = ArrayPool.Shared; var array = pool.Rent(16); IUniTaskAsyncEnumerator e = default; try { e = source.GetAsyncEnumerator(cancellationToken); var i = 0; while (await e.MoveNextAsync()) { ArrayPoolUtil.EnsureCapacity(ref array, i, pool); array[i++] = e.Current; } if (i == 0) { return Lookup.CreateEmpty(); } else { return Lookup.Create(new ArraySegment(array, 0, i), keySelector, elementSelector, comparer); } } finally { pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); if (e != null) { await e.DisposeAsync(); } } } // with await internal static async UniTask> ToLookupAwaitAsync(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var pool = ArrayPool.Shared; var array = pool.Rent(16); IUniTaskAsyncEnumerator e = default; try { e = source.GetAsyncEnumerator(cancellationToken); var i = 0; while (await e.MoveNextAsync()) { ArrayPoolUtil.EnsureCapacity(ref array, i, pool); array[i++] = e.Current; } if (i == 0) { return Lookup.CreateEmpty(); } else { return await Lookup.CreateAsync(new ArraySegment(array, 0, i), keySelector, comparer); } } finally { pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask> ToLookupAwaitAsync(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var pool = ArrayPool.Shared; var array = pool.Rent(16); IUniTaskAsyncEnumerator e = default; try { e = source.GetAsyncEnumerator(cancellationToken); var i = 0; while (await e.MoveNextAsync()) { ArrayPoolUtil.EnsureCapacity(ref array, i, pool); array[i++] = e.Current; } if (i == 0) { return Lookup.CreateEmpty(); } else { return await Lookup.CreateAsync(new ArraySegment(array, 0, i), keySelector, elementSelector, comparer); } } finally { pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); if (e != null) { await e.DisposeAsync(); } } } // with cancellation internal static async UniTask> ToLookupAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var pool = ArrayPool.Shared; var array = pool.Rent(16); IUniTaskAsyncEnumerator e = default; try { e = source.GetAsyncEnumerator(cancellationToken); var i = 0; while (await e.MoveNextAsync()) { ArrayPoolUtil.EnsureCapacity(ref array, i, pool); array[i++] = e.Current; } if (i == 0) { return Lookup.CreateEmpty(); } else { return await Lookup.CreateAsync(new ArraySegment(array, 0, i), keySelector, comparer, cancellationToken); } } finally { pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); if (e != null) { await e.DisposeAsync(); } } } internal static async UniTask> ToLookupAwaitWithCancellationAsync(IUniTaskAsyncEnumerable source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var pool = ArrayPool.Shared; var array = pool.Rent(16); IUniTaskAsyncEnumerator e = default; try { e = source.GetAsyncEnumerator(cancellationToken); var i = 0; while (await e.MoveNextAsync()) { ArrayPoolUtil.EnsureCapacity(ref array, i, pool); array[i++] = e.Current; } if (i == 0) { return Lookup.CreateEmpty(); } else { return await Lookup.CreateAsync(new ArraySegment(array, 0, i), keySelector, elementSelector, comparer, cancellationToken); } } finally { pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType()); if (e != null) { await e.DisposeAsync(); } } } // Lookup class Lookup : ILookup { static readonly Lookup empty = new Lookup(new Dictionary>()); // original lookup keeps order but this impl does not(dictionary not guarantee) readonly Dictionary> dict; Lookup(Dictionary> dict) { this.dict = dict; } public static Lookup CreateEmpty() { return empty; } public static Lookup Create(ArraySegment source, Func keySelector, IEqualityComparer comparer) { var dict = new Dictionary>(comparer); var arr = source.Array; var c = source.Count; for (int i = source.Offset; i < c; i++) { var key = keySelector(arr[i]); if (!dict.TryGetValue(key, out var list)) { list = new Grouping(key); dict[key] = list; } list.Add(arr[i]); } return new Lookup(dict); } public static Lookup Create(ArraySegment source, Func keySelector, Func elementSelector, IEqualityComparer comparer) { var dict = new Dictionary>(comparer); var arr = source.Array; var c = source.Count; for (int i = source.Offset; i < c; i++) { var key = keySelector(arr[i]); var elem = elementSelector(arr[i]); if (!dict.TryGetValue(key, out var list)) { list = new Grouping(key); dict[key] = list; } list.Add(elem); } return new Lookup(dict); } public static async UniTask> CreateAsync(ArraySegment source, Func> keySelector, IEqualityComparer comparer) { var dict = new Dictionary>(comparer); var arr = source.Array; var c = source.Count; for (int i = source.Offset; i < c; i++) { var key = await keySelector(arr[i]); if (!dict.TryGetValue(key, out var list)) { list = new Grouping(key); dict[key] = list; } list.Add(arr[i]); } return new Lookup(dict); } public static async UniTask> CreateAsync(ArraySegment source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer) { var dict = new Dictionary>(comparer); var arr = source.Array; var c = source.Count; for (int i = source.Offset; i < c; i++) { var key = await keySelector(arr[i]); var elem = await elementSelector(arr[i]); if (!dict.TryGetValue(key, out var list)) { list = new Grouping(key); dict[key] = list; } list.Add(elem); } return new Lookup(dict); } public static async UniTask> CreateAsync(ArraySegment source, Func> keySelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var dict = new Dictionary>(comparer); var arr = source.Array; var c = source.Count; for (int i = source.Offset; i < c; i++) { var key = await keySelector(arr[i], cancellationToken); if (!dict.TryGetValue(key, out var list)) { list = new Grouping(key); dict[key] = list; } list.Add(arr[i]); } return new Lookup(dict); } public static async UniTask> CreateAsync(ArraySegment source, Func> keySelector, Func> elementSelector, IEqualityComparer comparer, CancellationToken cancellationToken) { var dict = new Dictionary>(comparer); var arr = source.Array; var c = source.Count; for (int i = source.Offset; i < c; i++) { var key = await keySelector(arr[i], cancellationToken); var elem = await elementSelector(arr[i], cancellationToken); if (!dict.TryGetValue(key, out var list)) { list = new Grouping(key); dict[key] = list; } list.Add(elem); } return new Lookup(dict); } public IEnumerable this[TKey key] => dict.TryGetValue(key, out var g) ? g : Enumerable.Empty(); public int Count => dict.Count; public bool Contains(TKey key) { return dict.ContainsKey(key); } public IEnumerator> GetEnumerator() { return dict.Values.GetEnumerator(); } IEnumerator IEnumerable.GetEnumerator() { return dict.Values.GetEnumerator(); } } class Grouping : IGrouping // , IUniTaskAsyncGrouping { readonly List elements; public TKey Key { get; private set; } public Grouping(TKey key) { this.Key = key; this.elements = new List(); } public void Add(TElement value) { elements.Add(value); } public IEnumerator GetEnumerator() { return elements.GetEnumerator(); } IEnumerator IEnumerable.GetEnumerator() { return elements.GetEnumerator(); } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return this.ToUniTaskAsyncEnumerable().GetAsyncEnumerator(cancellationToken); } public override string ToString() { return "Key: " + Key + ", Count: " + elements.Count; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToLookup.cs.meta ================================================ fileFormatVersion: 2 guid: 57da22563bcd6ca4aaf256d941de5cb0 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToObservable.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IObservable ToObservable(this IUniTaskAsyncEnumerable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new ToObservable(source); } } internal sealed class ToObservable : IObservable { readonly IUniTaskAsyncEnumerable source; public ToObservable(IUniTaskAsyncEnumerable source) { this.source = source; } public IDisposable Subscribe(IObserver observer) { var ctd = new CancellationTokenDisposable(); RunAsync(source, observer, ctd.Token).Forget(); return ctd; } static async UniTaskVoid RunAsync(IUniTaskAsyncEnumerable src, IObserver observer, CancellationToken cancellationToken) { // cancellationToken.IsCancellationRequested is called when Rx's Disposed. // when disposed, finish silently. var e = src.GetAsyncEnumerator(cancellationToken); try { bool hasNext; do { try { hasNext = await e.MoveNextAsync(); } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) { return; } observer.OnError(ex); return; } if (hasNext) { observer.OnNext(e.Current); } else { observer.OnCompleted(); return; } } while (!cancellationToken.IsCancellationRequested); } finally { if (e != null) { await e.DisposeAsync(); } } } internal sealed class CancellationTokenDisposable : IDisposable { readonly CancellationTokenSource cts = new CancellationTokenSource(); public CancellationToken Token => cts.Token; public void Dispose() { if (!cts.IsCancellationRequested) { cts.Cancel(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToObservable.cs.meta ================================================ fileFormatVersion: 2 guid: b4f6f48a532188e4c80b7ebe69aea3a8 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToUniTaskAsyncEnumerable.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable ToUniTaskAsyncEnumerable(this IEnumerable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new ToUniTaskAsyncEnumerable(source); } public static IUniTaskAsyncEnumerable ToUniTaskAsyncEnumerable(this Task source) { Error.ThrowArgumentNullException(source, nameof(source)); return new ToUniTaskAsyncEnumerableTask(source); } public static IUniTaskAsyncEnumerable ToUniTaskAsyncEnumerable(this UniTask source) { return new ToUniTaskAsyncEnumerableUniTask(source); } public static IUniTaskAsyncEnumerable ToUniTaskAsyncEnumerable(this IObservable source) { Error.ThrowArgumentNullException(source, nameof(source)); return new ToUniTaskAsyncEnumerableObservable(source); } } internal class ToUniTaskAsyncEnumerable : IUniTaskAsyncEnumerable { readonly IEnumerable source; public ToUniTaskAsyncEnumerable(IEnumerable source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _ToUniTaskAsyncEnumerable(source, cancellationToken); } class _ToUniTaskAsyncEnumerable : IUniTaskAsyncEnumerator { readonly IEnumerable source; CancellationToken cancellationToken; IEnumerator enumerator; public _ToUniTaskAsyncEnumerable(IEnumerable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; } public T Current => enumerator.Current; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (enumerator == null) { enumerator = source.GetEnumerator(); } if (enumerator.MoveNext()) { return CompletedTasks.True; } return CompletedTasks.False; } public UniTask DisposeAsync() { enumerator.Dispose(); return default; } } } internal class ToUniTaskAsyncEnumerableTask : IUniTaskAsyncEnumerable { readonly Task source; public ToUniTaskAsyncEnumerableTask(Task source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _ToUniTaskAsyncEnumerableTask(source, cancellationToken); } class _ToUniTaskAsyncEnumerableTask : IUniTaskAsyncEnumerator { readonly Task source; CancellationToken cancellationToken; T current; bool called; public _ToUniTaskAsyncEnumerableTask(Task source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; this.called = false; } public T Current => current; public async UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (called) { return false; } called = true; current = await source; return true; } public UniTask DisposeAsync() { return default; } } } internal class ToUniTaskAsyncEnumerableUniTask : IUniTaskAsyncEnumerable { readonly UniTask source; public ToUniTaskAsyncEnumerableUniTask(UniTask source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _ToUniTaskAsyncEnumerableUniTask(source, cancellationToken); } class _ToUniTaskAsyncEnumerableUniTask : IUniTaskAsyncEnumerator { readonly UniTask source; CancellationToken cancellationToken; T current; bool called; public _ToUniTaskAsyncEnumerableUniTask(UniTask source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; this.called = false; } public T Current => current; public async UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (called) { return false; } called = true; current = await source; return true; } public UniTask DisposeAsync() { return default; } } } internal class ToUniTaskAsyncEnumerableObservable : IUniTaskAsyncEnumerable { readonly IObservable source; public ToUniTaskAsyncEnumerableObservable(IObservable source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _ToUniTaskAsyncEnumerableObservable(source, cancellationToken); } class _ToUniTaskAsyncEnumerableObservable : MoveNextSource, IUniTaskAsyncEnumerator, IObserver { static readonly Action OnCanceledDelegate = OnCanceled; readonly IObservable source; CancellationToken cancellationToken; bool useCachedCurrent; T current; bool subscribeCompleted; readonly Queue queuedResult; Exception error; IDisposable subscription; CancellationTokenRegistration cancellationTokenRegistration; public _ToUniTaskAsyncEnumerableObservable(IObservable source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; this.queuedResult = new Queue(); if (cancellationToken.CanBeCanceled) { cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(OnCanceledDelegate, this); } } public T Current { get { if (useCachedCurrent) { return current; } lock (queuedResult) { if (queuedResult.Count != 0) { current = queuedResult.Dequeue(); useCachedCurrent = true; return current; } else { return default; // undefined. } } } } public UniTask MoveNextAsync() { lock (queuedResult) { useCachedCurrent = false; if (cancellationToken.IsCancellationRequested) { return UniTask.FromCanceled(cancellationToken); } if (subscription == null) { subscription = source.Subscribe(this); } if (error != null) { return UniTask.FromException(error); } if (queuedResult.Count != 0) { return CompletedTasks.True; } if (subscribeCompleted) { return CompletedTasks.False; } completionSource.Reset(); return new UniTask(this, completionSource.Version); } } public UniTask DisposeAsync() { subscription.Dispose(); cancellationTokenRegistration.Dispose(); completionSource.Reset(); return default; } public void OnCompleted() { lock (queuedResult) { subscribeCompleted = true; completionSource.TrySetResult(false); } } public void OnError(Exception error) { lock (queuedResult) { this.error = error; completionSource.TrySetException(error); } } public void OnNext(T value) { lock (queuedResult) { queuedResult.Enqueue(value); completionSource.TrySetResult(true); // include callback execution, too long lock? } } static void OnCanceled(object state) { var self = (_ToUniTaskAsyncEnumerableObservable)state; lock (self.queuedResult) { self.completionSource.TrySetCanceled(self.cancellationToken); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/ToUniTaskAsyncEnumerable.cs.meta ================================================ fileFormatVersion: 2 guid: d7192de2a0581ec4db62962cc1404af5 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UniTask.Linq.asmdef ================================================ { "name": "UniTask.Linq", "references": [ "UniTask" ], "includePlatforms": [], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": false, "precompiledReferences": [], "autoReferenced": true, "defineConstraints": [], "versionDefines": [], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UniTask.Linq.asmdef.meta ================================================ fileFormatVersion: 2 guid: 5c01796d064528144a599661eaab93a6 AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Union.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System.Collections.Generic; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Union(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); return Union(first, second, EqualityComparer.Default); } public static IUniTaskAsyncEnumerable Union(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, IEqualityComparer comparer) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); Error.ThrowArgumentNullException(comparer, nameof(comparer)); // improv without combinate? return first.Concat(second).Distinct(comparer); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Union.cs.meta ================================================ fileFormatVersion: 2 guid: ae57a55bdeba98b4f8ff234d98d7dd76 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryUpdate.cs ================================================ using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable EveryUpdate(PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool cancelImmediately = false) { return new EveryUpdate(updateTiming, cancelImmediately); } } internal class EveryUpdate : IUniTaskAsyncEnumerable { readonly PlayerLoopTiming updateTiming; readonly bool cancelImmediately; public EveryUpdate(PlayerLoopTiming updateTiming, bool cancelImmediately) { this.updateTiming = updateTiming; this.cancelImmediately = cancelImmediately; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _EveryUpdate(updateTiming, cancellationToken, cancelImmediately); } class _EveryUpdate : MoveNextSource, IUniTaskAsyncEnumerator, IPlayerLoopItem { readonly PlayerLoopTiming updateTiming; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration cancellationTokenRegistration; bool disposed; public _EveryUpdate(PlayerLoopTiming updateTiming, CancellationToken cancellationToken, bool cancelImmediately) { this.updateTiming = updateTiming; this.cancellationToken = cancellationToken; if (cancelImmediately && cancellationToken.CanBeCanceled) { cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (_EveryUpdate)state; source.completionSource.TrySetCanceled(source.cancellationToken); }, this); } TaskTracker.TrackActiveTask(this, 2); PlayerLoopHelper.AddAction(updateTiming, this); } public AsyncUnit Current => default; public UniTask MoveNextAsync() { if (disposed) return CompletedTasks.False; completionSource.Reset(); if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); } return new UniTask(this, completionSource.Version); } public UniTask DisposeAsync() { if (!disposed) { cancellationTokenRegistration.Dispose(); disposed = true; TaskTracker.RemoveTracking(this); } return default; } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); return false; } if (disposed) { completionSource.TrySetResult(false); return false; } completionSource.TrySetResult(true); return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryUpdate.cs.meta ================================================ fileFormatVersion: 2 guid: 00520eb52e49b5b4e8d9870d6ff1aced MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable EveryValueChanged(TTarget target, Func propertySelector, PlayerLoopTiming monitorTiming = PlayerLoopTiming.Update, IEqualityComparer equalityComparer = null, bool cancelImmediately = false) where TTarget : class { var unityObject = target as UnityEngine.Object; var isUnityObject = target is UnityEngine.Object; // don't use (unityObject == null) if (isUnityObject) { return new EveryValueChangedUnityObject(target, propertySelector, equalityComparer ?? UnityEqualityComparer.GetDefault(), monitorTiming, cancelImmediately); } else { return new EveryValueChangedStandardObject(target, propertySelector, equalityComparer ?? UnityEqualityComparer.GetDefault(), monitorTiming, cancelImmediately); } } } internal sealed class EveryValueChangedUnityObject : IUniTaskAsyncEnumerable { readonly TTarget target; readonly Func propertySelector; readonly IEqualityComparer equalityComparer; readonly PlayerLoopTiming monitorTiming; readonly bool cancelImmediately; public EveryValueChangedUnityObject(TTarget target, Func propertySelector, IEqualityComparer equalityComparer, PlayerLoopTiming monitorTiming, bool cancelImmediately) { this.target = target; this.propertySelector = propertySelector; this.equalityComparer = equalityComparer; this.monitorTiming = monitorTiming; this.cancelImmediately = cancelImmediately; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _EveryValueChanged(target, propertySelector, equalityComparer, monitorTiming, cancellationToken, cancelImmediately); } sealed class _EveryValueChanged : MoveNextSource, IUniTaskAsyncEnumerator, IPlayerLoopItem { readonly TTarget target; readonly UnityEngine.Object targetAsUnityObject; readonly IEqualityComparer equalityComparer; readonly Func propertySelector; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration cancellationTokenRegistration; bool first; TProperty currentValue; bool disposed; public _EveryValueChanged(TTarget target, Func propertySelector, IEqualityComparer equalityComparer, PlayerLoopTiming monitorTiming, CancellationToken cancellationToken, bool cancelImmediately) { this.target = target; this.targetAsUnityObject = target as UnityEngine.Object; this.propertySelector = propertySelector; this.equalityComparer = equalityComparer; this.cancellationToken = cancellationToken; this.first = true; if (cancelImmediately && cancellationToken.CanBeCanceled) { cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (_EveryValueChanged)state; source.completionSource.TrySetCanceled(source.cancellationToken); }, this); } TaskTracker.TrackActiveTask(this, 2); PlayerLoopHelper.AddAction(monitorTiming, this); } public TProperty Current => currentValue; public UniTask MoveNextAsync() { if (disposed) return CompletedTasks.False; completionSource.Reset(); if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); return new UniTask(this, completionSource.Version); } if (first) { first = false; if (targetAsUnityObject == null) { return CompletedTasks.False; } this.currentValue = propertySelector(target); return CompletedTasks.True; } return new UniTask(this, completionSource.Version); } public UniTask DisposeAsync() { if (!disposed) { cancellationTokenRegistration.Dispose(); disposed = true; TaskTracker.RemoveTracking(this); } return default; } public bool MoveNext() { if (disposed || targetAsUnityObject == null) { completionSource.TrySetResult(false); DisposeAsync().Forget(); return false; } if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); return false; } TProperty nextValue = default(TProperty); try { nextValue = propertySelector(target); if (equalityComparer.Equals(currentValue, nextValue)) { return true; } } catch (Exception ex) { completionSource.TrySetException(ex); DisposeAsync().Forget(); return false; } currentValue = nextValue; completionSource.TrySetResult(true); return true; } } } internal sealed class EveryValueChangedStandardObject : IUniTaskAsyncEnumerable where TTarget : class { readonly WeakReference target; readonly Func propertySelector; readonly IEqualityComparer equalityComparer; readonly PlayerLoopTiming monitorTiming; readonly bool cancelImmediately; public EveryValueChangedStandardObject(TTarget target, Func propertySelector, IEqualityComparer equalityComparer, PlayerLoopTiming monitorTiming, bool cancelImmediately) { this.target = new WeakReference(target, false); this.propertySelector = propertySelector; this.equalityComparer = equalityComparer; this.monitorTiming = monitorTiming; this.cancelImmediately = cancelImmediately; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _EveryValueChanged(target, propertySelector, equalityComparer, monitorTiming, cancellationToken, cancelImmediately); } sealed class _EveryValueChanged : MoveNextSource, IUniTaskAsyncEnumerator, IPlayerLoopItem { readonly WeakReference target; readonly IEqualityComparer equalityComparer; readonly Func propertySelector; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration cancellationTokenRegistration; bool first; TProperty currentValue; bool disposed; public _EveryValueChanged(WeakReference target, Func propertySelector, IEqualityComparer equalityComparer, PlayerLoopTiming monitorTiming, CancellationToken cancellationToken, bool cancelImmediately) { this.target = target; this.propertySelector = propertySelector; this.equalityComparer = equalityComparer; this.cancellationToken = cancellationToken; this.first = true; if (cancelImmediately && cancellationToken.CanBeCanceled) { cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (_EveryValueChanged)state; source.completionSource.TrySetCanceled(source.cancellationToken); }, this); } TaskTracker.TrackActiveTask(this, 2); PlayerLoopHelper.AddAction(monitorTiming, this); } public TProperty Current => currentValue; public UniTask MoveNextAsync() { if (disposed) return CompletedTasks.False; completionSource.Reset(); if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); return new UniTask(this, completionSource.Version); } if (first) { first = false; if (!target.TryGetTarget(out var t)) { return CompletedTasks.False; } this.currentValue = propertySelector(t); return CompletedTasks.True; } return new UniTask(this, completionSource.Version); } public UniTask DisposeAsync() { if (!disposed) { cancellationTokenRegistration.Dispose(); disposed = true; TaskTracker.RemoveTracking(this); } return default; } public bool MoveNext() { if (disposed || !target.TryGetTarget(out var t)) { completionSource.TrySetResult(false); DisposeAsync().Forget(); return false; } if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); return false; } TProperty nextValue = default(TProperty); try { nextValue = propertySelector(t); if (equalityComparer.Equals(currentValue, nextValue)) { return true; } } catch (Exception ex) { completionSource.TrySetException(ex); DisposeAsync().Forget(); return false; } currentValue = nextValue; completionSource.TrySetResult(true); return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs.meta ================================================ fileFormatVersion: 2 guid: 1ec39f1c41c305344854782c935ad354 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/Timer.cs ================================================ using System; using System.Threading; using UnityEngine; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Timer(TimeSpan dueTime, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool ignoreTimeScale = false, bool cancelImmediately = false) { return new Timer(dueTime, null, updateTiming, ignoreTimeScale, cancelImmediately); } public static IUniTaskAsyncEnumerable Timer(TimeSpan dueTime, TimeSpan period, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool ignoreTimeScale = false, bool cancelImmediately = false) { return new Timer(dueTime, period, updateTiming, ignoreTimeScale, cancelImmediately); } public static IUniTaskAsyncEnumerable Interval(TimeSpan period, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool ignoreTimeScale = false, bool cancelImmediately = false) { return new Timer(period, period, updateTiming, ignoreTimeScale, cancelImmediately); } public static IUniTaskAsyncEnumerable TimerFrame(int dueTimeFrameCount, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool cancelImmediately = false) { if (dueTimeFrameCount < 0) { throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. dueTimeFrameCount:" + dueTimeFrameCount); } return new TimerFrame(dueTimeFrameCount, null, updateTiming, cancelImmediately); } public static IUniTaskAsyncEnumerable TimerFrame(int dueTimeFrameCount, int periodFrameCount, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool cancelImmediately = false) { if (dueTimeFrameCount < 0) { throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. dueTimeFrameCount:" + dueTimeFrameCount); } if (periodFrameCount < 0) { throw new ArgumentOutOfRangeException("Delay does not allow minus periodFrameCount. periodFrameCount:" + dueTimeFrameCount); } return new TimerFrame(dueTimeFrameCount, periodFrameCount, updateTiming, cancelImmediately); } public static IUniTaskAsyncEnumerable IntervalFrame(int intervalFrameCount, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool cancelImmediately = false) { if (intervalFrameCount < 0) { throw new ArgumentOutOfRangeException("Delay does not allow minus intervalFrameCount. intervalFrameCount:" + intervalFrameCount); } return new TimerFrame(intervalFrameCount, intervalFrameCount, updateTiming, cancelImmediately); } } internal class Timer : IUniTaskAsyncEnumerable { readonly PlayerLoopTiming updateTiming; readonly TimeSpan dueTime; readonly TimeSpan? period; readonly bool ignoreTimeScale; readonly bool cancelImmediately; public Timer(TimeSpan dueTime, TimeSpan? period, PlayerLoopTiming updateTiming, bool ignoreTimeScale, bool cancelImmediately) { this.updateTiming = updateTiming; this.dueTime = dueTime; this.period = period; this.ignoreTimeScale = ignoreTimeScale; this.cancelImmediately = cancelImmediately; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Timer(dueTime, period, updateTiming, ignoreTimeScale, cancellationToken, cancelImmediately); } class _Timer : MoveNextSource, IUniTaskAsyncEnumerator, IPlayerLoopItem { readonly float dueTime; readonly float? period; readonly PlayerLoopTiming updateTiming; readonly bool ignoreTimeScale; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration cancellationTokenRegistration; int initialFrame; float elapsed; bool dueTimePhase; bool completed; bool disposed; public _Timer(TimeSpan dueTime, TimeSpan? period, PlayerLoopTiming updateTiming, bool ignoreTimeScale, CancellationToken cancellationToken, bool cancelImmediately) { this.dueTime = (float)dueTime.TotalSeconds; this.period = (period == null) ? null : (float?)period.Value.TotalSeconds; if (this.dueTime <= 0) this.dueTime = 0; if (this.period != null) { if (this.period <= 0) this.period = 1; } this.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1; this.dueTimePhase = true; this.updateTiming = updateTiming; this.ignoreTimeScale = ignoreTimeScale; this.cancellationToken = cancellationToken; if (cancelImmediately && cancellationToken.CanBeCanceled) { cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (_Timer)state; source.completionSource.TrySetCanceled(source.cancellationToken); }, this); } TaskTracker.TrackActiveTask(this, 2); PlayerLoopHelper.AddAction(updateTiming, this); } public AsyncUnit Current => default; public UniTask MoveNextAsync() { // return false instead of throw if (disposed || completed) return CompletedTasks.False; // reset value here. this.elapsed = 0; completionSource.Reset(); if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); } return new UniTask(this, completionSource.Version); } public UniTask DisposeAsync() { if (!disposed) { cancellationTokenRegistration.Dispose(); disposed = true; TaskTracker.RemoveTracking(this); } return default; } public bool MoveNext() { if (disposed) { completionSource.TrySetResult(false); return false; } if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); return false; } if (dueTimePhase) { if (elapsed == 0) { // skip in initial frame. if (initialFrame == Time.frameCount) { return true; } } elapsed += (ignoreTimeScale) ? UnityEngine.Time.unscaledDeltaTime : UnityEngine.Time.deltaTime; if (elapsed >= dueTime) { dueTimePhase = false; completionSource.TrySetResult(true); } } else { if (period == null) { completed = true; completionSource.TrySetResult(false); return false; } elapsed += (ignoreTimeScale) ? UnityEngine.Time.unscaledDeltaTime : UnityEngine.Time.deltaTime; if (elapsed >= period) { completionSource.TrySetResult(true); } } return true; } } } internal class TimerFrame : IUniTaskAsyncEnumerable { readonly PlayerLoopTiming updateTiming; readonly int dueTimeFrameCount; readonly int? periodFrameCount; readonly bool cancelImmediately; public TimerFrame(int dueTimeFrameCount, int? periodFrameCount, PlayerLoopTiming updateTiming, bool cancelImmediately) { this.updateTiming = updateTiming; this.dueTimeFrameCount = dueTimeFrameCount; this.periodFrameCount = periodFrameCount; this.cancelImmediately = cancelImmediately; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _TimerFrame(dueTimeFrameCount, periodFrameCount, updateTiming, cancellationToken, cancelImmediately); } class _TimerFrame : MoveNextSource, IUniTaskAsyncEnumerator, IPlayerLoopItem { readonly int dueTimeFrameCount; readonly int? periodFrameCount; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration cancellationTokenRegistration; int initialFrame; int currentFrame; bool dueTimePhase; bool completed; bool disposed; public _TimerFrame(int dueTimeFrameCount, int? periodFrameCount, PlayerLoopTiming updateTiming, CancellationToken cancellationToken, bool cancelImmediately) { if (dueTimeFrameCount <= 0) dueTimeFrameCount = 0; if (periodFrameCount != null) { if (periodFrameCount <= 0) periodFrameCount = 1; } this.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1; this.dueTimePhase = true; this.dueTimeFrameCount = dueTimeFrameCount; this.periodFrameCount = periodFrameCount; this.cancellationToken = cancellationToken; if (cancelImmediately && cancellationToken.CanBeCanceled) { cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (_TimerFrame)state; source.completionSource.TrySetCanceled(source.cancellationToken); }, this); } TaskTracker.TrackActiveTask(this, 2); PlayerLoopHelper.AddAction(updateTiming, this); } public AsyncUnit Current => default; public UniTask MoveNextAsync() { if (disposed || completed) return CompletedTasks.False; if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); } // reset value here. this.currentFrame = 0; completionSource.Reset(); return new UniTask(this, completionSource.Version); } public UniTask DisposeAsync() { if (!disposed) { cancellationTokenRegistration.Dispose(); disposed = true; TaskTracker.RemoveTracking(this); } return default; } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { completionSource.TrySetCanceled(cancellationToken); return false; } if (disposed) { completionSource.TrySetResult(false); return false; } if (dueTimePhase) { if (currentFrame == 0) { if (dueTimeFrameCount == 0) { dueTimePhase = false; completionSource.TrySetResult(true); return true; } // skip in initial frame. if (initialFrame == Time.frameCount) { return true; } } if (++currentFrame >= dueTimeFrameCount) { dueTimePhase = false; completionSource.TrySetResult(true); } else { } } else { if (periodFrameCount == null) { completed = true; completionSource.TrySetResult(false); return false; } if (++currentFrame >= periodFrameCount) { completionSource.TrySetResult(true); } } return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions/Timer.cs.meta ================================================ fileFormatVersion: 2 guid: 382caacde439855418709c641e4d7b04 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/UnityExtensions.meta ================================================ fileFormatVersion: 2 guid: 669f5459819f7284ca1b35f4d55fe226 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Where.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable Where(this IUniTaskAsyncEnumerable source, Func predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new Where(source, predicate); } public static IUniTaskAsyncEnumerable Where(this IUniTaskAsyncEnumerable source, Func predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new WhereInt(source, predicate); } public static IUniTaskAsyncEnumerable WhereAwait(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new WhereAwait(source, predicate); } public static IUniTaskAsyncEnumerable WhereAwait(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new WhereIntAwait(source, predicate); } public static IUniTaskAsyncEnumerable WhereAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new WhereAwaitWithCancellation(source, predicate); } public static IUniTaskAsyncEnumerable WhereAwaitWithCancellation(this IUniTaskAsyncEnumerable source, Func> predicate) { Error.ThrowArgumentNullException(source, nameof(source)); Error.ThrowArgumentNullException(predicate, nameof(predicate)); return new WhereIntAwaitWithCancellation(source, predicate); } } internal sealed class Where : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func predicate; public Where(IUniTaskAsyncEnumerable source, Func predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Where(source, predicate, cancellationToken); } sealed class _Where : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func predicate; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; Action moveNextAction; public _Where(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) { this.source = source; this.predicate = predicate; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { Current = enumerator.Current; if (predicate(Current)) { goto CONTINUE; } else { state = 0; goto REPEAT; } } else { goto DONE; } default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class WhereInt : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func predicate; public WhereInt(IUniTaskAsyncEnumerable source, Func predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Where(source, predicate, cancellationToken); } sealed class _Where : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func predicate; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; Action moveNextAction; int index; public _Where(IUniTaskAsyncEnumerable source, Func predicate, CancellationToken cancellationToken) { this.source = source; this.predicate = predicate; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { Current = enumerator.Current; if (predicate(Current, checked(index++))) { goto CONTINUE; } else { state = 0; goto REPEAT; } } else { goto DONE; } default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class WhereAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public WhereAwait(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _WhereAwait(source, predicate, cancellationToken); } sealed class _WhereAwait : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; public _WhereAwait(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { this.source = source; this.predicate = predicate; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { Current = enumerator.Current; awaiter2 = predicate(Current).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: if (awaiter2.GetResult()) { goto CONTINUE; } else { state = 0; goto REPEAT; } default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class WhereIntAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public WhereIntAwait(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _WhereAwait(source, predicate, cancellationToken); } sealed class _WhereAwait : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; int index; public _WhereAwait(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { this.source = source; this.predicate = predicate; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { Current = enumerator.Current; awaiter2 = predicate(Current, checked(index++)).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: if (awaiter2.GetResult()) { goto CONTINUE; } else { state = 0; goto REPEAT; } default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class WhereAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public WhereAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _WhereAwaitWithCancellation(source, predicate, cancellationToken); } sealed class _WhereAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; public _WhereAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { this.source = source; this.predicate = predicate; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { Current = enumerator.Current; awaiter2 = predicate(Current, cancellationToken).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: if (awaiter2.GetResult()) { goto CONTINUE; } else { state = 0; goto REPEAT; } default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } internal sealed class WhereIntAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; public WhereIntAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate) { this.source = source; this.predicate = predicate; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _WhereAwaitWithCancellation(source, predicate, cancellationToken); } sealed class _WhereAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { readonly IUniTaskAsyncEnumerable source; readonly Func> predicate; readonly CancellationToken cancellationToken; int state = -1; IUniTaskAsyncEnumerator enumerator; UniTask.Awaiter awaiter; UniTask.Awaiter awaiter2; Action moveNextAction; int index; public _WhereAwaitWithCancellation(IUniTaskAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken) { this.source = source; this.predicate = predicate; this.cancellationToken = cancellationToken; this.moveNextAction = MoveNext; TaskTracker.TrackActiveTask(this, 3); } public TSource Current { get; private set; } public UniTask MoveNextAsync() { if (state == -2) return default; completionSource.Reset(); MoveNext(); return new UniTask(this, completionSource.Version); } void MoveNext() { REPEAT: try { switch (state) { case -1: // init enumerator = source.GetAsyncEnumerator(cancellationToken); goto case 0; case 0: awaiter = enumerator.MoveNextAsync().GetAwaiter(); if (awaiter.IsCompleted) { goto case 1; } else { state = 1; awaiter.UnsafeOnCompleted(moveNextAction); return; } case 1: if (awaiter.GetResult()) { Current = enumerator.Current; awaiter2 = predicate(Current, checked(index++), cancellationToken).GetAwaiter(); if (awaiter2.IsCompleted) { goto case 2; } else { state = 2; awaiter2.UnsafeOnCompleted(moveNextAction); return; } } else { goto DONE; } case 2: if (awaiter2.GetResult()) { goto CONTINUE; } else { state = 0; goto REPEAT; } default: goto DONE; } } catch (Exception ex) { state = -2; completionSource.TrySetException(ex); return; } DONE: state = -2; completionSource.TrySetResult(false); return; CONTINUE: state = 0; completionSource.TrySetResult(true); return; } public UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); return enumerator.DisposeAsync(); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Where.cs.meta ================================================ fileFormatVersion: 2 guid: d882a3238d9535e4e8ce1ad3291eb7fb MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Zip.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; namespace Cysharp.Threading.Tasks.Linq { public static partial class UniTaskAsyncEnumerable { public static IUniTaskAsyncEnumerable<(TFirst First, TSecond Second)> Zip(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); return Zip(first, second, (x, y) => (x, y)); } public static IUniTaskAsyncEnumerable Zip(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func resultSelector) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); Error.ThrowArgumentNullException(resultSelector, nameof(resultSelector)); return new Zip(first, second, resultSelector); } public static IUniTaskAsyncEnumerable ZipAwait(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func> selector) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new ZipAwait(first, second, selector); } public static IUniTaskAsyncEnumerable ZipAwaitWithCancellation(this IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func> selector) { Error.ThrowArgumentNullException(first, nameof(first)); Error.ThrowArgumentNullException(second, nameof(second)); Error.ThrowArgumentNullException(selector, nameof(selector)); return new ZipAwaitWithCancellation(first, second, selector); } } internal sealed class Zip : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; readonly Func resultSelector; public Zip(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func resultSelector) { this.first = first; this.second = second; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _Zip(first, second, resultSelector, cancellationToken); } sealed class _Zip : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action firstMoveNextCoreDelegate = FirstMoveNextCore; static readonly Action secondMoveNextCoreDelegate = SecondMoveNextCore; readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; readonly Func resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator firstEnumerator; IUniTaskAsyncEnumerator secondEnumerator; UniTask.Awaiter firstAwaiter; UniTask.Awaiter secondAwaiter; public _Zip(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func resultSelector, CancellationToken cancellationToken) { this.first = first; this.second = second; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { completionSource.Reset(); if (firstEnumerator == null) { firstEnumerator = first.GetAsyncEnumerator(cancellationToken); secondEnumerator = second.GetAsyncEnumerator(cancellationToken); } firstAwaiter = firstEnumerator.MoveNextAsync().GetAwaiter(); if (firstAwaiter.IsCompleted) { FirstMoveNextCore(this); } else { firstAwaiter.SourceOnCompleted(firstMoveNextCoreDelegate, this); } return new UniTask(this, completionSource.Version); } static void FirstMoveNextCore(object state) { var self = (_Zip)state; if (self.TryGetResult(self.firstAwaiter, out var result)) { if (result) { try { self.secondAwaiter = self.secondEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } if (self.secondAwaiter.IsCompleted) { SecondMoveNextCore(self); } else { self.secondAwaiter.SourceOnCompleted(secondMoveNextCoreDelegate, self); } } else { self.completionSource.TrySetResult(false); } } } static void SecondMoveNextCore(object state) { var self = (_Zip)state; if (self.TryGetResult(self.secondAwaiter, out var result)) { if (result) { try { self.Current = self.resultSelector(self.firstEnumerator.Current, self.secondEnumerator.Current); } catch (Exception ex) { self.completionSource.TrySetException(ex); } if (self.cancellationToken.IsCancellationRequested) { self.completionSource.TrySetCanceled(self.cancellationToken); } else { self.completionSource.TrySetResult(true); } } else { self.completionSource.TrySetResult(false); } } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (firstEnumerator != null) { await firstEnumerator.DisposeAsync(); } if (secondEnumerator != null) { await secondEnumerator.DisposeAsync(); } } } } internal sealed class ZipAwait : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; readonly Func> resultSelector; public ZipAwait(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func> resultSelector) { this.first = first; this.second = second; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _ZipAwait(first, second, resultSelector, cancellationToken); } sealed class _ZipAwait : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action firstMoveNextCoreDelegate = FirstMoveNextCore; static readonly Action secondMoveNextCoreDelegate = SecondMoveNextCore; static readonly Action resultAwaitCoreDelegate = ResultAwaitCore; readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; readonly Func> resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator firstEnumerator; IUniTaskAsyncEnumerator secondEnumerator; UniTask.Awaiter firstAwaiter; UniTask.Awaiter secondAwaiter; UniTask.Awaiter resultAwaiter; public _ZipAwait(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func> resultSelector, CancellationToken cancellationToken) { this.first = first; this.second = second; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { completionSource.Reset(); if (firstEnumerator == null) { firstEnumerator = first.GetAsyncEnumerator(cancellationToken); secondEnumerator = second.GetAsyncEnumerator(cancellationToken); } firstAwaiter = firstEnumerator.MoveNextAsync().GetAwaiter(); if (firstAwaiter.IsCompleted) { FirstMoveNextCore(this); } else { firstAwaiter.SourceOnCompleted(firstMoveNextCoreDelegate, this); } return new UniTask(this, completionSource.Version); } static void FirstMoveNextCore(object state) { var self = (_ZipAwait)state; if (self.TryGetResult(self.firstAwaiter, out var result)) { if (result) { try { self.secondAwaiter = self.secondEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } if (self.secondAwaiter.IsCompleted) { SecondMoveNextCore(self); } else { self.secondAwaiter.SourceOnCompleted(secondMoveNextCoreDelegate, self); } } else { self.completionSource.TrySetResult(false); } } } static void SecondMoveNextCore(object state) { var self = (_ZipAwait)state; if (self.TryGetResult(self.secondAwaiter, out var result)) { if (result) { try { self.resultAwaiter = self.resultSelector(self.firstEnumerator.Current, self.secondEnumerator.Current).GetAwaiter(); if (self.resultAwaiter.IsCompleted) { ResultAwaitCore(self); } else { self.resultAwaiter.SourceOnCompleted(resultAwaitCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); } } else { self.completionSource.TrySetResult(false); } } } static void ResultAwaitCore(object state) { var self = (_ZipAwait)state; if (self.TryGetResult(self.resultAwaiter, out var result)) { self.Current = result; if (self.cancellationToken.IsCancellationRequested) { self.completionSource.TrySetCanceled(self.cancellationToken); } else { self.completionSource.TrySetResult(true); } } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (firstEnumerator != null) { await firstEnumerator.DisposeAsync(); } if (secondEnumerator != null) { await secondEnumerator.DisposeAsync(); } } } } internal sealed class ZipAwaitWithCancellation : IUniTaskAsyncEnumerable { readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; readonly Func> resultSelector; public ZipAwaitWithCancellation(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func> resultSelector) { this.first = first; this.second = second; this.resultSelector = resultSelector; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new _ZipAwaitWithCancellation(first, second, resultSelector, cancellationToken); } sealed class _ZipAwaitWithCancellation : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action firstMoveNextCoreDelegate = FirstMoveNextCore; static readonly Action secondMoveNextCoreDelegate = SecondMoveNextCore; static readonly Action resultAwaitCoreDelegate = ResultAwaitCore; readonly IUniTaskAsyncEnumerable first; readonly IUniTaskAsyncEnumerable second; readonly Func> resultSelector; CancellationToken cancellationToken; IUniTaskAsyncEnumerator firstEnumerator; IUniTaskAsyncEnumerator secondEnumerator; UniTask.Awaiter firstAwaiter; UniTask.Awaiter secondAwaiter; UniTask.Awaiter resultAwaiter; public _ZipAwaitWithCancellation(IUniTaskAsyncEnumerable first, IUniTaskAsyncEnumerable second, Func> resultSelector, CancellationToken cancellationToken) { this.first = first; this.second = second; this.resultSelector = resultSelector; this.cancellationToken = cancellationToken; TaskTracker.TrackActiveTask(this, 3); } public TResult Current { get; private set; } public UniTask MoveNextAsync() { completionSource.Reset(); if (firstEnumerator == null) { firstEnumerator = first.GetAsyncEnumerator(cancellationToken); secondEnumerator = second.GetAsyncEnumerator(cancellationToken); } firstAwaiter = firstEnumerator.MoveNextAsync().GetAwaiter(); if (firstAwaiter.IsCompleted) { FirstMoveNextCore(this); } else { firstAwaiter.SourceOnCompleted(firstMoveNextCoreDelegate, this); } return new UniTask(this, completionSource.Version); } static void FirstMoveNextCore(object state) { var self = (_ZipAwaitWithCancellation)state; if (self.TryGetResult(self.firstAwaiter, out var result)) { if (result) { try { self.secondAwaiter = self.secondEnumerator.MoveNextAsync().GetAwaiter(); } catch (Exception ex) { self.completionSource.TrySetException(ex); return; } if (self.secondAwaiter.IsCompleted) { SecondMoveNextCore(self); } else { self.secondAwaiter.SourceOnCompleted(secondMoveNextCoreDelegate, self); } } else { self.completionSource.TrySetResult(false); } } } static void SecondMoveNextCore(object state) { var self = (_ZipAwaitWithCancellation)state; if (self.TryGetResult(self.secondAwaiter, out var result)) { if (result) { try { self.resultAwaiter = self.resultSelector(self.firstEnumerator.Current, self.secondEnumerator.Current, self.cancellationToken).GetAwaiter(); if (self.resultAwaiter.IsCompleted) { ResultAwaitCore(self); } else { self.resultAwaiter.SourceOnCompleted(resultAwaitCoreDelegate, self); } } catch (Exception ex) { self.completionSource.TrySetException(ex); } } else { self.completionSource.TrySetResult(false); } } } static void ResultAwaitCore(object state) { var self = (_ZipAwaitWithCancellation)state; if (self.TryGetResult(self.resultAwaiter, out var result)) { self.Current = result; if (self.cancellationToken.IsCancellationRequested) { self.completionSource.TrySetCanceled(self.cancellationToken); } else { self.completionSource.TrySetResult(true); } } } public async UniTask DisposeAsync() { TaskTracker.RemoveTracking(this); if (firstEnumerator != null) { await firstEnumerator.DisposeAsync(); } if (secondEnumerator != null) { await secondEnumerator.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/Zip.cs.meta ================================================ fileFormatVersion: 2 guid: acc1acff153e347418f0f30b1c535994 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Linq.meta ================================================ fileFormatVersion: 2 guid: 4cc94a232b1c1154b8084bdda29c3484 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/MoveNextSource.cs ================================================ using System; namespace Cysharp.Threading.Tasks { public abstract class MoveNextSource : IUniTaskSource { protected UniTaskCompletionSourceCore completionSource; public bool GetResult(short token) { return completionSource.GetResult(token); } public UniTaskStatus GetStatus(short token) { return completionSource.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { completionSource.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return completionSource.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { completionSource.GetResult(token); } protected bool TryGetResult(UniTask.Awaiter awaiter, out T result) { try { result = awaiter.GetResult(); return true; } catch (Exception ex) { completionSource.TrySetException(ex); result = default; return false; } } protected bool TryGetResult(UniTask.Awaiter awaiter) { try { awaiter.GetResult(); return true; } catch (Exception ex) { completionSource.TrySetException(ex); return false; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/MoveNextSource.cs.meta ================================================ fileFormatVersion: 2 guid: dc4c5dc2a5f246e4f8df44cab735826c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Linq; using UnityEngine; using Cysharp.Threading.Tasks.Internal; using System.Threading; #if UNITY_2019_3_OR_NEWER using UnityEngine.LowLevel; using PlayerLoopType = UnityEngine.PlayerLoop; #else using UnityEngine.Experimental.LowLevel; using PlayerLoopType = UnityEngine.Experimental.PlayerLoop; #endif #if UNITY_EDITOR using UnityEditor; #endif namespace Cysharp.Threading.Tasks { public static class UniTaskLoopRunners { public struct UniTaskLoopRunnerInitialization { }; public struct UniTaskLoopRunnerEarlyUpdate { }; public struct UniTaskLoopRunnerFixedUpdate { }; public struct UniTaskLoopRunnerPreUpdate { }; public struct UniTaskLoopRunnerUpdate { }; public struct UniTaskLoopRunnerPreLateUpdate { }; public struct UniTaskLoopRunnerPostLateUpdate { }; // Last public struct UniTaskLoopRunnerLastInitialization { }; public struct UniTaskLoopRunnerLastEarlyUpdate { }; public struct UniTaskLoopRunnerLastFixedUpdate { }; public struct UniTaskLoopRunnerLastPreUpdate { }; public struct UniTaskLoopRunnerLastUpdate { }; public struct UniTaskLoopRunnerLastPreLateUpdate { }; public struct UniTaskLoopRunnerLastPostLateUpdate { }; // Yield public struct UniTaskLoopRunnerYieldInitialization { }; public struct UniTaskLoopRunnerYieldEarlyUpdate { }; public struct UniTaskLoopRunnerYieldFixedUpdate { }; public struct UniTaskLoopRunnerYieldPreUpdate { }; public struct UniTaskLoopRunnerYieldUpdate { }; public struct UniTaskLoopRunnerYieldPreLateUpdate { }; public struct UniTaskLoopRunnerYieldPostLateUpdate { }; // Yield Last public struct UniTaskLoopRunnerLastYieldInitialization { }; public struct UniTaskLoopRunnerLastYieldEarlyUpdate { }; public struct UniTaskLoopRunnerLastYieldFixedUpdate { }; public struct UniTaskLoopRunnerLastYieldPreUpdate { }; public struct UniTaskLoopRunnerLastYieldUpdate { }; public struct UniTaskLoopRunnerLastYieldPreLateUpdate { }; public struct UniTaskLoopRunnerLastYieldPostLateUpdate { }; #if UNITY_2020_2_OR_NEWER public struct UniTaskLoopRunnerTimeUpdate { }; public struct UniTaskLoopRunnerLastTimeUpdate { }; public struct UniTaskLoopRunnerYieldTimeUpdate { }; public struct UniTaskLoopRunnerLastYieldTimeUpdate { }; #endif } public enum PlayerLoopTiming { Initialization = 0, LastInitialization = 1, EarlyUpdate = 2, LastEarlyUpdate = 3, FixedUpdate = 4, LastFixedUpdate = 5, PreUpdate = 6, LastPreUpdate = 7, Update = 8, LastUpdate = 9, PreLateUpdate = 10, LastPreLateUpdate = 11, PostLateUpdate = 12, LastPostLateUpdate = 13, #if UNITY_2020_2_OR_NEWER // Unity 2020.2 added TimeUpdate https://docs.unity3d.com/2020.2/Documentation/ScriptReference/PlayerLoop.TimeUpdate.html TimeUpdate = 14, LastTimeUpdate = 15, #endif } [Flags] public enum InjectPlayerLoopTimings { /// /// Preset: All loops(default). /// All = Initialization | LastInitialization | EarlyUpdate | LastEarlyUpdate | FixedUpdate | LastFixedUpdate | PreUpdate | LastPreUpdate | Update | LastUpdate | PreLateUpdate | LastPreLateUpdate | PostLateUpdate | LastPostLateUpdate #if UNITY_2020_2_OR_NEWER | TimeUpdate | LastTimeUpdate, #else , #endif /// /// Preset: All without last except LastPostLateUpdate. /// Standard = Initialization | EarlyUpdate | FixedUpdate | PreUpdate | Update | PreLateUpdate | PostLateUpdate | LastPostLateUpdate #if UNITY_2020_2_OR_NEWER | TimeUpdate #endif , /// /// Preset: Minimum pattern, Update | FixedUpdate | LastPostLateUpdate /// Minimum = Update | FixedUpdate | LastPostLateUpdate, // PlayerLoopTiming Initialization = 1, LastInitialization = 2, EarlyUpdate = 4, LastEarlyUpdate = 8, FixedUpdate = 16, LastFixedUpdate = 32, PreUpdate = 64, LastPreUpdate = 128, Update = 256, LastUpdate = 512, PreLateUpdate = 1024, LastPreLateUpdate = 2048, PostLateUpdate = 4096, LastPostLateUpdate = 8192 #if UNITY_2020_2_OR_NEWER , // Unity 2020.2 added TimeUpdate https://docs.unity3d.com/2020.2/Documentation/ScriptReference/PlayerLoop.TimeUpdate.html TimeUpdate = 16384, LastTimeUpdate = 32768 #endif } public interface IPlayerLoopItem { bool MoveNext(); } public static class PlayerLoopHelper { static readonly ContinuationQueue ThrowMarkerContinuationQueue = new ContinuationQueue(PlayerLoopTiming.Initialization); static readonly PlayerLoopRunner ThrowMarkerPlayerLoopRunner = new PlayerLoopRunner(PlayerLoopTiming.Initialization); public static SynchronizationContext UnitySynchronizationContext => unitySynchronizationContext; public static int MainThreadId => mainThreadId; internal static string ApplicationDataPath => applicationDataPath; public static bool IsMainThread => Thread.CurrentThread.ManagedThreadId == mainThreadId; static int mainThreadId; static string applicationDataPath; static SynchronizationContext unitySynchronizationContext; static ContinuationQueue[] yielders; static PlayerLoopRunner[] runners; internal static bool IsEditorApplicationQuitting { get; private set; } static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem, bool injectOnFirst, Type loopRunnerYieldType, ContinuationQueue cq, Type loopRunnerType, PlayerLoopRunner runner) { #if UNITY_EDITOR EditorApplication.playModeStateChanged += (state) => { if (state == PlayModeStateChange.EnteredEditMode || state == PlayModeStateChange.ExitingEditMode) { IsEditorApplicationQuitting = true; // run rest action before clear. if (runner != null) { runner.Run(); runner.Clear(); } if (cq != null) { cq.Run(); cq.Clear(); } IsEditorApplicationQuitting = false; } }; #endif var yieldLoop = new PlayerLoopSystem { type = loopRunnerYieldType, updateDelegate = cq.Run }; var runnerLoop = new PlayerLoopSystem { type = loopRunnerType, updateDelegate = runner.Run }; // Remove items from previous initializations. var source = RemoveRunner(loopSystem, loopRunnerYieldType, loopRunnerType); var dest = new PlayerLoopSystem[source.Length + 2]; Array.Copy(source, 0, dest, injectOnFirst ? 2 : 0, source.Length); if (injectOnFirst) { dest[0] = yieldLoop; dest[1] = runnerLoop; } else { dest[dest.Length - 2] = yieldLoop; dest[dest.Length - 1] = runnerLoop; } return dest; } static PlayerLoopSystem[] RemoveRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType, Type loopRunnerType) { return loopSystem.subSystemList .Where(ls => ls.type != loopRunnerYieldType && ls.type != loopRunnerType) .ToArray(); } static PlayerLoopSystem[] InsertUniTaskSynchronizationContext(PlayerLoopSystem loopSystem) { var loop = new PlayerLoopSystem { type = typeof(UniTaskSynchronizationContext), updateDelegate = UniTaskSynchronizationContext.Run }; // Remove items from previous initializations. var source = loopSystem.subSystemList .Where(ls => ls.type != typeof(UniTaskSynchronizationContext)) .ToArray(); var dest = new System.Collections.Generic.List(source); var index = dest.FindIndex(x => x.type.Name == "ScriptRunDelayedTasks"); if (index == -1) { index = dest.FindIndex(x => x.type.Name == "UniTaskLoopRunnerUpdate"); } dest.Insert(index + 1, loop); return dest.ToArray(); } #if UNITY_2020_1_OR_NEWER [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)] #else [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)] #endif static void Init() { // capture default(unity) sync-context. unitySynchronizationContext = SynchronizationContext.Current; mainThreadId = Thread.CurrentThread.ManagedThreadId; try { applicationDataPath = Application.dataPath; } catch { } #if UNITY_EDITOR && UNITY_2019_3_OR_NEWER // When domain reload is disabled, re-initialization is required when entering play mode; // otherwise, pending tasks will leak between play mode sessions. var domainReloadDisabled = UnityEditor.EditorSettings.enterPlayModeOptionsEnabled && UnityEditor.EditorSettings.enterPlayModeOptions.HasFlag(UnityEditor.EnterPlayModeOptions.DisableDomainReload); if (!domainReloadDisabled && runners != null) return; #else if (runners != null) return; // already initialized #endif var playerLoop = #if UNITY_2019_3_OR_NEWER PlayerLoop.GetCurrentPlayerLoop(); #else PlayerLoop.GetDefaultPlayerLoop(); #endif Initialize(ref playerLoop); } #if UNITY_EDITOR [InitializeOnLoadMethod] static void InitOnEditor() { // Execute the play mode init method Init(); // register an Editor update delegate, used to forcing playerLoop update EditorApplication.update += ForceEditorPlayerLoopUpdate; } private static void ForceEditorPlayerLoopUpdate() { if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating) { // Not in Edit mode, don't interfere return; } // EditorApplication.QueuePlayerLoopUpdate causes performance issue, don't call directly. // EditorApplication.QueuePlayerLoopUpdate(); if (yielders != null) { foreach (var item in yielders) { if (item != null) item.Run(); } } if (runners != null) { foreach (var item in runners) { if (item != null) item.Run(); } } UniTaskSynchronizationContext.Run(); } #endif private static int FindLoopSystemIndex(PlayerLoopSystem[] playerLoopList, Type systemType) { for (int i = 0; i < playerLoopList.Length; i++) { if (playerLoopList[i].type == systemType) { return i; } } throw new Exception("Target PlayerLoopSystem does not found. Type:" + systemType.FullName); } static void InsertLoop(PlayerLoopSystem[] copyList, InjectPlayerLoopTimings injectTimings, Type loopType, InjectPlayerLoopTimings targetTimings, int index, bool injectOnFirst, Type loopRunnerYieldType, Type loopRunnerType, PlayerLoopTiming playerLoopTiming) { var i = FindLoopSystemIndex(copyList, loopType); if ((injectTimings & targetTimings) == targetTimings) { copyList[i].subSystemList = InsertRunner(copyList[i], injectOnFirst, loopRunnerYieldType, yielders[index] = new ContinuationQueue(playerLoopTiming), loopRunnerType, runners[index] = new PlayerLoopRunner(playerLoopTiming)); } else { copyList[i].subSystemList = RemoveRunner(copyList[i], loopRunnerYieldType, loopRunnerType); } } public static void Initialize(ref PlayerLoopSystem playerLoop, InjectPlayerLoopTimings injectTimings = InjectPlayerLoopTimings.All) { #if UNITY_2020_2_OR_NEWER yielders = new ContinuationQueue[16]; runners = new PlayerLoopRunner[16]; #else yielders = new ContinuationQueue[14]; runners = new PlayerLoopRunner[14]; #endif var copyList = playerLoop.subSystemList.ToArray(); // Initialization InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.Initialization), InjectPlayerLoopTimings.Initialization, 0, true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), PlayerLoopTiming.Initialization); InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.Initialization), InjectPlayerLoopTimings.LastInitialization, 1, false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldInitialization), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastInitialization), PlayerLoopTiming.LastInitialization); // EarlyUpdate InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.EarlyUpdate), InjectPlayerLoopTimings.EarlyUpdate, 2, true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), PlayerLoopTiming.EarlyUpdate); InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.EarlyUpdate), InjectPlayerLoopTimings.LastEarlyUpdate, 3, false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldEarlyUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastEarlyUpdate), PlayerLoopTiming.LastEarlyUpdate); // FixedUpdate InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.FixedUpdate), InjectPlayerLoopTimings.FixedUpdate, 4, true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), PlayerLoopTiming.FixedUpdate); InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.FixedUpdate), InjectPlayerLoopTimings.LastFixedUpdate, 5, false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldFixedUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastFixedUpdate), PlayerLoopTiming.LastFixedUpdate); // PreUpdate InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PreUpdate), InjectPlayerLoopTimings.PreUpdate, 6, true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), PlayerLoopTiming.PreUpdate); InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PreUpdate), InjectPlayerLoopTimings.LastPreUpdate, 7, false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreUpdate), PlayerLoopTiming.LastPreUpdate); // Update InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.Update), InjectPlayerLoopTimings.Update, 8, true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), PlayerLoopTiming.Update); InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.Update), InjectPlayerLoopTimings.LastUpdate, 9, false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastUpdate), PlayerLoopTiming.LastUpdate); // PreLateUpdate InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PreLateUpdate), InjectPlayerLoopTimings.PreLateUpdate, 10, true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), PlayerLoopTiming.PreLateUpdate); InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PreLateUpdate), InjectPlayerLoopTimings.LastPreLateUpdate, 11, false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreLateUpdate), PlayerLoopTiming.LastPreLateUpdate); // PostLateUpdate InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PostLateUpdate), InjectPlayerLoopTimings.PostLateUpdate, 12, true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), PlayerLoopTiming.PostLateUpdate); InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.PostLateUpdate), InjectPlayerLoopTimings.LastPostLateUpdate, 13, false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPostLateUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPostLateUpdate), PlayerLoopTiming.LastPostLateUpdate); #if UNITY_2020_2_OR_NEWER // TimeUpdate InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.TimeUpdate), InjectPlayerLoopTimings.TimeUpdate, 14, true, typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldTimeUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerTimeUpdate), PlayerLoopTiming.TimeUpdate); InsertLoop(copyList, injectTimings, typeof(PlayerLoopType.TimeUpdate), InjectPlayerLoopTimings.LastTimeUpdate, 15, false, typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldTimeUpdate), typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastTimeUpdate), PlayerLoopTiming.LastTimeUpdate); #endif // Insert UniTaskSynchronizationContext to Update loop var i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.Update)); copyList[i].subSystemList = InsertUniTaskSynchronizationContext(copyList[i]); playerLoop.subSystemList = copyList; PlayerLoop.SetPlayerLoop(playerLoop); } public static void AddAction(PlayerLoopTiming timing, IPlayerLoopItem action) { var runner = runners[(int)timing]; if (runner == null) { ThrowInvalidLoopTiming(timing); } runner.AddAction(action); } static void ThrowInvalidLoopTiming(PlayerLoopTiming playerLoopTiming) { throw new InvalidOperationException("Target playerLoopTiming is not injected. Please check PlayerLoopHelper.Initialize. PlayerLoopTiming:" + playerLoopTiming); } public static void AddContinuation(PlayerLoopTiming timing, Action continuation) { var q = yielders[(int)timing]; if (q == null) { ThrowInvalidLoopTiming(timing); } q.Enqueue(continuation); } // Diagnostics helper #if UNITY_2019_3_OR_NEWER public static void DumpCurrentPlayerLoop() { var playerLoop = UnityEngine.LowLevel.PlayerLoop.GetCurrentPlayerLoop(); var sb = new System.Text.StringBuilder(); sb.AppendLine($"PlayerLoop List"); foreach (var header in playerLoop.subSystemList) { sb.AppendFormat("------{0}------", header.type.Name); sb.AppendLine(); if (header.subSystemList is null) { sb.AppendFormat("{0} has no subsystems!", header.ToString()); sb.AppendLine(); continue; } foreach (var subSystem in header.subSystemList) { sb.AppendFormat("{0}", subSystem.type.Name); sb.AppendLine(); if (subSystem.subSystemList != null) { UnityEngine.Debug.LogWarning("More Subsystem:" + subSystem.subSystemList.Length); } } } UnityEngine.Debug.Log(sb.ToString()); } public static bool IsInjectedUniTaskPlayerLoop() { var playerLoop = UnityEngine.LowLevel.PlayerLoop.GetCurrentPlayerLoop(); foreach (var header in playerLoop.subSystemList) { if (header.subSystemList is null) { continue; } foreach (var subSystem in header.subSystemList) { if (subSystem.type == typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization)) { return true; } } } return false; } #endif } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs.meta ================================================ fileFormatVersion: 2 guid: 15fb5b85042f19640b973ce651795aca MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopTimer.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Threading; using System; using Cysharp.Threading.Tasks.Internal; using UnityEngine; namespace Cysharp.Threading.Tasks { public abstract class PlayerLoopTimer : IDisposable, IPlayerLoopItem { readonly CancellationToken cancellationToken; readonly Action timerCallback; readonly object state; readonly PlayerLoopTiming playerLoopTiming; readonly bool periodic; bool isRunning; bool tryStop; bool isDisposed; protected PlayerLoopTimer(bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action timerCallback, object state) { this.periodic = periodic; this.playerLoopTiming = playerLoopTiming; this.cancellationToken = cancellationToken; this.timerCallback = timerCallback; this.state = state; } public static PlayerLoopTimer Create(TimeSpan interval, bool periodic, DelayType delayType, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action timerCallback, object state) { #if UNITY_EDITOR // force use Realtime. if (PlayerLoopHelper.IsMainThread && !UnityEditor.EditorApplication.isPlaying) { delayType = DelayType.Realtime; } #endif switch (delayType) { case DelayType.UnscaledDeltaTime: return new IgnoreTimeScalePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state); case DelayType.Realtime: return new RealtimePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state); case DelayType.DeltaTime: default: return new DeltaTimePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state); } } public static PlayerLoopTimer StartNew(TimeSpan interval, bool periodic, DelayType delayType, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action timerCallback, object state) { var timer = Create(interval, periodic, delayType, playerLoopTiming, cancellationToken, timerCallback, state); timer.Restart(); return timer; } /// /// Restart(Reset and Start) timer. /// public void Restart() { if (isDisposed) throw new ObjectDisposedException(null); ResetCore(null); // init state if (!isRunning) { isRunning = true; PlayerLoopHelper.AddAction(playerLoopTiming, this); } tryStop = false; } /// /// Restart(Reset and Start) and change interval. /// public void Restart(TimeSpan interval) { if (isDisposed) throw new ObjectDisposedException(null); ResetCore(interval); // init state if (!isRunning) { isRunning = true; PlayerLoopHelper.AddAction(playerLoopTiming, this); } tryStop = false; } /// /// Stop timer. /// public void Stop() { tryStop = true; } protected abstract void ResetCore(TimeSpan? newInterval); public void Dispose() { isDisposed = true; } bool IPlayerLoopItem.MoveNext() { if (isDisposed) { isRunning = false; return false; } if (tryStop) { isRunning = false; return false; } if (cancellationToken.IsCancellationRequested) { isRunning = false; return false; } if (!MoveNextCore()) { timerCallback(state); if (periodic) { ResetCore(null); return true; } else { isRunning = false; return false; } } return true; } protected abstract bool MoveNextCore(); } sealed class DeltaTimePlayerLoopTimer : PlayerLoopTimer { int initialFrame; float elapsed; float interval; public DeltaTimePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action timerCallback, object state) : base(periodic, playerLoopTiming, cancellationToken, timerCallback, state) { ResetCore(interval); } protected override bool MoveNextCore() { if (elapsed == 0.0f) { if (initialFrame == Time.frameCount) { return true; } } elapsed += Time.deltaTime; if (elapsed >= interval) { return false; } return true; } protected override void ResetCore(TimeSpan? interval) { this.elapsed = 0.0f; this.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1; if (interval != null) { this.interval = (float)interval.Value.TotalSeconds; } } } sealed class IgnoreTimeScalePlayerLoopTimer : PlayerLoopTimer { int initialFrame; float elapsed; float interval; public IgnoreTimeScalePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action timerCallback, object state) : base(periodic, playerLoopTiming, cancellationToken, timerCallback, state) { ResetCore(interval); } protected override bool MoveNextCore() { if (elapsed == 0.0f) { if (initialFrame == Time.frameCount) { return true; } } elapsed += Time.unscaledDeltaTime; if (elapsed >= interval) { return false; } return true; } protected override void ResetCore(TimeSpan? interval) { this.elapsed = 0.0f; this.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1; if (interval != null) { this.interval = (float)interval.Value.TotalSeconds; } } } sealed class RealtimePlayerLoopTimer : PlayerLoopTimer { ValueStopwatch stopwatch; long intervalTicks; public RealtimePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action timerCallback, object state) : base(periodic, playerLoopTiming, cancellationToken, timerCallback, state) { ResetCore(interval); } protected override bool MoveNextCore() { if (stopwatch.ElapsedTicks >= intervalTicks) { return false; } return true; } protected override void ResetCore(TimeSpan? interval) { this.stopwatch = ValueStopwatch.StartNew(); if (interval != null) { this.intervalTicks = interval.Value.Ticks; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopTimer.cs.meta ================================================ fileFormatVersion: 2 guid: 57095a17fdca7ee4380450910afc7f26 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Progress.cs ================================================ using System; using System.Collections.Generic; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { /// /// Lightweight IProgress[T] factory. /// public static class Progress { public static IProgress Create(Action handler) { if (handler == null) return NullProgress.Instance; return new AnonymousProgress(handler); } public static IProgress CreateOnlyValueChanged(Action handler, IEqualityComparer comparer = null) { if (handler == null) return NullProgress.Instance; #if UNITY_2018_3_OR_NEWER return new OnlyValueChangedProgress(handler, comparer ?? UnityEqualityComparer.GetDefault()); #else return new OnlyValueChangedProgress(handler, comparer ?? EqualityComparer.Default); #endif } sealed class NullProgress : IProgress { public static readonly IProgress Instance = new NullProgress(); NullProgress() { } public void Report(T value) { } } sealed class AnonymousProgress : IProgress { readonly Action action; public AnonymousProgress(Action action) { this.action = action; } public void Report(T value) { action(value); } } sealed class OnlyValueChangedProgress : IProgress { readonly Action action; readonly IEqualityComparer comparer; bool isFirstCall; T latestValue; public OnlyValueChangedProgress(Action action, IEqualityComparer comparer) { this.action = action; this.comparer = comparer; this.isFirstCall = true; } public void Report(T value) { if (isFirstCall) { isFirstCall = false; } else if (comparer.Equals(value, latestValue)) { return; } latestValue = value; action(value); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Progress.cs.meta ================================================ fileFormatVersion: 2 guid: e3377e2ae934ed54fb8fd5388e2d9eb9 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs ================================================ using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Threading; namespace Cysharp.Threading.Tasks { // internally used but public, allow to user create custom operator with pooling. public static class TaskPool { internal static int MaxPoolSize; // avoid to use ConcurrentDictionary for safety of WebGL build. static Dictionary> sizes = new Dictionary>(); static TaskPool() { try { var value = Environment.GetEnvironmentVariable("UNITASK_MAX_POOLSIZE"); if (value != null) { if (int.TryParse(value, out var size)) { MaxPoolSize = size; return; } } } catch { } MaxPoolSize = int.MaxValue; } public static void SetMaxPoolSize(int maxPoolSize) { MaxPoolSize = maxPoolSize; } public static IEnumerable<(Type, int)> GetCacheSizeInfo() { lock (sizes) { foreach (var item in sizes) { yield return (item.Key, item.Value()); } } } public static void RegisterSizeGetter(Type type, Func getSize) { lock (sizes) { sizes[type] = getSize; } } } public interface ITaskPoolNode { ref T NextNode { get; } } // mutable struct, don't mark readonly. [StructLayout(LayoutKind.Auto)] public struct TaskPool where T : class, ITaskPoolNode { int gate; int size; T root; public int Size => size; [MethodImpl(MethodImplOptions.AggressiveInlining)] public bool TryPop(out T result) { if (Interlocked.CompareExchange(ref gate, 1, 0) == 0) { var v = root; if (!(v is null)) { ref var nextNode = ref v.NextNode; root = nextNode; nextNode = null; size--; result = v; Volatile.Write(ref gate, 0); return true; } Volatile.Write(ref gate, 0); } result = default; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public bool TryPush(T item) { if (Interlocked.CompareExchange(ref gate, 1, 0) == 0) { if (size < TaskPool.MaxPoolSize) { item.NextNode = root; root = item; size++; Volatile.Write(ref gate, 0); return true; } else { Volatile.Write(ref gate, 0); } } return false; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs.meta ================================================ fileFormatVersion: 2 guid: 19f4e6575150765449cc99f25f06f25f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/TimeoutController.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; namespace Cysharp.Threading.Tasks { // CancellationTokenSource itself can not reuse but CancelAfter(Timeout.InfiniteTimeSpan) allows reuse if did not reach timeout. // Similar discussion: // https://github.com/dotnet/runtime/issues/4694 // https://github.com/dotnet/runtime/issues/48492 // This TimeoutController emulate similar implementation, using CancelAfterSlim; to achieve zero allocation timeout. public sealed class TimeoutController : IDisposable { readonly static Action CancelCancellationTokenSourceStateDelegate = new Action(CancelCancellationTokenSourceState); static void CancelCancellationTokenSourceState(object state) { var cts = (CancellationTokenSource)state; cts.Cancel(); } CancellationTokenSource timeoutSource; CancellationTokenSource linkedSource; PlayerLoopTimer timer; bool isDisposed; readonly DelayType delayType; readonly PlayerLoopTiming delayTiming; readonly CancellationTokenSource originalLinkCancellationTokenSource; public TimeoutController(DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update) { this.timeoutSource = new CancellationTokenSource(); this.originalLinkCancellationTokenSource = null; this.linkedSource = null; this.delayType = delayType; this.delayTiming = delayTiming; } public TimeoutController(CancellationTokenSource linkCancellationTokenSource, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update) { this.timeoutSource = new CancellationTokenSource(); this.originalLinkCancellationTokenSource = linkCancellationTokenSource; this.linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, linkCancellationTokenSource.Token); this.delayType = delayType; this.delayTiming = delayTiming; } public CancellationToken Timeout(int millisecondsTimeout) { return Timeout(TimeSpan.FromMilliseconds(millisecondsTimeout)); } public CancellationToken Timeout(TimeSpan timeout) { if (originalLinkCancellationTokenSource != null && originalLinkCancellationTokenSource.IsCancellationRequested) { return originalLinkCancellationTokenSource.Token; } // Timeouted, create new source and timer. if (timeoutSource.IsCancellationRequested) { timeoutSource.Dispose(); timeoutSource = new CancellationTokenSource(); if (linkedSource != null) { this.linkedSource.Cancel(); this.linkedSource.Dispose(); this.linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, originalLinkCancellationTokenSource.Token); } timer?.Dispose(); timer = null; } var useSource = (linkedSource != null) ? linkedSource : timeoutSource; var token = useSource.Token; if (timer == null) { // Timer complete => timeoutSource.Cancel() -> linkedSource will be canceled. // (linked)token is canceled => stop timer timer = PlayerLoopTimer.StartNew(timeout, false, delayType, delayTiming, token, CancelCancellationTokenSourceStateDelegate, timeoutSource); } else { timer.Restart(timeout); } return token; } public bool IsTimeout() { return timeoutSource.IsCancellationRequested; } public void Reset() { timer?.Stop(); } public void Dispose() { if (isDisposed) return; try { // stop timer. timer?.Dispose(); // cancel and dispose. timeoutSource.Cancel(); timeoutSource.Dispose(); if (linkedSource != null) { linkedSource.Cancel(); linkedSource.Dispose(); } } finally { isDisposed = true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/TimeoutController.cs.meta ================================================ fileFormatVersion: 2 guid: 6347ab34d2db6d744a654e8d62d96b96 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/TriggerEvent.cs ================================================ using System; using System.Threading; namespace Cysharp.Threading.Tasks { public interface ITriggerHandler { void OnNext(T value); void OnError(Exception ex); void OnCompleted(); void OnCanceled(CancellationToken cancellationToken); // set/get from TriggerEvent ITriggerHandler Prev { get; set; } ITriggerHandler Next { get; set; } } // be careful to use, itself is struct. public struct TriggerEvent { ITriggerHandler head; // head.prev is last ITriggerHandler iteratingHead; ITriggerHandler iteratingNode; void LogError(Exception ex) { #if UNITY_2018_3_OR_NEWER UnityEngine.Debug.LogException(ex); #else Console.WriteLine(ex); #endif } public void SetResult(T value) { if (iteratingNode != null) { throw new InvalidOperationException("Can not trigger itself in iterating."); } var h = head; while (h != null) { iteratingNode = h; try { h.OnNext(value); } catch (Exception ex) { LogError(ex); Remove(h); } // If `h` itself is removed by OnNext, h.Next is null. // Therefore, instead of looking at h.Next, the `iteratingNode` reference itself is replaced. h = h == iteratingNode ? h.Next : iteratingNode; } iteratingNode = null; if (iteratingHead != null) { Add(iteratingHead); iteratingHead = null; } } public void SetCanceled(CancellationToken cancellationToken) { if (iteratingNode != null) { throw new InvalidOperationException("Can not trigger itself in iterating."); } var h = head; while (h != null) { iteratingNode = h; try { h.OnCanceled(cancellationToken); } catch (Exception ex) { LogError(ex); } var next = h == iteratingNode ? h.Next : iteratingNode; iteratingNode = null; Remove(h); h = next; } iteratingNode = null; if (iteratingHead != null) { Add(iteratingHead); iteratingHead = null; } } public void SetCompleted() { if (iteratingNode != null) { throw new InvalidOperationException("Can not trigger itself in iterating."); } var h = head; while (h != null) { iteratingNode = h; try { h.OnCompleted(); } catch (Exception ex) { LogError(ex); } var next = h == iteratingNode ? h.Next : iteratingNode; iteratingNode = null; Remove(h); h = next; } iteratingNode = null; if (iteratingHead != null) { Add(iteratingHead); iteratingHead = null; } } public void SetError(Exception exception) { if (iteratingNode != null) { throw new InvalidOperationException("Can not trigger itself in iterating."); } var h = head; while (h != null) { iteratingNode = h; try { h.OnError(exception); } catch (Exception ex) { LogError(ex); } var next = h == iteratingNode ? h.Next : iteratingNode; iteratingNode = null; Remove(h); h = next; } iteratingNode = null; if (iteratingHead != null) { Add(iteratingHead); iteratingHead = null; } } public void Add(ITriggerHandler handler) { if (handler == null) throw new ArgumentNullException(nameof(handler)); // zero node. if (head == null) { head = handler; return; } if (iteratingNode != null) { if (iteratingHead == null) { iteratingHead = handler; return; } var last = iteratingHead.Prev; if (last == null) { // single node. iteratingHead.Prev = handler; iteratingHead.Next = handler; handler.Prev = iteratingHead; } else { // multi node iteratingHead.Prev = handler; last.Next = handler; handler.Prev = last; } } else { var last = head.Prev; if (last == null) { // single node. head.Prev = handler; head.Next = handler; handler.Prev = head; } else { // multi node head.Prev = handler; last.Next = handler; handler.Prev = last; } } } public void Remove(ITriggerHandler handler) { if (handler == null) throw new ArgumentNullException(nameof(handler)); var prev = handler.Prev; var next = handler.Next; if (next != null) { next.Prev = prev; } if (handler == head) { head = next; } // when handler is head, prev indicate last so don't use it. else if (prev != null) { prev.Next = next; } if (handler == iteratingNode) { iteratingNode = next; } if (handler == iteratingHead) { iteratingHead = next; } if (head != null) { if (head.Prev == handler) { if (prev != head) { head.Prev = prev; } else { head.Prev = null; } } } if (iteratingHead != null) { if (iteratingHead.Prev == handler) { if (prev != iteratingHead.Prev) { iteratingHead.Prev = prev; } else { iteratingHead.Prev = null; } } } handler.Prev = null; handler.Next = null; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/TriggerEvent.cs.meta ================================================ fileFormatVersion: 2 guid: f68b22bb8f66f5c4885f9bd3c4fc43ed MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncAwakeTrigger.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Threading; using UnityEngine; namespace Cysharp.Threading.Tasks.Triggers { public static partial class AsyncTriggerExtensions { public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this Component component) { return component.gameObject.GetAsyncAwakeTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncAwakeTrigger : AsyncTriggerBase { public UniTask AwakeAsync() { if (calledAwake) return UniTask.CompletedTask; return ((IAsyncOneShotTrigger)new AsyncTriggerHandler(this, true)).OneShotAsync(); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncAwakeTrigger.cs.meta ================================================ fileFormatVersion: 2 guid: ef2840a2586894741a0ae211b8fd669b MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncDestroyTrigger.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Threading; using UnityEngine; namespace Cysharp.Threading.Tasks.Triggers { public static partial class AsyncTriggerExtensions { public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this Component component) { return component.gameObject.GetAsyncDestroyTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncDestroyTrigger : MonoBehaviour { bool awakeCalled = false; bool called = false; CancellationTokenSource cancellationTokenSource; public CancellationToken CancellationToken { get { if (cancellationTokenSource == null) { cancellationTokenSource = new CancellationTokenSource(); if (!awakeCalled) { PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this)); } } return cancellationTokenSource.Token; } } void Awake() { awakeCalled = true; } void OnDestroy() { called = true; cancellationTokenSource?.Cancel(); cancellationTokenSource?.Dispose(); } public UniTask OnDestroyAsync() { if (called) return UniTask.CompletedTask; var tcs = new UniTaskCompletionSource(); // OnDestroy = Called Cancel. CancellationToken.RegisterWithoutCaptureExecutionContext(state => { var tcs2 = (UniTaskCompletionSource)state; tcs2.TrySetResult(); }, tcs); return tcs.Task; } class AwakeMonitor : IPlayerLoopItem { readonly AsyncDestroyTrigger trigger; public AwakeMonitor(AsyncDestroyTrigger trigger) { this.trigger = trigger; } public bool MoveNext() { if (trigger.called || trigger.awakeCalled) return false; if (trigger == null) { trigger.OnDestroy(); return false; } return true; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncDestroyTrigger.cs.meta ================================================ fileFormatVersion: 2 guid: f4afdcb1cbadf954ba8b1cf465429e17 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncStartTrigger.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using UnityEngine; namespace Cysharp.Threading.Tasks.Triggers { public static partial class AsyncTriggerExtensions { public static AsyncStartTrigger GetAsyncStartTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncStartTrigger GetAsyncStartTrigger(this Component component) { return component.gameObject.GetAsyncStartTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncStartTrigger : AsyncTriggerBase { bool called; void Start() { called = true; RaiseEvent(AsyncUnit.Default); } public UniTask StartAsync() { if (called) return UniTask.CompletedTask; return ((IAsyncOneShotTrigger)new AsyncTriggerHandler(this, true)).OneShotAsync(); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncStartTrigger.cs.meta ================================================ fileFormatVersion: 2 guid: b4fd0f75e54ec3d4fbcb7fc65b11646b MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncTriggerBase.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; using UnityEngine; namespace Cysharp.Threading.Tasks.Triggers { public abstract class AsyncTriggerBase : MonoBehaviour, IUniTaskAsyncEnumerable { TriggerEvent triggerEvent; internal protected bool calledAwake; internal protected bool calledDestroy; void Awake() { calledAwake = true; } void OnDestroy() { if (calledDestroy) return; calledDestroy = true; triggerEvent.SetCompleted(); } internal void AddHandler(ITriggerHandler handler) { if (!calledAwake) { PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this)); } triggerEvent.Add(handler); } internal void RemoveHandler(ITriggerHandler handler) { if (!calledAwake) { PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this)); } triggerEvent.Remove(handler); } protected void RaiseEvent(T value) { triggerEvent.SetResult(value); } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new AsyncTriggerEnumerator(this, cancellationToken); } sealed class AsyncTriggerEnumerator : MoveNextSource, IUniTaskAsyncEnumerator, ITriggerHandler { static Action cancellationCallback = CancellationCallback; readonly AsyncTriggerBase parent; CancellationToken cancellationToken; CancellationTokenRegistration registration; bool called; bool isDisposed; public AsyncTriggerEnumerator(AsyncTriggerBase parent, CancellationToken cancellationToken) { this.parent = parent; this.cancellationToken = cancellationToken; } public void OnCanceled(CancellationToken cancellationToken = default) { completionSource.TrySetCanceled(cancellationToken); } public void OnNext(T value) { Current = value; completionSource.TrySetResult(true); } public void OnCompleted() { completionSource.TrySetResult(false); } public void OnError(Exception ex) { completionSource.TrySetException(ex); } static void CancellationCallback(object state) { var self = (AsyncTriggerEnumerator)state; self.DisposeAsync().Forget(); // sync self.completionSource.TrySetCanceled(self.cancellationToken); } public T Current { get; private set; } ITriggerHandler ITriggerHandler.Prev { get; set; } ITriggerHandler ITriggerHandler.Next { get; set; } public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); completionSource.Reset(); if (!called) { called = true; TaskTracker.TrackActiveTask(this, 3); parent.AddHandler(this); if (cancellationToken.CanBeCanceled) { registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this); } } return new UniTask(this, completionSource.Version); } public UniTask DisposeAsync() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); registration.Dispose(); parent.RemoveHandler(this); } return default; } } class AwakeMonitor : IPlayerLoopItem { readonly AsyncTriggerBase trigger; public AwakeMonitor(AsyncTriggerBase trigger) { this.trigger = trigger; } public bool MoveNext() { if (trigger.calledAwake) return false; if (trigger == null) { trigger.OnDestroy(); return false; } return true; } } } public interface IAsyncOneShotTrigger { UniTask OneShotAsync(); } public partial class AsyncTriggerHandler : IAsyncOneShotTrigger { UniTask IAsyncOneShotTrigger.OneShotAsync() { core.Reset(); return new UniTask((IUniTaskSource)this, core.Version); } } public sealed partial class AsyncTriggerHandler : IUniTaskSource, ITriggerHandler, IDisposable { static Action cancellationCallback = CancellationCallback; readonly AsyncTriggerBase trigger; CancellationToken cancellationToken; CancellationTokenRegistration registration; bool isDisposed; bool callOnce; UniTaskCompletionSourceCore core; internal CancellationToken CancellationToken => cancellationToken; ITriggerHandler ITriggerHandler.Prev { get; set; } ITriggerHandler ITriggerHandler.Next { get; set; } internal AsyncTriggerHandler(AsyncTriggerBase trigger, bool callOnce) { if (cancellationToken.IsCancellationRequested) { isDisposed = true; return; } this.trigger = trigger; this.cancellationToken = default; this.registration = default; this.callOnce = callOnce; trigger.AddHandler(this); TaskTracker.TrackActiveTask(this, 3); } internal AsyncTriggerHandler(AsyncTriggerBase trigger, CancellationToken cancellationToken, bool callOnce) { if (cancellationToken.IsCancellationRequested) { isDisposed = true; return; } this.trigger = trigger; this.cancellationToken = cancellationToken; this.callOnce = callOnce; trigger.AddHandler(this); if (cancellationToken.CanBeCanceled) { registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this); } TaskTracker.TrackActiveTask(this, 3); } static void CancellationCallback(object state) { var self = (AsyncTriggerHandler)state; self.Dispose(); self.core.TrySetCanceled(self.cancellationToken); } public void Dispose() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); registration.Dispose(); trigger.RemoveHandler(this); } } T IUniTaskSource.GetResult(short token) { try { return core.GetResult(token); } finally { if (callOnce) { Dispose(); } } } void ITriggerHandler.OnNext(T value) { core.TrySetResult(value); } void ITriggerHandler.OnCanceled(CancellationToken cancellationToken) { core.TrySetCanceled(cancellationToken); } void ITriggerHandler.OnCompleted() { core.TrySetCanceled(CancellationToken.None); } void ITriggerHandler.OnError(Exception ex) { core.TrySetException(ex); } void IUniTaskSource.GetResult(short token) { ((IUniTaskSource)this).GetResult(token); } UniTaskStatus IUniTaskSource.GetStatus(short token) { return core.GetStatus(token); } UniTaskStatus IUniTaskSource.UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncTriggerBase.cs.meta ================================================ fileFormatVersion: 2 guid: 2c0c2bcee832c6641b25949c412f020f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncTriggerExtensions.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Threading; using UnityEngine; using Cysharp.Threading.Tasks.Triggers; namespace Cysharp.Threading.Tasks { public static class UniTaskCancellationExtensions { #if UNITY_2022_2_OR_NEWER /// This CancellationToken is canceled when the MonoBehaviour will be destroyed. public static CancellationToken GetCancellationTokenOnDestroy(this MonoBehaviour monoBehaviour) { return monoBehaviour.destroyCancellationToken; } #endif /// This CancellationToken is canceled when the MonoBehaviour will be destroyed. public static CancellationToken GetCancellationTokenOnDestroy(this GameObject gameObject) { return gameObject.GetAsyncDestroyTrigger().CancellationToken; } /// This CancellationToken is canceled when the MonoBehaviour will be destroyed. public static CancellationToken GetCancellationTokenOnDestroy(this Component component) { #if UNITY_2022_2_OR_NEWER if (component is MonoBehaviour mb) { return mb.destroyCancellationToken; } #endif return component.GetAsyncDestroyTrigger().CancellationToken; } } } namespace Cysharp.Threading.Tasks.Triggers { public static partial class AsyncTriggerExtensions { // Util. static T GetOrAddComponent(GameObject gameObject) where T : Component { #if UNITY_2019_2_OR_NEWER if (!gameObject.TryGetComponent(out var component)) { component = gameObject.AddComponent(); } #else var component = gameObject.GetComponent(); if (component == null) { component = gameObject.AddComponent(); } #endif return component; } // Special for single operation. /// This function is called when the MonoBehaviour will be destroyed. public static UniTask OnDestroyAsync(this GameObject gameObject) { return gameObject.GetAsyncDestroyTrigger().OnDestroyAsync(); } /// This function is called when the MonoBehaviour will be destroyed. public static UniTask OnDestroyAsync(this Component component) { return component.GetAsyncDestroyTrigger().OnDestroyAsync(); } public static UniTask StartAsync(this GameObject gameObject) { return gameObject.GetAsyncStartTrigger().StartAsync(); } public static UniTask StartAsync(this Component component) { return component.GetAsyncStartTrigger().StartAsync(); } public static UniTask AwakeAsync(this GameObject gameObject) { return gameObject.GetAsyncAwakeTrigger().AwakeAsync(); } public static UniTask AwakeAsync(this Component component) { return component.GetAsyncAwakeTrigger().AwakeAsync(); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/AsyncTriggerExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 59b61dbea1562a84fb7a38ae0a0a0f88 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Threading; using UnityEngine; #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT using UnityEngine.EventSystems; #endif namespace Cysharp.Threading.Tasks.Triggers { #region FixedUpdate public interface IAsyncFixedUpdateHandler { UniTask FixedUpdateAsync(); } public partial class AsyncTriggerHandler : IAsyncFixedUpdateHandler { UniTask IAsyncFixedUpdateHandler.FixedUpdateAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncFixedUpdateTrigger GetAsyncFixedUpdateTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncFixedUpdateTrigger GetAsyncFixedUpdateTrigger(this Component component) { return component.gameObject.GetAsyncFixedUpdateTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncFixedUpdateTrigger : AsyncTriggerBase { void FixedUpdate() { RaiseEvent(AsyncUnit.Default); } public IAsyncFixedUpdateHandler GetFixedUpdateAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncFixedUpdateHandler GetFixedUpdateAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask FixedUpdateAsync() { return ((IAsyncFixedUpdateHandler)new AsyncTriggerHandler(this, true)).FixedUpdateAsync(); } public UniTask FixedUpdateAsync(CancellationToken cancellationToken) { return ((IAsyncFixedUpdateHandler)new AsyncTriggerHandler(this, cancellationToken, true)).FixedUpdateAsync(); } } #endregion #region LateUpdate public interface IAsyncLateUpdateHandler { UniTask LateUpdateAsync(); } public partial class AsyncTriggerHandler : IAsyncLateUpdateHandler { UniTask IAsyncLateUpdateHandler.LateUpdateAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncLateUpdateTrigger GetAsyncLateUpdateTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncLateUpdateTrigger GetAsyncLateUpdateTrigger(this Component component) { return component.gameObject.GetAsyncLateUpdateTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncLateUpdateTrigger : AsyncTriggerBase { void LateUpdate() { RaiseEvent(AsyncUnit.Default); } public IAsyncLateUpdateHandler GetLateUpdateAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncLateUpdateHandler GetLateUpdateAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask LateUpdateAsync() { return ((IAsyncLateUpdateHandler)new AsyncTriggerHandler(this, true)).LateUpdateAsync(); } public UniTask LateUpdateAsync(CancellationToken cancellationToken) { return ((IAsyncLateUpdateHandler)new AsyncTriggerHandler(this, cancellationToken, true)).LateUpdateAsync(); } } #endregion #region AnimatorIK public interface IAsyncOnAnimatorIKHandler { UniTask OnAnimatorIKAsync(); } public partial class AsyncTriggerHandler : IAsyncOnAnimatorIKHandler { UniTask IAsyncOnAnimatorIKHandler.OnAnimatorIKAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncAnimatorIKTrigger GetAsyncAnimatorIKTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncAnimatorIKTrigger GetAsyncAnimatorIKTrigger(this Component component) { return component.gameObject.GetAsyncAnimatorIKTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncAnimatorIKTrigger : AsyncTriggerBase { void OnAnimatorIK(int layerIndex) { RaiseEvent((layerIndex)); } public IAsyncOnAnimatorIKHandler GetOnAnimatorIKAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnAnimatorIKHandler GetOnAnimatorIKAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnAnimatorIKAsync() { return ((IAsyncOnAnimatorIKHandler)new AsyncTriggerHandler(this, true)).OnAnimatorIKAsync(); } public UniTask OnAnimatorIKAsync(CancellationToken cancellationToken) { return ((IAsyncOnAnimatorIKHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnAnimatorIKAsync(); } } #endregion #region AnimatorMove public interface IAsyncOnAnimatorMoveHandler { UniTask OnAnimatorMoveAsync(); } public partial class AsyncTriggerHandler : IAsyncOnAnimatorMoveHandler { UniTask IAsyncOnAnimatorMoveHandler.OnAnimatorMoveAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncAnimatorMoveTrigger GetAsyncAnimatorMoveTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncAnimatorMoveTrigger GetAsyncAnimatorMoveTrigger(this Component component) { return component.gameObject.GetAsyncAnimatorMoveTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncAnimatorMoveTrigger : AsyncTriggerBase { void OnAnimatorMove() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnAnimatorMoveHandler GetOnAnimatorMoveAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnAnimatorMoveHandler GetOnAnimatorMoveAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnAnimatorMoveAsync() { return ((IAsyncOnAnimatorMoveHandler)new AsyncTriggerHandler(this, true)).OnAnimatorMoveAsync(); } public UniTask OnAnimatorMoveAsync(CancellationToken cancellationToken) { return ((IAsyncOnAnimatorMoveHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnAnimatorMoveAsync(); } } #endregion #region ApplicationFocus public interface IAsyncOnApplicationFocusHandler { UniTask OnApplicationFocusAsync(); } public partial class AsyncTriggerHandler : IAsyncOnApplicationFocusHandler { UniTask IAsyncOnApplicationFocusHandler.OnApplicationFocusAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncApplicationFocusTrigger GetAsyncApplicationFocusTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncApplicationFocusTrigger GetAsyncApplicationFocusTrigger(this Component component) { return component.gameObject.GetAsyncApplicationFocusTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncApplicationFocusTrigger : AsyncTriggerBase { void OnApplicationFocus(bool hasFocus) { RaiseEvent((hasFocus)); } public IAsyncOnApplicationFocusHandler GetOnApplicationFocusAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnApplicationFocusHandler GetOnApplicationFocusAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnApplicationFocusAsync() { return ((IAsyncOnApplicationFocusHandler)new AsyncTriggerHandler(this, true)).OnApplicationFocusAsync(); } public UniTask OnApplicationFocusAsync(CancellationToken cancellationToken) { return ((IAsyncOnApplicationFocusHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnApplicationFocusAsync(); } } #endregion #region ApplicationPause public interface IAsyncOnApplicationPauseHandler { UniTask OnApplicationPauseAsync(); } public partial class AsyncTriggerHandler : IAsyncOnApplicationPauseHandler { UniTask IAsyncOnApplicationPauseHandler.OnApplicationPauseAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncApplicationPauseTrigger GetAsyncApplicationPauseTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncApplicationPauseTrigger GetAsyncApplicationPauseTrigger(this Component component) { return component.gameObject.GetAsyncApplicationPauseTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncApplicationPauseTrigger : AsyncTriggerBase { void OnApplicationPause(bool pauseStatus) { RaiseEvent((pauseStatus)); } public IAsyncOnApplicationPauseHandler GetOnApplicationPauseAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnApplicationPauseHandler GetOnApplicationPauseAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnApplicationPauseAsync() { return ((IAsyncOnApplicationPauseHandler)new AsyncTriggerHandler(this, true)).OnApplicationPauseAsync(); } public UniTask OnApplicationPauseAsync(CancellationToken cancellationToken) { return ((IAsyncOnApplicationPauseHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnApplicationPauseAsync(); } } #endregion #region ApplicationQuit public interface IAsyncOnApplicationQuitHandler { UniTask OnApplicationQuitAsync(); } public partial class AsyncTriggerHandler : IAsyncOnApplicationQuitHandler { UniTask IAsyncOnApplicationQuitHandler.OnApplicationQuitAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncApplicationQuitTrigger GetAsyncApplicationQuitTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncApplicationQuitTrigger GetAsyncApplicationQuitTrigger(this Component component) { return component.gameObject.GetAsyncApplicationQuitTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncApplicationQuitTrigger : AsyncTriggerBase { void OnApplicationQuit() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnApplicationQuitHandler GetOnApplicationQuitAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnApplicationQuitHandler GetOnApplicationQuitAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnApplicationQuitAsync() { return ((IAsyncOnApplicationQuitHandler)new AsyncTriggerHandler(this, true)).OnApplicationQuitAsync(); } public UniTask OnApplicationQuitAsync(CancellationToken cancellationToken) { return ((IAsyncOnApplicationQuitHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnApplicationQuitAsync(); } } #endregion #region AudioFilterRead public interface IAsyncOnAudioFilterReadHandler { UniTask<(float[] data, int channels)> OnAudioFilterReadAsync(); } public partial class AsyncTriggerHandler : IAsyncOnAudioFilterReadHandler { UniTask<(float[] data, int channels)> IAsyncOnAudioFilterReadHandler.OnAudioFilterReadAsync() { core.Reset(); return new UniTask<(float[] data, int channels)>((IUniTaskSource<(float[] data, int channels)>)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncAudioFilterReadTrigger GetAsyncAudioFilterReadTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncAudioFilterReadTrigger GetAsyncAudioFilterReadTrigger(this Component component) { return component.gameObject.GetAsyncAudioFilterReadTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncAudioFilterReadTrigger : AsyncTriggerBase<(float[] data, int channels)> { void OnAudioFilterRead(float[] data, int channels) { RaiseEvent((data, channels)); } public IAsyncOnAudioFilterReadHandler GetOnAudioFilterReadAsyncHandler() { return new AsyncTriggerHandler<(float[] data, int channels)>(this, false); } public IAsyncOnAudioFilterReadHandler GetOnAudioFilterReadAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler<(float[] data, int channels)>(this, cancellationToken, false); } public UniTask<(float[] data, int channels)> OnAudioFilterReadAsync() { return ((IAsyncOnAudioFilterReadHandler)new AsyncTriggerHandler<(float[] data, int channels)>(this, true)).OnAudioFilterReadAsync(); } public UniTask<(float[] data, int channels)> OnAudioFilterReadAsync(CancellationToken cancellationToken) { return ((IAsyncOnAudioFilterReadHandler)new AsyncTriggerHandler<(float[] data, int channels)>(this, cancellationToken, true)).OnAudioFilterReadAsync(); } } #endregion #region BecameInvisible public interface IAsyncOnBecameInvisibleHandler { UniTask OnBecameInvisibleAsync(); } public partial class AsyncTriggerHandler : IAsyncOnBecameInvisibleHandler { UniTask IAsyncOnBecameInvisibleHandler.OnBecameInvisibleAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncBecameInvisibleTrigger GetAsyncBecameInvisibleTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncBecameInvisibleTrigger GetAsyncBecameInvisibleTrigger(this Component component) { return component.gameObject.GetAsyncBecameInvisibleTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncBecameInvisibleTrigger : AsyncTriggerBase { void OnBecameInvisible() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnBecameInvisibleHandler GetOnBecameInvisibleAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnBecameInvisibleHandler GetOnBecameInvisibleAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnBecameInvisibleAsync() { return ((IAsyncOnBecameInvisibleHandler)new AsyncTriggerHandler(this, true)).OnBecameInvisibleAsync(); } public UniTask OnBecameInvisibleAsync(CancellationToken cancellationToken) { return ((IAsyncOnBecameInvisibleHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnBecameInvisibleAsync(); } } #endregion #region BecameVisible public interface IAsyncOnBecameVisibleHandler { UniTask OnBecameVisibleAsync(); } public partial class AsyncTriggerHandler : IAsyncOnBecameVisibleHandler { UniTask IAsyncOnBecameVisibleHandler.OnBecameVisibleAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncBecameVisibleTrigger GetAsyncBecameVisibleTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncBecameVisibleTrigger GetAsyncBecameVisibleTrigger(this Component component) { return component.gameObject.GetAsyncBecameVisibleTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncBecameVisibleTrigger : AsyncTriggerBase { void OnBecameVisible() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnBecameVisibleHandler GetOnBecameVisibleAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnBecameVisibleHandler GetOnBecameVisibleAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnBecameVisibleAsync() { return ((IAsyncOnBecameVisibleHandler)new AsyncTriggerHandler(this, true)).OnBecameVisibleAsync(); } public UniTask OnBecameVisibleAsync(CancellationToken cancellationToken) { return ((IAsyncOnBecameVisibleHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnBecameVisibleAsync(); } } #endregion #region BeforeTransformParentChanged public interface IAsyncOnBeforeTransformParentChangedHandler { UniTask OnBeforeTransformParentChangedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnBeforeTransformParentChangedHandler { UniTask IAsyncOnBeforeTransformParentChangedHandler.OnBeforeTransformParentChangedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncBeforeTransformParentChangedTrigger GetAsyncBeforeTransformParentChangedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncBeforeTransformParentChangedTrigger GetAsyncBeforeTransformParentChangedTrigger(this Component component) { return component.gameObject.GetAsyncBeforeTransformParentChangedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncBeforeTransformParentChangedTrigger : AsyncTriggerBase { void OnBeforeTransformParentChanged() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnBeforeTransformParentChangedHandler GetOnBeforeTransformParentChangedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnBeforeTransformParentChangedHandler GetOnBeforeTransformParentChangedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnBeforeTransformParentChangedAsync() { return ((IAsyncOnBeforeTransformParentChangedHandler)new AsyncTriggerHandler(this, true)).OnBeforeTransformParentChangedAsync(); } public UniTask OnBeforeTransformParentChangedAsync(CancellationToken cancellationToken) { return ((IAsyncOnBeforeTransformParentChangedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnBeforeTransformParentChangedAsync(); } } #endregion #region OnCanvasGroupChanged public interface IAsyncOnCanvasGroupChangedHandler { UniTask OnCanvasGroupChangedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnCanvasGroupChangedHandler { UniTask IAsyncOnCanvasGroupChangedHandler.OnCanvasGroupChangedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncOnCanvasGroupChangedTrigger GetAsyncOnCanvasGroupChangedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncOnCanvasGroupChangedTrigger GetAsyncOnCanvasGroupChangedTrigger(this Component component) { return component.gameObject.GetAsyncOnCanvasGroupChangedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncOnCanvasGroupChangedTrigger : AsyncTriggerBase { void OnCanvasGroupChanged() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnCanvasGroupChangedHandler GetOnCanvasGroupChangedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnCanvasGroupChangedHandler GetOnCanvasGroupChangedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnCanvasGroupChangedAsync() { return ((IAsyncOnCanvasGroupChangedHandler)new AsyncTriggerHandler(this, true)).OnCanvasGroupChangedAsync(); } public UniTask OnCanvasGroupChangedAsync(CancellationToken cancellationToken) { return ((IAsyncOnCanvasGroupChangedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnCanvasGroupChangedAsync(); } } #endregion #region CollisionEnter #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT public interface IAsyncOnCollisionEnterHandler { UniTask OnCollisionEnterAsync(); } public partial class AsyncTriggerHandler : IAsyncOnCollisionEnterHandler { UniTask IAsyncOnCollisionEnterHandler.OnCollisionEnterAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncCollisionEnterTrigger GetAsyncCollisionEnterTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncCollisionEnterTrigger GetAsyncCollisionEnterTrigger(this Component component) { return component.gameObject.GetAsyncCollisionEnterTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncCollisionEnterTrigger : AsyncTriggerBase { void OnCollisionEnter(Collision coll) { RaiseEvent((coll)); } public IAsyncOnCollisionEnterHandler GetOnCollisionEnterAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnCollisionEnterHandler GetOnCollisionEnterAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnCollisionEnterAsync() { return ((IAsyncOnCollisionEnterHandler)new AsyncTriggerHandler(this, true)).OnCollisionEnterAsync(); } public UniTask OnCollisionEnterAsync(CancellationToken cancellationToken) { return ((IAsyncOnCollisionEnterHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnCollisionEnterAsync(); } } #endif #endregion #region CollisionEnter2D #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT public interface IAsyncOnCollisionEnter2DHandler { UniTask OnCollisionEnter2DAsync(); } public partial class AsyncTriggerHandler : IAsyncOnCollisionEnter2DHandler { UniTask IAsyncOnCollisionEnter2DHandler.OnCollisionEnter2DAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncCollisionEnter2DTrigger GetAsyncCollisionEnter2DTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncCollisionEnter2DTrigger GetAsyncCollisionEnter2DTrigger(this Component component) { return component.gameObject.GetAsyncCollisionEnter2DTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncCollisionEnter2DTrigger : AsyncTriggerBase { void OnCollisionEnter2D(Collision2D coll) { RaiseEvent((coll)); } public IAsyncOnCollisionEnter2DHandler GetOnCollisionEnter2DAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnCollisionEnter2DHandler GetOnCollisionEnter2DAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnCollisionEnter2DAsync() { return ((IAsyncOnCollisionEnter2DHandler)new AsyncTriggerHandler(this, true)).OnCollisionEnter2DAsync(); } public UniTask OnCollisionEnter2DAsync(CancellationToken cancellationToken) { return ((IAsyncOnCollisionEnter2DHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnCollisionEnter2DAsync(); } } #endif #endregion #region CollisionExit #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT public interface IAsyncOnCollisionExitHandler { UniTask OnCollisionExitAsync(); } public partial class AsyncTriggerHandler : IAsyncOnCollisionExitHandler { UniTask IAsyncOnCollisionExitHandler.OnCollisionExitAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncCollisionExitTrigger GetAsyncCollisionExitTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncCollisionExitTrigger GetAsyncCollisionExitTrigger(this Component component) { return component.gameObject.GetAsyncCollisionExitTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncCollisionExitTrigger : AsyncTriggerBase { void OnCollisionExit(Collision coll) { RaiseEvent((coll)); } public IAsyncOnCollisionExitHandler GetOnCollisionExitAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnCollisionExitHandler GetOnCollisionExitAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnCollisionExitAsync() { return ((IAsyncOnCollisionExitHandler)new AsyncTriggerHandler(this, true)).OnCollisionExitAsync(); } public UniTask OnCollisionExitAsync(CancellationToken cancellationToken) { return ((IAsyncOnCollisionExitHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnCollisionExitAsync(); } } #endif #endregion #region CollisionExit2D #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT public interface IAsyncOnCollisionExit2DHandler { UniTask OnCollisionExit2DAsync(); } public partial class AsyncTriggerHandler : IAsyncOnCollisionExit2DHandler { UniTask IAsyncOnCollisionExit2DHandler.OnCollisionExit2DAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncCollisionExit2DTrigger GetAsyncCollisionExit2DTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncCollisionExit2DTrigger GetAsyncCollisionExit2DTrigger(this Component component) { return component.gameObject.GetAsyncCollisionExit2DTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncCollisionExit2DTrigger : AsyncTriggerBase { void OnCollisionExit2D(Collision2D coll) { RaiseEvent((coll)); } public IAsyncOnCollisionExit2DHandler GetOnCollisionExit2DAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnCollisionExit2DHandler GetOnCollisionExit2DAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnCollisionExit2DAsync() { return ((IAsyncOnCollisionExit2DHandler)new AsyncTriggerHandler(this, true)).OnCollisionExit2DAsync(); } public UniTask OnCollisionExit2DAsync(CancellationToken cancellationToken) { return ((IAsyncOnCollisionExit2DHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnCollisionExit2DAsync(); } } #endif #endregion #region CollisionStay #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT public interface IAsyncOnCollisionStayHandler { UniTask OnCollisionStayAsync(); } public partial class AsyncTriggerHandler : IAsyncOnCollisionStayHandler { UniTask IAsyncOnCollisionStayHandler.OnCollisionStayAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncCollisionStayTrigger GetAsyncCollisionStayTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncCollisionStayTrigger GetAsyncCollisionStayTrigger(this Component component) { return component.gameObject.GetAsyncCollisionStayTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncCollisionStayTrigger : AsyncTriggerBase { void OnCollisionStay(Collision coll) { RaiseEvent((coll)); } public IAsyncOnCollisionStayHandler GetOnCollisionStayAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnCollisionStayHandler GetOnCollisionStayAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnCollisionStayAsync() { return ((IAsyncOnCollisionStayHandler)new AsyncTriggerHandler(this, true)).OnCollisionStayAsync(); } public UniTask OnCollisionStayAsync(CancellationToken cancellationToken) { return ((IAsyncOnCollisionStayHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnCollisionStayAsync(); } } #endif #endregion #region CollisionStay2D #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT public interface IAsyncOnCollisionStay2DHandler { UniTask OnCollisionStay2DAsync(); } public partial class AsyncTriggerHandler : IAsyncOnCollisionStay2DHandler { UniTask IAsyncOnCollisionStay2DHandler.OnCollisionStay2DAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncCollisionStay2DTrigger GetAsyncCollisionStay2DTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncCollisionStay2DTrigger GetAsyncCollisionStay2DTrigger(this Component component) { return component.gameObject.GetAsyncCollisionStay2DTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncCollisionStay2DTrigger : AsyncTriggerBase { void OnCollisionStay2D(Collision2D coll) { RaiseEvent((coll)); } public IAsyncOnCollisionStay2DHandler GetOnCollisionStay2DAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnCollisionStay2DHandler GetOnCollisionStay2DAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnCollisionStay2DAsync() { return ((IAsyncOnCollisionStay2DHandler)new AsyncTriggerHandler(this, true)).OnCollisionStay2DAsync(); } public UniTask OnCollisionStay2DAsync(CancellationToken cancellationToken) { return ((IAsyncOnCollisionStay2DHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnCollisionStay2DAsync(); } } #endif #endregion #region ControllerColliderHit #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT public interface IAsyncOnControllerColliderHitHandler { UniTask OnControllerColliderHitAsync(); } public partial class AsyncTriggerHandler : IAsyncOnControllerColliderHitHandler { UniTask IAsyncOnControllerColliderHitHandler.OnControllerColliderHitAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncControllerColliderHitTrigger GetAsyncControllerColliderHitTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncControllerColliderHitTrigger GetAsyncControllerColliderHitTrigger(this Component component) { return component.gameObject.GetAsyncControllerColliderHitTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncControllerColliderHitTrigger : AsyncTriggerBase { void OnControllerColliderHit(ControllerColliderHit hit) { RaiseEvent((hit)); } public IAsyncOnControllerColliderHitHandler GetOnControllerColliderHitAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnControllerColliderHitHandler GetOnControllerColliderHitAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnControllerColliderHitAsync() { return ((IAsyncOnControllerColliderHitHandler)new AsyncTriggerHandler(this, true)).OnControllerColliderHitAsync(); } public UniTask OnControllerColliderHitAsync(CancellationToken cancellationToken) { return ((IAsyncOnControllerColliderHitHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnControllerColliderHitAsync(); } } #endif #endregion #region Disable public interface IAsyncOnDisableHandler { UniTask OnDisableAsync(); } public partial class AsyncTriggerHandler : IAsyncOnDisableHandler { UniTask IAsyncOnDisableHandler.OnDisableAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncDisableTrigger GetAsyncDisableTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncDisableTrigger GetAsyncDisableTrigger(this Component component) { return component.gameObject.GetAsyncDisableTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncDisableTrigger : AsyncTriggerBase { void OnDisable() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnDisableHandler GetOnDisableAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnDisableHandler GetOnDisableAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnDisableAsync() { return ((IAsyncOnDisableHandler)new AsyncTriggerHandler(this, true)).OnDisableAsync(); } public UniTask OnDisableAsync(CancellationToken cancellationToken) { return ((IAsyncOnDisableHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnDisableAsync(); } } #endregion #region DrawGizmos public interface IAsyncOnDrawGizmosHandler { UniTask OnDrawGizmosAsync(); } public partial class AsyncTriggerHandler : IAsyncOnDrawGizmosHandler { UniTask IAsyncOnDrawGizmosHandler.OnDrawGizmosAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncDrawGizmosTrigger GetAsyncDrawGizmosTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncDrawGizmosTrigger GetAsyncDrawGizmosTrigger(this Component component) { return component.gameObject.GetAsyncDrawGizmosTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncDrawGizmosTrigger : AsyncTriggerBase { void OnDrawGizmos() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnDrawGizmosHandler GetOnDrawGizmosAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnDrawGizmosHandler GetOnDrawGizmosAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnDrawGizmosAsync() { return ((IAsyncOnDrawGizmosHandler)new AsyncTriggerHandler(this, true)).OnDrawGizmosAsync(); } public UniTask OnDrawGizmosAsync(CancellationToken cancellationToken) { return ((IAsyncOnDrawGizmosHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnDrawGizmosAsync(); } } #endregion #region DrawGizmosSelected public interface IAsyncOnDrawGizmosSelectedHandler { UniTask OnDrawGizmosSelectedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnDrawGizmosSelectedHandler { UniTask IAsyncOnDrawGizmosSelectedHandler.OnDrawGizmosSelectedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncDrawGizmosSelectedTrigger GetAsyncDrawGizmosSelectedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncDrawGizmosSelectedTrigger GetAsyncDrawGizmosSelectedTrigger(this Component component) { return component.gameObject.GetAsyncDrawGizmosSelectedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncDrawGizmosSelectedTrigger : AsyncTriggerBase { void OnDrawGizmosSelected() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnDrawGizmosSelectedHandler GetOnDrawGizmosSelectedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnDrawGizmosSelectedHandler GetOnDrawGizmosSelectedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnDrawGizmosSelectedAsync() { return ((IAsyncOnDrawGizmosSelectedHandler)new AsyncTriggerHandler(this, true)).OnDrawGizmosSelectedAsync(); } public UniTask OnDrawGizmosSelectedAsync(CancellationToken cancellationToken) { return ((IAsyncOnDrawGizmosSelectedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnDrawGizmosSelectedAsync(); } } #endregion #region Enable public interface IAsyncOnEnableHandler { UniTask OnEnableAsync(); } public partial class AsyncTriggerHandler : IAsyncOnEnableHandler { UniTask IAsyncOnEnableHandler.OnEnableAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncEnableTrigger GetAsyncEnableTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncEnableTrigger GetAsyncEnableTrigger(this Component component) { return component.gameObject.GetAsyncEnableTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncEnableTrigger : AsyncTriggerBase { void OnEnable() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnEnableHandler GetOnEnableAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnEnableHandler GetOnEnableAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnEnableAsync() { return ((IAsyncOnEnableHandler)new AsyncTriggerHandler(this, true)).OnEnableAsync(); } public UniTask OnEnableAsync(CancellationToken cancellationToken) { return ((IAsyncOnEnableHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnEnableAsync(); } } #endregion #region GUI public interface IAsyncOnGUIHandler { UniTask OnGUIAsync(); } public partial class AsyncTriggerHandler : IAsyncOnGUIHandler { UniTask IAsyncOnGUIHandler.OnGUIAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncGUITrigger GetAsyncGUITrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncGUITrigger GetAsyncGUITrigger(this Component component) { return component.gameObject.GetAsyncGUITrigger(); } } [DisallowMultipleComponent] public sealed class AsyncGUITrigger : AsyncTriggerBase { void OnGUI() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnGUIHandler GetOnGUIAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnGUIHandler GetOnGUIAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnGUIAsync() { return ((IAsyncOnGUIHandler)new AsyncTriggerHandler(this, true)).OnGUIAsync(); } public UniTask OnGUIAsync(CancellationToken cancellationToken) { return ((IAsyncOnGUIHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnGUIAsync(); } } #endregion #region JointBreak #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT public interface IAsyncOnJointBreakHandler { UniTask OnJointBreakAsync(); } public partial class AsyncTriggerHandler : IAsyncOnJointBreakHandler { UniTask IAsyncOnJointBreakHandler.OnJointBreakAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncJointBreakTrigger GetAsyncJointBreakTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncJointBreakTrigger GetAsyncJointBreakTrigger(this Component component) { return component.gameObject.GetAsyncJointBreakTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncJointBreakTrigger : AsyncTriggerBase { void OnJointBreak(float breakForce) { RaiseEvent((breakForce)); } public IAsyncOnJointBreakHandler GetOnJointBreakAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnJointBreakHandler GetOnJointBreakAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnJointBreakAsync() { return ((IAsyncOnJointBreakHandler)new AsyncTriggerHandler(this, true)).OnJointBreakAsync(); } public UniTask OnJointBreakAsync(CancellationToken cancellationToken) { return ((IAsyncOnJointBreakHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnJointBreakAsync(); } } #endif #endregion #region JointBreak2D #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT public interface IAsyncOnJointBreak2DHandler { UniTask OnJointBreak2DAsync(); } public partial class AsyncTriggerHandler : IAsyncOnJointBreak2DHandler { UniTask IAsyncOnJointBreak2DHandler.OnJointBreak2DAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncJointBreak2DTrigger GetAsyncJointBreak2DTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncJointBreak2DTrigger GetAsyncJointBreak2DTrigger(this Component component) { return component.gameObject.GetAsyncJointBreak2DTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncJointBreak2DTrigger : AsyncTriggerBase { void OnJointBreak2D(Joint2D brokenJoint) { RaiseEvent((brokenJoint)); } public IAsyncOnJointBreak2DHandler GetOnJointBreak2DAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnJointBreak2DHandler GetOnJointBreak2DAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnJointBreak2DAsync() { return ((IAsyncOnJointBreak2DHandler)new AsyncTriggerHandler(this, true)).OnJointBreak2DAsync(); } public UniTask OnJointBreak2DAsync(CancellationToken cancellationToken) { return ((IAsyncOnJointBreak2DHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnJointBreak2DAsync(); } } #endif #endregion #region MouseDown #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) public interface IAsyncOnMouseDownHandler { UniTask OnMouseDownAsync(); } public partial class AsyncTriggerHandler : IAsyncOnMouseDownHandler { UniTask IAsyncOnMouseDownHandler.OnMouseDownAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncMouseDownTrigger GetAsyncMouseDownTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncMouseDownTrigger GetAsyncMouseDownTrigger(this Component component) { return component.gameObject.GetAsyncMouseDownTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncMouseDownTrigger : AsyncTriggerBase { void OnMouseDown() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnMouseDownHandler GetOnMouseDownAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnMouseDownHandler GetOnMouseDownAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnMouseDownAsync() { return ((IAsyncOnMouseDownHandler)new AsyncTriggerHandler(this, true)).OnMouseDownAsync(); } public UniTask OnMouseDownAsync(CancellationToken cancellationToken) { return ((IAsyncOnMouseDownHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnMouseDownAsync(); } } #endif #endregion #region MouseDrag #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) public interface IAsyncOnMouseDragHandler { UniTask OnMouseDragAsync(); } public partial class AsyncTriggerHandler : IAsyncOnMouseDragHandler { UniTask IAsyncOnMouseDragHandler.OnMouseDragAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncMouseDragTrigger GetAsyncMouseDragTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncMouseDragTrigger GetAsyncMouseDragTrigger(this Component component) { return component.gameObject.GetAsyncMouseDragTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncMouseDragTrigger : AsyncTriggerBase { void OnMouseDrag() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnMouseDragHandler GetOnMouseDragAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnMouseDragHandler GetOnMouseDragAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnMouseDragAsync() { return ((IAsyncOnMouseDragHandler)new AsyncTriggerHandler(this, true)).OnMouseDragAsync(); } public UniTask OnMouseDragAsync(CancellationToken cancellationToken) { return ((IAsyncOnMouseDragHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnMouseDragAsync(); } } #endif #endregion #region MouseEnter #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) public interface IAsyncOnMouseEnterHandler { UniTask OnMouseEnterAsync(); } public partial class AsyncTriggerHandler : IAsyncOnMouseEnterHandler { UniTask IAsyncOnMouseEnterHandler.OnMouseEnterAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncMouseEnterTrigger GetAsyncMouseEnterTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncMouseEnterTrigger GetAsyncMouseEnterTrigger(this Component component) { return component.gameObject.GetAsyncMouseEnterTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncMouseEnterTrigger : AsyncTriggerBase { void OnMouseEnter() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnMouseEnterHandler GetOnMouseEnterAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnMouseEnterHandler GetOnMouseEnterAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnMouseEnterAsync() { return ((IAsyncOnMouseEnterHandler)new AsyncTriggerHandler(this, true)).OnMouseEnterAsync(); } public UniTask OnMouseEnterAsync(CancellationToken cancellationToken) { return ((IAsyncOnMouseEnterHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnMouseEnterAsync(); } } #endif #endregion #region MouseExit #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) public interface IAsyncOnMouseExitHandler { UniTask OnMouseExitAsync(); } public partial class AsyncTriggerHandler : IAsyncOnMouseExitHandler { UniTask IAsyncOnMouseExitHandler.OnMouseExitAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncMouseExitTrigger GetAsyncMouseExitTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncMouseExitTrigger GetAsyncMouseExitTrigger(this Component component) { return component.gameObject.GetAsyncMouseExitTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncMouseExitTrigger : AsyncTriggerBase { void OnMouseExit() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnMouseExitHandler GetOnMouseExitAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnMouseExitHandler GetOnMouseExitAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnMouseExitAsync() { return ((IAsyncOnMouseExitHandler)new AsyncTriggerHandler(this, true)).OnMouseExitAsync(); } public UniTask OnMouseExitAsync(CancellationToken cancellationToken) { return ((IAsyncOnMouseExitHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnMouseExitAsync(); } } #endif #endregion #region MouseOver #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) public interface IAsyncOnMouseOverHandler { UniTask OnMouseOverAsync(); } public partial class AsyncTriggerHandler : IAsyncOnMouseOverHandler { UniTask IAsyncOnMouseOverHandler.OnMouseOverAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncMouseOverTrigger GetAsyncMouseOverTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncMouseOverTrigger GetAsyncMouseOverTrigger(this Component component) { return component.gameObject.GetAsyncMouseOverTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncMouseOverTrigger : AsyncTriggerBase { void OnMouseOver() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnMouseOverHandler GetOnMouseOverAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnMouseOverHandler GetOnMouseOverAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnMouseOverAsync() { return ((IAsyncOnMouseOverHandler)new AsyncTriggerHandler(this, true)).OnMouseOverAsync(); } public UniTask OnMouseOverAsync(CancellationToken cancellationToken) { return ((IAsyncOnMouseOverHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnMouseOverAsync(); } } #endif #endregion #region MouseUp #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) public interface IAsyncOnMouseUpHandler { UniTask OnMouseUpAsync(); } public partial class AsyncTriggerHandler : IAsyncOnMouseUpHandler { UniTask IAsyncOnMouseUpHandler.OnMouseUpAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncMouseUpTrigger GetAsyncMouseUpTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncMouseUpTrigger GetAsyncMouseUpTrigger(this Component component) { return component.gameObject.GetAsyncMouseUpTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncMouseUpTrigger : AsyncTriggerBase { void OnMouseUp() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnMouseUpHandler GetOnMouseUpAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnMouseUpHandler GetOnMouseUpAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnMouseUpAsync() { return ((IAsyncOnMouseUpHandler)new AsyncTriggerHandler(this, true)).OnMouseUpAsync(); } public UniTask OnMouseUpAsync(CancellationToken cancellationToken) { return ((IAsyncOnMouseUpHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnMouseUpAsync(); } } #endif #endregion #region MouseUpAsButton #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) public interface IAsyncOnMouseUpAsButtonHandler { UniTask OnMouseUpAsButtonAsync(); } public partial class AsyncTriggerHandler : IAsyncOnMouseUpAsButtonHandler { UniTask IAsyncOnMouseUpAsButtonHandler.OnMouseUpAsButtonAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncMouseUpAsButtonTrigger GetAsyncMouseUpAsButtonTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncMouseUpAsButtonTrigger GetAsyncMouseUpAsButtonTrigger(this Component component) { return component.gameObject.GetAsyncMouseUpAsButtonTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncMouseUpAsButtonTrigger : AsyncTriggerBase { void OnMouseUpAsButton() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnMouseUpAsButtonHandler GetOnMouseUpAsButtonAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnMouseUpAsButtonHandler GetOnMouseUpAsButtonAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnMouseUpAsButtonAsync() { return ((IAsyncOnMouseUpAsButtonHandler)new AsyncTriggerHandler(this, true)).OnMouseUpAsButtonAsync(); } public UniTask OnMouseUpAsButtonAsync(CancellationToken cancellationToken) { return ((IAsyncOnMouseUpAsButtonHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnMouseUpAsButtonAsync(); } } #endif #endregion #region ParticleCollision public interface IAsyncOnParticleCollisionHandler { UniTask OnParticleCollisionAsync(); } public partial class AsyncTriggerHandler : IAsyncOnParticleCollisionHandler { UniTask IAsyncOnParticleCollisionHandler.OnParticleCollisionAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncParticleCollisionTrigger GetAsyncParticleCollisionTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncParticleCollisionTrigger GetAsyncParticleCollisionTrigger(this Component component) { return component.gameObject.GetAsyncParticleCollisionTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncParticleCollisionTrigger : AsyncTriggerBase { void OnParticleCollision(GameObject other) { RaiseEvent((other)); } public IAsyncOnParticleCollisionHandler GetOnParticleCollisionAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnParticleCollisionHandler GetOnParticleCollisionAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnParticleCollisionAsync() { return ((IAsyncOnParticleCollisionHandler)new AsyncTriggerHandler(this, true)).OnParticleCollisionAsync(); } public UniTask OnParticleCollisionAsync(CancellationToken cancellationToken) { return ((IAsyncOnParticleCollisionHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnParticleCollisionAsync(); } } #endregion #region ParticleSystemStopped public interface IAsyncOnParticleSystemStoppedHandler { UniTask OnParticleSystemStoppedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnParticleSystemStoppedHandler { UniTask IAsyncOnParticleSystemStoppedHandler.OnParticleSystemStoppedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncParticleSystemStoppedTrigger GetAsyncParticleSystemStoppedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncParticleSystemStoppedTrigger GetAsyncParticleSystemStoppedTrigger(this Component component) { return component.gameObject.GetAsyncParticleSystemStoppedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncParticleSystemStoppedTrigger : AsyncTriggerBase { void OnParticleSystemStopped() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnParticleSystemStoppedHandler GetOnParticleSystemStoppedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnParticleSystemStoppedHandler GetOnParticleSystemStoppedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnParticleSystemStoppedAsync() { return ((IAsyncOnParticleSystemStoppedHandler)new AsyncTriggerHandler(this, true)).OnParticleSystemStoppedAsync(); } public UniTask OnParticleSystemStoppedAsync(CancellationToken cancellationToken) { return ((IAsyncOnParticleSystemStoppedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnParticleSystemStoppedAsync(); } } #endregion #region ParticleTrigger public interface IAsyncOnParticleTriggerHandler { UniTask OnParticleTriggerAsync(); } public partial class AsyncTriggerHandler : IAsyncOnParticleTriggerHandler { UniTask IAsyncOnParticleTriggerHandler.OnParticleTriggerAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncParticleTriggerTrigger GetAsyncParticleTriggerTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncParticleTriggerTrigger GetAsyncParticleTriggerTrigger(this Component component) { return component.gameObject.GetAsyncParticleTriggerTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncParticleTriggerTrigger : AsyncTriggerBase { void OnParticleTrigger() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnParticleTriggerHandler GetOnParticleTriggerAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnParticleTriggerHandler GetOnParticleTriggerAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnParticleTriggerAsync() { return ((IAsyncOnParticleTriggerHandler)new AsyncTriggerHandler(this, true)).OnParticleTriggerAsync(); } public UniTask OnParticleTriggerAsync(CancellationToken cancellationToken) { return ((IAsyncOnParticleTriggerHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnParticleTriggerAsync(); } } #endregion #region ParticleUpdateJobScheduled #if UNITY_2019_3_OR_NEWER && (!UNITY_2019_1_OR_NEWER || UNITASK_PARTICLESYSTEM_SUPPORT) public interface IAsyncOnParticleUpdateJobScheduledHandler { UniTask OnParticleUpdateJobScheduledAsync(); } public partial class AsyncTriggerHandler : IAsyncOnParticleUpdateJobScheduledHandler { UniTask IAsyncOnParticleUpdateJobScheduledHandler.OnParticleUpdateJobScheduledAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncParticleUpdateJobScheduledTrigger GetAsyncParticleUpdateJobScheduledTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncParticleUpdateJobScheduledTrigger GetAsyncParticleUpdateJobScheduledTrigger(this Component component) { return component.gameObject.GetAsyncParticleUpdateJobScheduledTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncParticleUpdateJobScheduledTrigger : AsyncTriggerBase { void OnParticleUpdateJobScheduled(UnityEngine.ParticleSystemJobs.ParticleSystemJobData particles) { RaiseEvent((particles)); } public IAsyncOnParticleUpdateJobScheduledHandler GetOnParticleUpdateJobScheduledAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnParticleUpdateJobScheduledHandler GetOnParticleUpdateJobScheduledAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnParticleUpdateJobScheduledAsync() { return ((IAsyncOnParticleUpdateJobScheduledHandler)new AsyncTriggerHandler(this, true)).OnParticleUpdateJobScheduledAsync(); } public UniTask OnParticleUpdateJobScheduledAsync(CancellationToken cancellationToken) { return ((IAsyncOnParticleUpdateJobScheduledHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnParticleUpdateJobScheduledAsync(); } } #endif #endregion #region PostRender public interface IAsyncOnPostRenderHandler { UniTask OnPostRenderAsync(); } public partial class AsyncTriggerHandler : IAsyncOnPostRenderHandler { UniTask IAsyncOnPostRenderHandler.OnPostRenderAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncPostRenderTrigger GetAsyncPostRenderTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncPostRenderTrigger GetAsyncPostRenderTrigger(this Component component) { return component.gameObject.GetAsyncPostRenderTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncPostRenderTrigger : AsyncTriggerBase { void OnPostRender() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnPostRenderHandler GetOnPostRenderAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnPostRenderHandler GetOnPostRenderAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnPostRenderAsync() { return ((IAsyncOnPostRenderHandler)new AsyncTriggerHandler(this, true)).OnPostRenderAsync(); } public UniTask OnPostRenderAsync(CancellationToken cancellationToken) { return ((IAsyncOnPostRenderHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnPostRenderAsync(); } } #endregion #region PreCull public interface IAsyncOnPreCullHandler { UniTask OnPreCullAsync(); } public partial class AsyncTriggerHandler : IAsyncOnPreCullHandler { UniTask IAsyncOnPreCullHandler.OnPreCullAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncPreCullTrigger GetAsyncPreCullTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncPreCullTrigger GetAsyncPreCullTrigger(this Component component) { return component.gameObject.GetAsyncPreCullTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncPreCullTrigger : AsyncTriggerBase { void OnPreCull() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnPreCullHandler GetOnPreCullAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnPreCullHandler GetOnPreCullAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnPreCullAsync() { return ((IAsyncOnPreCullHandler)new AsyncTriggerHandler(this, true)).OnPreCullAsync(); } public UniTask OnPreCullAsync(CancellationToken cancellationToken) { return ((IAsyncOnPreCullHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnPreCullAsync(); } } #endregion #region PreRender public interface IAsyncOnPreRenderHandler { UniTask OnPreRenderAsync(); } public partial class AsyncTriggerHandler : IAsyncOnPreRenderHandler { UniTask IAsyncOnPreRenderHandler.OnPreRenderAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncPreRenderTrigger GetAsyncPreRenderTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncPreRenderTrigger GetAsyncPreRenderTrigger(this Component component) { return component.gameObject.GetAsyncPreRenderTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncPreRenderTrigger : AsyncTriggerBase { void OnPreRender() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnPreRenderHandler GetOnPreRenderAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnPreRenderHandler GetOnPreRenderAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnPreRenderAsync() { return ((IAsyncOnPreRenderHandler)new AsyncTriggerHandler(this, true)).OnPreRenderAsync(); } public UniTask OnPreRenderAsync(CancellationToken cancellationToken) { return ((IAsyncOnPreRenderHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnPreRenderAsync(); } } #endregion #region RectTransformDimensionsChange public interface IAsyncOnRectTransformDimensionsChangeHandler { UniTask OnRectTransformDimensionsChangeAsync(); } public partial class AsyncTriggerHandler : IAsyncOnRectTransformDimensionsChangeHandler { UniTask IAsyncOnRectTransformDimensionsChangeHandler.OnRectTransformDimensionsChangeAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncRectTransformDimensionsChangeTrigger GetAsyncRectTransformDimensionsChangeTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncRectTransformDimensionsChangeTrigger GetAsyncRectTransformDimensionsChangeTrigger(this Component component) { return component.gameObject.GetAsyncRectTransformDimensionsChangeTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncRectTransformDimensionsChangeTrigger : AsyncTriggerBase { void OnRectTransformDimensionsChange() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnRectTransformDimensionsChangeHandler GetOnRectTransformDimensionsChangeAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnRectTransformDimensionsChangeHandler GetOnRectTransformDimensionsChangeAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnRectTransformDimensionsChangeAsync() { return ((IAsyncOnRectTransformDimensionsChangeHandler)new AsyncTriggerHandler(this, true)).OnRectTransformDimensionsChangeAsync(); } public UniTask OnRectTransformDimensionsChangeAsync(CancellationToken cancellationToken) { return ((IAsyncOnRectTransformDimensionsChangeHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnRectTransformDimensionsChangeAsync(); } } #endregion #region RectTransformRemoved public interface IAsyncOnRectTransformRemovedHandler { UniTask OnRectTransformRemovedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnRectTransformRemovedHandler { UniTask IAsyncOnRectTransformRemovedHandler.OnRectTransformRemovedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncRectTransformRemovedTrigger GetAsyncRectTransformRemovedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncRectTransformRemovedTrigger GetAsyncRectTransformRemovedTrigger(this Component component) { return component.gameObject.GetAsyncRectTransformRemovedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncRectTransformRemovedTrigger : AsyncTriggerBase { void OnRectTransformRemoved() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnRectTransformRemovedHandler GetOnRectTransformRemovedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnRectTransformRemovedHandler GetOnRectTransformRemovedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnRectTransformRemovedAsync() { return ((IAsyncOnRectTransformRemovedHandler)new AsyncTriggerHandler(this, true)).OnRectTransformRemovedAsync(); } public UniTask OnRectTransformRemovedAsync(CancellationToken cancellationToken) { return ((IAsyncOnRectTransformRemovedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnRectTransformRemovedAsync(); } } #endregion #region RenderImage public interface IAsyncOnRenderImageHandler { UniTask<(RenderTexture source, RenderTexture destination)> OnRenderImageAsync(); } public partial class AsyncTriggerHandler : IAsyncOnRenderImageHandler { UniTask<(RenderTexture source, RenderTexture destination)> IAsyncOnRenderImageHandler.OnRenderImageAsync() { core.Reset(); return new UniTask<(RenderTexture source, RenderTexture destination)>((IUniTaskSource<(RenderTexture source, RenderTexture destination)>)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncRenderImageTrigger GetAsyncRenderImageTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncRenderImageTrigger GetAsyncRenderImageTrigger(this Component component) { return component.gameObject.GetAsyncRenderImageTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncRenderImageTrigger : AsyncTriggerBase<(RenderTexture source, RenderTexture destination)> { void OnRenderImage(RenderTexture source, RenderTexture destination) { RaiseEvent((source, destination)); } public IAsyncOnRenderImageHandler GetOnRenderImageAsyncHandler() { return new AsyncTriggerHandler<(RenderTexture source, RenderTexture destination)>(this, false); } public IAsyncOnRenderImageHandler GetOnRenderImageAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler<(RenderTexture source, RenderTexture destination)>(this, cancellationToken, false); } public UniTask<(RenderTexture source, RenderTexture destination)> OnRenderImageAsync() { return ((IAsyncOnRenderImageHandler)new AsyncTriggerHandler<(RenderTexture source, RenderTexture destination)>(this, true)).OnRenderImageAsync(); } public UniTask<(RenderTexture source, RenderTexture destination)> OnRenderImageAsync(CancellationToken cancellationToken) { return ((IAsyncOnRenderImageHandler)new AsyncTriggerHandler<(RenderTexture source, RenderTexture destination)>(this, cancellationToken, true)).OnRenderImageAsync(); } } #endregion #region RenderObject public interface IAsyncOnRenderObjectHandler { UniTask OnRenderObjectAsync(); } public partial class AsyncTriggerHandler : IAsyncOnRenderObjectHandler { UniTask IAsyncOnRenderObjectHandler.OnRenderObjectAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncRenderObjectTrigger GetAsyncRenderObjectTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncRenderObjectTrigger GetAsyncRenderObjectTrigger(this Component component) { return component.gameObject.GetAsyncRenderObjectTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncRenderObjectTrigger : AsyncTriggerBase { void OnRenderObject() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnRenderObjectHandler GetOnRenderObjectAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnRenderObjectHandler GetOnRenderObjectAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnRenderObjectAsync() { return ((IAsyncOnRenderObjectHandler)new AsyncTriggerHandler(this, true)).OnRenderObjectAsync(); } public UniTask OnRenderObjectAsync(CancellationToken cancellationToken) { return ((IAsyncOnRenderObjectHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnRenderObjectAsync(); } } #endregion #region ServerInitialized public interface IAsyncOnServerInitializedHandler { UniTask OnServerInitializedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnServerInitializedHandler { UniTask IAsyncOnServerInitializedHandler.OnServerInitializedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncServerInitializedTrigger GetAsyncServerInitializedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncServerInitializedTrigger GetAsyncServerInitializedTrigger(this Component component) { return component.gameObject.GetAsyncServerInitializedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncServerInitializedTrigger : AsyncTriggerBase { void OnServerInitialized() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnServerInitializedHandler GetOnServerInitializedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnServerInitializedHandler GetOnServerInitializedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnServerInitializedAsync() { return ((IAsyncOnServerInitializedHandler)new AsyncTriggerHandler(this, true)).OnServerInitializedAsync(); } public UniTask OnServerInitializedAsync(CancellationToken cancellationToken) { return ((IAsyncOnServerInitializedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnServerInitializedAsync(); } } #endregion #region TransformChildrenChanged public interface IAsyncOnTransformChildrenChangedHandler { UniTask OnTransformChildrenChangedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnTransformChildrenChangedHandler { UniTask IAsyncOnTransformChildrenChangedHandler.OnTransformChildrenChangedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncTransformChildrenChangedTrigger GetAsyncTransformChildrenChangedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncTransformChildrenChangedTrigger GetAsyncTransformChildrenChangedTrigger(this Component component) { return component.gameObject.GetAsyncTransformChildrenChangedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncTransformChildrenChangedTrigger : AsyncTriggerBase { void OnTransformChildrenChanged() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnTransformChildrenChangedHandler GetOnTransformChildrenChangedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnTransformChildrenChangedHandler GetOnTransformChildrenChangedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnTransformChildrenChangedAsync() { return ((IAsyncOnTransformChildrenChangedHandler)new AsyncTriggerHandler(this, true)).OnTransformChildrenChangedAsync(); } public UniTask OnTransformChildrenChangedAsync(CancellationToken cancellationToken) { return ((IAsyncOnTransformChildrenChangedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnTransformChildrenChangedAsync(); } } #endregion #region TransformParentChanged public interface IAsyncOnTransformParentChangedHandler { UniTask OnTransformParentChangedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnTransformParentChangedHandler { UniTask IAsyncOnTransformParentChangedHandler.OnTransformParentChangedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncTransformParentChangedTrigger GetAsyncTransformParentChangedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncTransformParentChangedTrigger GetAsyncTransformParentChangedTrigger(this Component component) { return component.gameObject.GetAsyncTransformParentChangedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncTransformParentChangedTrigger : AsyncTriggerBase { void OnTransformParentChanged() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnTransformParentChangedHandler GetOnTransformParentChangedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnTransformParentChangedHandler GetOnTransformParentChangedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnTransformParentChangedAsync() { return ((IAsyncOnTransformParentChangedHandler)new AsyncTriggerHandler(this, true)).OnTransformParentChangedAsync(); } public UniTask OnTransformParentChangedAsync(CancellationToken cancellationToken) { return ((IAsyncOnTransformParentChangedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnTransformParentChangedAsync(); } } #endregion #region TriggerEnter #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT public interface IAsyncOnTriggerEnterHandler { UniTask OnTriggerEnterAsync(); } public partial class AsyncTriggerHandler : IAsyncOnTriggerEnterHandler { UniTask IAsyncOnTriggerEnterHandler.OnTriggerEnterAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncTriggerEnterTrigger GetAsyncTriggerEnterTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncTriggerEnterTrigger GetAsyncTriggerEnterTrigger(this Component component) { return component.gameObject.GetAsyncTriggerEnterTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncTriggerEnterTrigger : AsyncTriggerBase { void OnTriggerEnter(Collider other) { RaiseEvent((other)); } public IAsyncOnTriggerEnterHandler GetOnTriggerEnterAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnTriggerEnterHandler GetOnTriggerEnterAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnTriggerEnterAsync() { return ((IAsyncOnTriggerEnterHandler)new AsyncTriggerHandler(this, true)).OnTriggerEnterAsync(); } public UniTask OnTriggerEnterAsync(CancellationToken cancellationToken) { return ((IAsyncOnTriggerEnterHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnTriggerEnterAsync(); } } #endif #endregion #region TriggerEnter2D #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT public interface IAsyncOnTriggerEnter2DHandler { UniTask OnTriggerEnter2DAsync(); } public partial class AsyncTriggerHandler : IAsyncOnTriggerEnter2DHandler { UniTask IAsyncOnTriggerEnter2DHandler.OnTriggerEnter2DAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncTriggerEnter2DTrigger GetAsyncTriggerEnter2DTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncTriggerEnter2DTrigger GetAsyncTriggerEnter2DTrigger(this Component component) { return component.gameObject.GetAsyncTriggerEnter2DTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncTriggerEnter2DTrigger : AsyncTriggerBase { void OnTriggerEnter2D(Collider2D other) { RaiseEvent((other)); } public IAsyncOnTriggerEnter2DHandler GetOnTriggerEnter2DAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnTriggerEnter2DHandler GetOnTriggerEnter2DAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnTriggerEnter2DAsync() { return ((IAsyncOnTriggerEnter2DHandler)new AsyncTriggerHandler(this, true)).OnTriggerEnter2DAsync(); } public UniTask OnTriggerEnter2DAsync(CancellationToken cancellationToken) { return ((IAsyncOnTriggerEnter2DHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnTriggerEnter2DAsync(); } } #endif #endregion #region TriggerExit #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT public interface IAsyncOnTriggerExitHandler { UniTask OnTriggerExitAsync(); } public partial class AsyncTriggerHandler : IAsyncOnTriggerExitHandler { UniTask IAsyncOnTriggerExitHandler.OnTriggerExitAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncTriggerExitTrigger GetAsyncTriggerExitTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncTriggerExitTrigger GetAsyncTriggerExitTrigger(this Component component) { return component.gameObject.GetAsyncTriggerExitTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncTriggerExitTrigger : AsyncTriggerBase { void OnTriggerExit(Collider other) { RaiseEvent((other)); } public IAsyncOnTriggerExitHandler GetOnTriggerExitAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnTriggerExitHandler GetOnTriggerExitAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnTriggerExitAsync() { return ((IAsyncOnTriggerExitHandler)new AsyncTriggerHandler(this, true)).OnTriggerExitAsync(); } public UniTask OnTriggerExitAsync(CancellationToken cancellationToken) { return ((IAsyncOnTriggerExitHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnTriggerExitAsync(); } } #endif #endregion #region TriggerExit2D #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT public interface IAsyncOnTriggerExit2DHandler { UniTask OnTriggerExit2DAsync(); } public partial class AsyncTriggerHandler : IAsyncOnTriggerExit2DHandler { UniTask IAsyncOnTriggerExit2DHandler.OnTriggerExit2DAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncTriggerExit2DTrigger GetAsyncTriggerExit2DTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncTriggerExit2DTrigger GetAsyncTriggerExit2DTrigger(this Component component) { return component.gameObject.GetAsyncTriggerExit2DTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncTriggerExit2DTrigger : AsyncTriggerBase { void OnTriggerExit2D(Collider2D other) { RaiseEvent((other)); } public IAsyncOnTriggerExit2DHandler GetOnTriggerExit2DAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnTriggerExit2DHandler GetOnTriggerExit2DAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnTriggerExit2DAsync() { return ((IAsyncOnTriggerExit2DHandler)new AsyncTriggerHandler(this, true)).OnTriggerExit2DAsync(); } public UniTask OnTriggerExit2DAsync(CancellationToken cancellationToken) { return ((IAsyncOnTriggerExit2DHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnTriggerExit2DAsync(); } } #endif #endregion #region TriggerStay #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS_SUPPORT public interface IAsyncOnTriggerStayHandler { UniTask OnTriggerStayAsync(); } public partial class AsyncTriggerHandler : IAsyncOnTriggerStayHandler { UniTask IAsyncOnTriggerStayHandler.OnTriggerStayAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncTriggerStayTrigger GetAsyncTriggerStayTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncTriggerStayTrigger GetAsyncTriggerStayTrigger(this Component component) { return component.gameObject.GetAsyncTriggerStayTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncTriggerStayTrigger : AsyncTriggerBase { void OnTriggerStay(Collider other) { RaiseEvent((other)); } public IAsyncOnTriggerStayHandler GetOnTriggerStayAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnTriggerStayHandler GetOnTriggerStayAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnTriggerStayAsync() { return ((IAsyncOnTriggerStayHandler)new AsyncTriggerHandler(this, true)).OnTriggerStayAsync(); } public UniTask OnTriggerStayAsync(CancellationToken cancellationToken) { return ((IAsyncOnTriggerStayHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnTriggerStayAsync(); } } #endif #endregion #region TriggerStay2D #if !UNITY_2019_1_OR_NEWER || UNITASK_PHYSICS2D_SUPPORT public interface IAsyncOnTriggerStay2DHandler { UniTask OnTriggerStay2DAsync(); } public partial class AsyncTriggerHandler : IAsyncOnTriggerStay2DHandler { UniTask IAsyncOnTriggerStay2DHandler.OnTriggerStay2DAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncTriggerStay2DTrigger GetAsyncTriggerStay2DTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncTriggerStay2DTrigger GetAsyncTriggerStay2DTrigger(this Component component) { return component.gameObject.GetAsyncTriggerStay2DTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncTriggerStay2DTrigger : AsyncTriggerBase { void OnTriggerStay2D(Collider2D other) { RaiseEvent((other)); } public IAsyncOnTriggerStay2DHandler GetOnTriggerStay2DAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnTriggerStay2DHandler GetOnTriggerStay2DAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnTriggerStay2DAsync() { return ((IAsyncOnTriggerStay2DHandler)new AsyncTriggerHandler(this, true)).OnTriggerStay2DAsync(); } public UniTask OnTriggerStay2DAsync(CancellationToken cancellationToken) { return ((IAsyncOnTriggerStay2DHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnTriggerStay2DAsync(); } } #endif #endregion #region Validate public interface IAsyncOnValidateHandler { UniTask OnValidateAsync(); } public partial class AsyncTriggerHandler : IAsyncOnValidateHandler { UniTask IAsyncOnValidateHandler.OnValidateAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncValidateTrigger GetAsyncValidateTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncValidateTrigger GetAsyncValidateTrigger(this Component component) { return component.gameObject.GetAsyncValidateTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncValidateTrigger : AsyncTriggerBase { void OnValidate() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnValidateHandler GetOnValidateAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnValidateHandler GetOnValidateAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnValidateAsync() { return ((IAsyncOnValidateHandler)new AsyncTriggerHandler(this, true)).OnValidateAsync(); } public UniTask OnValidateAsync(CancellationToken cancellationToken) { return ((IAsyncOnValidateHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnValidateAsync(); } } #endregion #region WillRenderObject public interface IAsyncOnWillRenderObjectHandler { UniTask OnWillRenderObjectAsync(); } public partial class AsyncTriggerHandler : IAsyncOnWillRenderObjectHandler { UniTask IAsyncOnWillRenderObjectHandler.OnWillRenderObjectAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncWillRenderObjectTrigger GetAsyncWillRenderObjectTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncWillRenderObjectTrigger GetAsyncWillRenderObjectTrigger(this Component component) { return component.gameObject.GetAsyncWillRenderObjectTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncWillRenderObjectTrigger : AsyncTriggerBase { void OnWillRenderObject() { RaiseEvent(AsyncUnit.Default); } public IAsyncOnWillRenderObjectHandler GetOnWillRenderObjectAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnWillRenderObjectHandler GetOnWillRenderObjectAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnWillRenderObjectAsync() { return ((IAsyncOnWillRenderObjectHandler)new AsyncTriggerHandler(this, true)).OnWillRenderObjectAsync(); } public UniTask OnWillRenderObjectAsync(CancellationToken cancellationToken) { return ((IAsyncOnWillRenderObjectHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnWillRenderObjectAsync(); } } #endregion #region Reset public interface IAsyncResetHandler { UniTask ResetAsync(); } public partial class AsyncTriggerHandler : IAsyncResetHandler { UniTask IAsyncResetHandler.ResetAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncResetTrigger GetAsyncResetTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncResetTrigger GetAsyncResetTrigger(this Component component) { return component.gameObject.GetAsyncResetTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncResetTrigger : AsyncTriggerBase { void Reset() { RaiseEvent(AsyncUnit.Default); } public IAsyncResetHandler GetResetAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncResetHandler GetResetAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask ResetAsync() { return ((IAsyncResetHandler)new AsyncTriggerHandler(this, true)).ResetAsync(); } public UniTask ResetAsync(CancellationToken cancellationToken) { return ((IAsyncResetHandler)new AsyncTriggerHandler(this, cancellationToken, true)).ResetAsync(); } } #endregion #region Update public interface IAsyncUpdateHandler { UniTask UpdateAsync(); } public partial class AsyncTriggerHandler : IAsyncUpdateHandler { UniTask IAsyncUpdateHandler.UpdateAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncUpdateTrigger GetAsyncUpdateTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncUpdateTrigger GetAsyncUpdateTrigger(this Component component) { return component.gameObject.GetAsyncUpdateTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncUpdateTrigger : AsyncTriggerBase { void Update() { RaiseEvent(AsyncUnit.Default); } public IAsyncUpdateHandler GetUpdateAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncUpdateHandler GetUpdateAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask UpdateAsync() { return ((IAsyncUpdateHandler)new AsyncTriggerHandler(this, true)).UpdateAsync(); } public UniTask UpdateAsync(CancellationToken cancellationToken) { return ((IAsyncUpdateHandler)new AsyncTriggerHandler(this, cancellationToken, true)).UpdateAsync(); } } #endregion #region BeginDrag #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnBeginDragHandler { UniTask OnBeginDragAsync(); } public partial class AsyncTriggerHandler : IAsyncOnBeginDragHandler { UniTask IAsyncOnBeginDragHandler.OnBeginDragAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncBeginDragTrigger GetAsyncBeginDragTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncBeginDragTrigger GetAsyncBeginDragTrigger(this Component component) { return component.gameObject.GetAsyncBeginDragTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncBeginDragTrigger : AsyncTriggerBase, IBeginDragHandler { void IBeginDragHandler.OnBeginDrag(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnBeginDragHandler GetOnBeginDragAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnBeginDragHandler GetOnBeginDragAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnBeginDragAsync() { return ((IAsyncOnBeginDragHandler)new AsyncTriggerHandler(this, true)).OnBeginDragAsync(); } public UniTask OnBeginDragAsync(CancellationToken cancellationToken) { return ((IAsyncOnBeginDragHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnBeginDragAsync(); } } #endif #endregion #region Cancel #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnCancelHandler { UniTask OnCancelAsync(); } public partial class AsyncTriggerHandler : IAsyncOnCancelHandler { UniTask IAsyncOnCancelHandler.OnCancelAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncCancelTrigger GetAsyncCancelTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncCancelTrigger GetAsyncCancelTrigger(this Component component) { return component.gameObject.GetAsyncCancelTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncCancelTrigger : AsyncTriggerBase, ICancelHandler { void ICancelHandler.OnCancel(BaseEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnCancelHandler GetOnCancelAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnCancelHandler GetOnCancelAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnCancelAsync() { return ((IAsyncOnCancelHandler)new AsyncTriggerHandler(this, true)).OnCancelAsync(); } public UniTask OnCancelAsync(CancellationToken cancellationToken) { return ((IAsyncOnCancelHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnCancelAsync(); } } #endif #endregion #region Deselect #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnDeselectHandler { UniTask OnDeselectAsync(); } public partial class AsyncTriggerHandler : IAsyncOnDeselectHandler { UniTask IAsyncOnDeselectHandler.OnDeselectAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncDeselectTrigger GetAsyncDeselectTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncDeselectTrigger GetAsyncDeselectTrigger(this Component component) { return component.gameObject.GetAsyncDeselectTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncDeselectTrigger : AsyncTriggerBase, IDeselectHandler { void IDeselectHandler.OnDeselect(BaseEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnDeselectHandler GetOnDeselectAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnDeselectHandler GetOnDeselectAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnDeselectAsync() { return ((IAsyncOnDeselectHandler)new AsyncTriggerHandler(this, true)).OnDeselectAsync(); } public UniTask OnDeselectAsync(CancellationToken cancellationToken) { return ((IAsyncOnDeselectHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnDeselectAsync(); } } #endif #endregion #region Drag #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnDragHandler { UniTask OnDragAsync(); } public partial class AsyncTriggerHandler : IAsyncOnDragHandler { UniTask IAsyncOnDragHandler.OnDragAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncDragTrigger GetAsyncDragTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncDragTrigger GetAsyncDragTrigger(this Component component) { return component.gameObject.GetAsyncDragTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncDragTrigger : AsyncTriggerBase, IDragHandler { void IDragHandler.OnDrag(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnDragHandler GetOnDragAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnDragHandler GetOnDragAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnDragAsync() { return ((IAsyncOnDragHandler)new AsyncTriggerHandler(this, true)).OnDragAsync(); } public UniTask OnDragAsync(CancellationToken cancellationToken) { return ((IAsyncOnDragHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnDragAsync(); } } #endif #endregion #region Drop #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnDropHandler { UniTask OnDropAsync(); } public partial class AsyncTriggerHandler : IAsyncOnDropHandler { UniTask IAsyncOnDropHandler.OnDropAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncDropTrigger GetAsyncDropTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncDropTrigger GetAsyncDropTrigger(this Component component) { return component.gameObject.GetAsyncDropTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncDropTrigger : AsyncTriggerBase, IDropHandler { void IDropHandler.OnDrop(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnDropHandler GetOnDropAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnDropHandler GetOnDropAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnDropAsync() { return ((IAsyncOnDropHandler)new AsyncTriggerHandler(this, true)).OnDropAsync(); } public UniTask OnDropAsync(CancellationToken cancellationToken) { return ((IAsyncOnDropHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnDropAsync(); } } #endif #endregion #region EndDrag #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnEndDragHandler { UniTask OnEndDragAsync(); } public partial class AsyncTriggerHandler : IAsyncOnEndDragHandler { UniTask IAsyncOnEndDragHandler.OnEndDragAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncEndDragTrigger GetAsyncEndDragTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncEndDragTrigger GetAsyncEndDragTrigger(this Component component) { return component.gameObject.GetAsyncEndDragTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncEndDragTrigger : AsyncTriggerBase, IEndDragHandler { void IEndDragHandler.OnEndDrag(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnEndDragHandler GetOnEndDragAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnEndDragHandler GetOnEndDragAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnEndDragAsync() { return ((IAsyncOnEndDragHandler)new AsyncTriggerHandler(this, true)).OnEndDragAsync(); } public UniTask OnEndDragAsync(CancellationToken cancellationToken) { return ((IAsyncOnEndDragHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnEndDragAsync(); } } #endif #endregion #region InitializePotentialDrag #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnInitializePotentialDragHandler { UniTask OnInitializePotentialDragAsync(); } public partial class AsyncTriggerHandler : IAsyncOnInitializePotentialDragHandler { UniTask IAsyncOnInitializePotentialDragHandler.OnInitializePotentialDragAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncInitializePotentialDragTrigger GetAsyncInitializePotentialDragTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncInitializePotentialDragTrigger GetAsyncInitializePotentialDragTrigger(this Component component) { return component.gameObject.GetAsyncInitializePotentialDragTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncInitializePotentialDragTrigger : AsyncTriggerBase, IInitializePotentialDragHandler { void IInitializePotentialDragHandler.OnInitializePotentialDrag(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnInitializePotentialDragHandler GetOnInitializePotentialDragAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnInitializePotentialDragHandler GetOnInitializePotentialDragAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnInitializePotentialDragAsync() { return ((IAsyncOnInitializePotentialDragHandler)new AsyncTriggerHandler(this, true)).OnInitializePotentialDragAsync(); } public UniTask OnInitializePotentialDragAsync(CancellationToken cancellationToken) { return ((IAsyncOnInitializePotentialDragHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnInitializePotentialDragAsync(); } } #endif #endregion #region Move #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnMoveHandler { UniTask OnMoveAsync(); } public partial class AsyncTriggerHandler : IAsyncOnMoveHandler { UniTask IAsyncOnMoveHandler.OnMoveAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncMoveTrigger GetAsyncMoveTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncMoveTrigger GetAsyncMoveTrigger(this Component component) { return component.gameObject.GetAsyncMoveTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncMoveTrigger : AsyncTriggerBase, IMoveHandler { void IMoveHandler.OnMove(AxisEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnMoveHandler GetOnMoveAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnMoveHandler GetOnMoveAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnMoveAsync() { return ((IAsyncOnMoveHandler)new AsyncTriggerHandler(this, true)).OnMoveAsync(); } public UniTask OnMoveAsync(CancellationToken cancellationToken) { return ((IAsyncOnMoveHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnMoveAsync(); } } #endif #endregion #region PointerClick #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnPointerClickHandler { UniTask OnPointerClickAsync(); } public partial class AsyncTriggerHandler : IAsyncOnPointerClickHandler { UniTask IAsyncOnPointerClickHandler.OnPointerClickAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncPointerClickTrigger GetAsyncPointerClickTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncPointerClickTrigger GetAsyncPointerClickTrigger(this Component component) { return component.gameObject.GetAsyncPointerClickTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncPointerClickTrigger : AsyncTriggerBase, IPointerClickHandler { void IPointerClickHandler.OnPointerClick(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnPointerClickHandler GetOnPointerClickAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnPointerClickHandler GetOnPointerClickAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnPointerClickAsync() { return ((IAsyncOnPointerClickHandler)new AsyncTriggerHandler(this, true)).OnPointerClickAsync(); } public UniTask OnPointerClickAsync(CancellationToken cancellationToken) { return ((IAsyncOnPointerClickHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnPointerClickAsync(); } } #endif #endregion #region PointerDown #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnPointerDownHandler { UniTask OnPointerDownAsync(); } public partial class AsyncTriggerHandler : IAsyncOnPointerDownHandler { UniTask IAsyncOnPointerDownHandler.OnPointerDownAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncPointerDownTrigger GetAsyncPointerDownTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncPointerDownTrigger GetAsyncPointerDownTrigger(this Component component) { return component.gameObject.GetAsyncPointerDownTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncPointerDownTrigger : AsyncTriggerBase, IPointerDownHandler { void IPointerDownHandler.OnPointerDown(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnPointerDownHandler GetOnPointerDownAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnPointerDownHandler GetOnPointerDownAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnPointerDownAsync() { return ((IAsyncOnPointerDownHandler)new AsyncTriggerHandler(this, true)).OnPointerDownAsync(); } public UniTask OnPointerDownAsync(CancellationToken cancellationToken) { return ((IAsyncOnPointerDownHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnPointerDownAsync(); } } #endif #endregion #region PointerEnter #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnPointerEnterHandler { UniTask OnPointerEnterAsync(); } public partial class AsyncTriggerHandler : IAsyncOnPointerEnterHandler { UniTask IAsyncOnPointerEnterHandler.OnPointerEnterAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncPointerEnterTrigger GetAsyncPointerEnterTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncPointerEnterTrigger GetAsyncPointerEnterTrigger(this Component component) { return component.gameObject.GetAsyncPointerEnterTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncPointerEnterTrigger : AsyncTriggerBase, IPointerEnterHandler { void IPointerEnterHandler.OnPointerEnter(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnPointerEnterHandler GetOnPointerEnterAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnPointerEnterHandler GetOnPointerEnterAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnPointerEnterAsync() { return ((IAsyncOnPointerEnterHandler)new AsyncTriggerHandler(this, true)).OnPointerEnterAsync(); } public UniTask OnPointerEnterAsync(CancellationToken cancellationToken) { return ((IAsyncOnPointerEnterHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnPointerEnterAsync(); } } #endif #endregion #region PointerExit #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnPointerExitHandler { UniTask OnPointerExitAsync(); } public partial class AsyncTriggerHandler : IAsyncOnPointerExitHandler { UniTask IAsyncOnPointerExitHandler.OnPointerExitAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncPointerExitTrigger GetAsyncPointerExitTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncPointerExitTrigger GetAsyncPointerExitTrigger(this Component component) { return component.gameObject.GetAsyncPointerExitTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncPointerExitTrigger : AsyncTriggerBase, IPointerExitHandler { void IPointerExitHandler.OnPointerExit(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnPointerExitHandler GetOnPointerExitAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnPointerExitHandler GetOnPointerExitAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnPointerExitAsync() { return ((IAsyncOnPointerExitHandler)new AsyncTriggerHandler(this, true)).OnPointerExitAsync(); } public UniTask OnPointerExitAsync(CancellationToken cancellationToken) { return ((IAsyncOnPointerExitHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnPointerExitAsync(); } } #endif #endregion #region PointerUp #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnPointerUpHandler { UniTask OnPointerUpAsync(); } public partial class AsyncTriggerHandler : IAsyncOnPointerUpHandler { UniTask IAsyncOnPointerUpHandler.OnPointerUpAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncPointerUpTrigger GetAsyncPointerUpTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncPointerUpTrigger GetAsyncPointerUpTrigger(this Component component) { return component.gameObject.GetAsyncPointerUpTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncPointerUpTrigger : AsyncTriggerBase, IPointerUpHandler { void IPointerUpHandler.OnPointerUp(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnPointerUpHandler GetOnPointerUpAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnPointerUpHandler GetOnPointerUpAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnPointerUpAsync() { return ((IAsyncOnPointerUpHandler)new AsyncTriggerHandler(this, true)).OnPointerUpAsync(); } public UniTask OnPointerUpAsync(CancellationToken cancellationToken) { return ((IAsyncOnPointerUpHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnPointerUpAsync(); } } #endif #endregion #region Scroll #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnScrollHandler { UniTask OnScrollAsync(); } public partial class AsyncTriggerHandler : IAsyncOnScrollHandler { UniTask IAsyncOnScrollHandler.OnScrollAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncScrollTrigger GetAsyncScrollTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncScrollTrigger GetAsyncScrollTrigger(this Component component) { return component.gameObject.GetAsyncScrollTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncScrollTrigger : AsyncTriggerBase, IScrollHandler { void IScrollHandler.OnScroll(PointerEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnScrollHandler GetOnScrollAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnScrollHandler GetOnScrollAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnScrollAsync() { return ((IAsyncOnScrollHandler)new AsyncTriggerHandler(this, true)).OnScrollAsync(); } public UniTask OnScrollAsync(CancellationToken cancellationToken) { return ((IAsyncOnScrollHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnScrollAsync(); } } #endif #endregion #region Select #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnSelectHandler { UniTask OnSelectAsync(); } public partial class AsyncTriggerHandler : IAsyncOnSelectHandler { UniTask IAsyncOnSelectHandler.OnSelectAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncSelectTrigger GetAsyncSelectTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncSelectTrigger GetAsyncSelectTrigger(this Component component) { return component.gameObject.GetAsyncSelectTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncSelectTrigger : AsyncTriggerBase, ISelectHandler { void ISelectHandler.OnSelect(BaseEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnSelectHandler GetOnSelectAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnSelectHandler GetOnSelectAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnSelectAsync() { return ((IAsyncOnSelectHandler)new AsyncTriggerHandler(this, true)).OnSelectAsync(); } public UniTask OnSelectAsync(CancellationToken cancellationToken) { return ((IAsyncOnSelectHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnSelectAsync(); } } #endif #endregion #region Submit #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnSubmitHandler { UniTask OnSubmitAsync(); } public partial class AsyncTriggerHandler : IAsyncOnSubmitHandler { UniTask IAsyncOnSubmitHandler.OnSubmitAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncSubmitTrigger GetAsyncSubmitTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncSubmitTrigger GetAsyncSubmitTrigger(this Component component) { return component.gameObject.GetAsyncSubmitTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncSubmitTrigger : AsyncTriggerBase, ISubmitHandler { void ISubmitHandler.OnSubmit(BaseEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnSubmitHandler GetOnSubmitAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnSubmitHandler GetOnSubmitAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnSubmitAsync() { return ((IAsyncOnSubmitHandler)new AsyncTriggerHandler(this, true)).OnSubmitAsync(); } public UniTask OnSubmitAsync(CancellationToken cancellationToken) { return ((IAsyncOnSubmitHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnSubmitAsync(); } } #endif #endregion #region UpdateSelected #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT public interface IAsyncOnUpdateSelectedHandler { UniTask OnUpdateSelectedAsync(); } public partial class AsyncTriggerHandler : IAsyncOnUpdateSelectedHandler { UniTask IAsyncOnUpdateSelectedHandler.OnUpdateSelectedAsync() { core.Reset(); return new UniTask((IUniTaskSource)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static AsyncUpdateSelectedTrigger GetAsyncUpdateSelectedTrigger(this GameObject gameObject) { return GetOrAddComponent(gameObject); } public static AsyncUpdateSelectedTrigger GetAsyncUpdateSelectedTrigger(this Component component) { return component.gameObject.GetAsyncUpdateSelectedTrigger(); } } [DisallowMultipleComponent] public sealed class AsyncUpdateSelectedTrigger : AsyncTriggerBase, IUpdateSelectedHandler { void IUpdateSelectedHandler.OnUpdateSelected(BaseEventData eventData) { RaiseEvent((eventData)); } public IAsyncOnUpdateSelectedHandler GetOnUpdateSelectedAsyncHandler() { return new AsyncTriggerHandler(this, false); } public IAsyncOnUpdateSelectedHandler GetOnUpdateSelectedAsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler(this, cancellationToken, false); } public UniTask OnUpdateSelectedAsync() { return ((IAsyncOnUpdateSelectedHandler)new AsyncTriggerHandler(this, true)).OnUpdateSelectedAsync(); } public UniTask OnUpdateSelectedAsync(CancellationToken cancellationToken) { return ((IAsyncOnUpdateSelectedHandler)new AsyncTriggerHandler(this, cancellationToken, true)).OnUpdateSelectedAsync(); } } #endif #endregion } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.cs.meta ================================================ fileFormatVersion: 2 guid: c30655636c35c3d4da44064af3d2d9a7 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> <# var empty = new (string, string)[0]; var triggers = new (string triggerName, string methodName, string returnType, string handlerInterface, (string argType, string argName)[] arguments)[] { ("AnimatorIK", "OnAnimatorIK", "int", null, new []{ ("int", "layerIndex") }), ("AnimatorMove", "OnAnimatorMove", "AsyncUnit", null, empty), ("OnCanvasGroupChanged", "OnCanvasGroupChanged", "AsyncUnit", null, empty ), ("CollisionEnter2D", "OnCollisionEnter2D", "Collision2D", null, new []{ ("Collision2D", "coll") }), ("CollisionExit2D", "OnCollisionExit2D", "Collision2D", null, new []{ ("Collision2D", "coll") }), ("CollisionStay2D", "OnCollisionStay2D", "Collision2D", null, new []{ ("Collision2D", "coll") }), ("CollisionEnter", "OnCollisionEnter", "Collision", null, new []{ ("Collision", "coll") }), ("CollisionExit", "OnCollisionExit", "Collision", null, new []{ ("Collision", "coll") }), ("CollisionStay", "OnCollisionStay", "Collision", null, new []{ ("Collision", "coll") }), ("Enable", "OnEnable", "AsyncUnit", null, empty), ("Disable", "OnDisable", "AsyncUnit", null, empty), ("JointBreak", "OnJointBreak", "float", null, new []{ ("float", "breakForce") }), ("JointBreak2D", "OnJointBreak2D", "Joint2D", null, new []{ ("Joint2D", "brokenJoint") }), ("Update", "Update", "AsyncUnit", null, empty), ("FixedUpdate", "FixedUpdate", "AsyncUnit", null, empty), ("LateUpdate", "LateUpdate", "AsyncUnit", null, empty), ("ParticleCollision", "OnParticleCollision", "GameObject", null, new []{ ("GameObject", "other") }), ("RectTransformDimensionsChange", "OnRectTransformDimensionsChange", "AsyncUnit", null, empty), ("RectTransformRemoved", "OnRectTransformRemoved", "AsyncUnit", null, empty), ("BeforeTransformParentChanged", "OnBeforeTransformParentChanged", "AsyncUnit", null, empty), ("TransformParentChanged", "OnTransformParentChanged", "AsyncUnit", null, empty), ("TransformChildrenChanged", "OnTransformChildrenChanged", "AsyncUnit", null, empty), ("TriggerEnter2D", "OnTriggerEnter2D", "Collider2D", null, new []{ ("Collider2D", "other") }), ("TriggerExit2D", "OnTriggerExit2D", "Collider2D", null, new []{ ("Collider2D", "other") }), ("TriggerStay2D", "OnTriggerStay2D", "Collider2D", null, new []{ ("Collider2D", "other") }), ("TriggerEnter", "OnTriggerEnter", "Collider", null, new []{ ("Collider", "other") }), ("TriggerExit", "OnTriggerExit", "Collider", null, new []{ ("Collider", "other") }), ("TriggerStay", "OnTriggerStay", "Collider", null, new []{ ("Collider", "other") }), ("BecameInvisible", "OnBecameInvisible", "AsyncUnit", null, empty), ("BecameVisible", "OnBecameVisible", "AsyncUnit", null, empty), // Mouse... #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) ("MouseDown", "OnMouseDown", "AsyncUnit", null, empty), ("MouseDrag", "OnMouseDrag", "AsyncUnit", null, empty), ("MouseEnter", "OnMouseEnter", "AsyncUnit", null, empty), ("MouseExit", "OnMouseExit", "AsyncUnit", null, empty), ("MouseOver", "OnMouseOver", "AsyncUnit", null, empty), ("MouseUp", "OnMouseUp", "AsyncUnit", null, empty), ("MouseUpAsButton", "OnMouseUpAsButton", "AsyncUnit", null, empty), // new in v2 ("ApplicationFocus", "OnApplicationFocus", "bool", null, new []{("bool", "hasFocus") }), ("ApplicationPause", "OnApplicationPause", "bool", null, new []{("bool", "pauseStatus") }), ("ApplicationQuit", "OnApplicationQuit", "AsyncUnit", null, empty), ("AudioFilterRead", "OnAudioFilterRead", "(float[] data, int channels)", null, new[]{("float[]", "data"), ("int", "channels")}), ("ControllerColliderHit", "OnControllerColliderHit", "ControllerColliderHit", null, new[]{("ControllerColliderHit", "hit")}), ("DrawGizmos", "OnDrawGizmos", "AsyncUnit", null, empty), ("DrawGizmosSelected", "OnDrawGizmosSelected", "AsyncUnit", null, empty), ("GUI", "OnGUI", "AsyncUnit", null, empty), ("ParticleSystemStopped", "OnParticleSystemStopped", "AsyncUnit", null, empty), ("ParticleTrigger", "OnParticleTrigger", "AsyncUnit", null, empty), ("PostRender", "OnPostRender", "AsyncUnit", null, empty), ("PreCull", "OnPreCull", "AsyncUnit", null, empty), ("PreRender", "OnPreRender", "AsyncUnit", null, empty), ("RenderImage", "OnRenderImage", "(RenderTexture source, RenderTexture destination)", null, new[]{("RenderTexture", "source"), ("RenderTexture", "destination")}), ("RenderObject", "OnRenderObject", "AsyncUnit", null, empty), ("ServerInitialized", "OnServerInitialized", "AsyncUnit", null, empty), ("Validate", "OnValidate", "AsyncUnit", null, empty), ("WillRenderObject", "OnWillRenderObject", "AsyncUnit", null, empty), ("Reset", "Reset", "AsyncUnit", null, empty), // uGUI ("BeginDrag", "OnBeginDrag", "PointerEventData", "IBeginDragHandler", new []{ ("PointerEventData", "eventData") }), ("Cancel", "OnCancel", "BaseEventData", "ICancelHandler", new []{ ("BaseEventData", "eventData") }), ("Deselect", "OnDeselect", "BaseEventData", "IDeselectHandler", new []{ ("BaseEventData", "eventData") }), ("Drag", "OnDrag", "PointerEventData", "IDragHandler", new []{ ("PointerEventData", "eventData") }), ("Drop", "OnDrop", "PointerEventData", "IDropHandler", new []{ ("PointerEventData", "eventData") }), ("EndDrag", "OnEndDrag", "PointerEventData", "IEndDragHandler", new []{ ("PointerEventData", "eventData") }), ("InitializePotentialDrag", "OnInitializePotentialDrag", "PointerEventData", "IInitializePotentialDragHandler", new []{ ("PointerEventData", "eventData") }), ("Move", "OnMove", "AxisEventData", "IMoveHandler", new []{ ("AxisEventData", "eventData") }), ("PointerClick", "OnPointerClick", "PointerEventData", "IPointerClickHandler", new []{ ("PointerEventData", "eventData") }), ("PointerDown", "OnPointerDown", "PointerEventData", "IPointerDownHandler", new []{ ("PointerEventData", "eventData") }), ("PointerEnter", "OnPointerEnter", "PointerEventData", "IPointerEnterHandler", new []{ ("PointerEventData", "eventData") }), ("PointerExit", "OnPointerExit", "PointerEventData", "IPointerExitHandler", new []{ ("PointerEventData", "eventData") }), ("PointerUp", "OnPointerUp", "PointerEventData", "IPointerUpHandler", new []{ ("PointerEventData", "eventData") }), ("Scroll", "OnScroll", "PointerEventData", "IScrollHandler", new []{ ("PointerEventData", "eventData") }), ("Select", "OnSelect", "BaseEventData", "ISelectHandler", new []{ ("BaseEventData", "eventData") }), ("Submit", "OnSubmit", "BaseEventData", "ISubmitHandler", new []{ ("BaseEventData", "eventData") }), ("UpdateSelected", "OnUpdateSelected", "BaseEventData", "IUpdateSelectedHandler", new []{ ("BaseEventData", "eventData") }), // 2019.3 ("ParticleUpdateJobScheduled", "OnParticleUpdateJobScheduled", "UnityEngine.ParticleSystemJobs.ParticleSystemJobData", null, new[]{("UnityEngine.ParticleSystemJobs.ParticleSystemJobData", "particles")}), // Oneshot // Awake, Start, Destroy }; triggers = triggers.OrderBy(x => x.handlerInterface != null).ThenBy(x => x.handlerInterface != null ? x.handlerInterface : x.methodName).ToArray(); Func ToInterfaceName = x => $"IAsync{x}Handler"; Func ToUniTaskName = x => x == "AsyncUnit" ? "UniTask" : $"UniTask<{x}>"; Func ToCastUniTasSourceType = x => x == "AsyncUnit" ? "IUniTaskSource" : $"IUniTaskSource<{x}>"; Func OnInvokeSuffix = x => x == "AsyncUnit" ? ".AsUniTask()" : $""; Func<(string argType, string argName)[], string> BuildMethodArgument = x => string.Join(", ", x.Select(y => y.argType + " " + y.argName)); Func<(string argType, string argName)[], string> BuildResultParameter = x => x.Length == 0 ? "AsyncUnit.Default" : "(" + string.Join(", ", x.Select(y => y.argName)) + ")"; Func IsParticleSystem = x => x == "ParticleUpdateJobScheduled"; Func IsMouseTrigger = x => x.StartsWith("Mouse"); Func RequirePhysicsModule = x => (x.StartsWith("Collision") || x.StartsWith("Collider") || x.StartsWith("ControllerCollider") || x.StartsWith("Joint") || x.StartsWith("Trigger")) ? (x.Contains("2D") ? "UNITASK_PHYSICS2D_SUPPORT" : "UNITASK_PHYSICS_SUPPORT") : null; Func IsUguiSystem = x => x != null; #> #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Threading; using UnityEngine; #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT using UnityEngine.EventSystems; #endif namespace Cysharp.Threading.Tasks.Triggers { <# foreach(var t in triggers) { #> #region <#= t.triggerName #> <# if(IsUguiSystem(t.handlerInterface)) { #> #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT <# } #> <# if(IsParticleSystem(t.triggerName)) { #> #if UNITY_2019_3_OR_NEWER && (!UNITY_2019_1_OR_NEWER || UNITASK_PARTICLESYSTEM_SUPPORT) <# } #> <# if(IsMouseTrigger(t.triggerName)) { #> #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO) <# } #> <# if(RequirePhysicsModule(t.triggerName) != null) { #> #if !UNITY_2019_1_OR_NEWER || <#= RequirePhysicsModule(t.triggerName) #> <# } #> public interface <#= ToInterfaceName(t.methodName) #> { <#= ToUniTaskName(t.returnType) #> <#= t.methodName #>Async(); } public partial class AsyncTriggerHandler : <#= ToInterfaceName(t.methodName) #> { <#= ToUniTaskName(t.returnType) #> <#= ToInterfaceName(t.methodName) #>.<#= t.methodName #>Async() { core.Reset(); return new <#= ToUniTaskName(t.returnType) #>((<#= ToCastUniTasSourceType(t.returnType) #>)(object)this, core.Version); } } public static partial class AsyncTriggerExtensions { public static Async<#= t.triggerName #>Trigger GetAsync<#= t.triggerName #>Trigger(this GameObject gameObject) { return GetOrAddComponentTrigger>(gameObject); } public static Async<#= t.triggerName #>Trigger GetAsync<#= t.triggerName #>Trigger(this Component component) { return component.gameObject.GetAsync<#= t.triggerName #>Trigger(); } } [DisallowMultipleComponent] public sealed class Async<#= t.triggerName #>Trigger : AsyncTriggerBase<<#= t.returnType #>><#= (t.handlerInterface == null) ? "" : $", {t.handlerInterface}" #> { void <#= (t.handlerInterface == null) ? "" : $"{t.handlerInterface}." #><#= t.methodName #>(<#= BuildMethodArgument(t.arguments) #>) { RaiseEvent(<#= BuildResultParameter(t.arguments) #>); } public <#= ToInterfaceName(t.methodName) #> Get<#= t.methodName #>AsyncHandler() { return new AsyncTriggerHandler<<#= t.returnType #>>(this, false); } public <#= ToInterfaceName(t.methodName) #> Get<#= t.methodName #>AsyncHandler(CancellationToken cancellationToken) { return new AsyncTriggerHandler<<#= t.returnType #>>(this, cancellationToken, false); } public <#= ToUniTaskName(t.returnType) #> <#= t.methodName #>Async() { return ((<#= ToInterfaceName(t.methodName) #>)new AsyncTriggerHandler<<#= t.returnType #>>(this, true)).<#= t.methodName #>Async(); } public <#= ToUniTaskName(t.returnType) #> <#= t.methodName #>Async(CancellationToken cancellationToken) { return ((<#= ToInterfaceName(t.methodName) #>)new AsyncTriggerHandler<<#= t.returnType #>>(this, cancellationToken, true)).<#= t.methodName #>Async(); } } <# if(IsUguiSystem(t.handlerInterface)) { #> #endif <# } #> <# if(RequirePhysicsModule(t.triggerName) != null) { #> #endif <# } #> <# if(IsParticleSystem(t.triggerName) || IsMouseTrigger(t.triggerName)) { #> #endif <# } #> #endregion <# } #> } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.tt.meta ================================================ fileFormatVersion: 2 guid: 3ca26d0cd9373354c8cd147490f32c8e DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers.meta ================================================ fileFormatVersion: 2 guid: 85c0c768ced512e42b24021b3258b669 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.AsValueTask.cs ================================================ #pragma warning disable 0649 #if UNITASK_NETCORE || UNITY_2022_3_OR_NEWER #define SUPPORT_VALUETASK #endif #if SUPPORT_VALUETASK using System; using System.Threading.Tasks; using System.Threading.Tasks.Sources; namespace Cysharp.Threading.Tasks { public static class UniTaskValueTaskExtensions { public static ValueTask AsValueTask(this in UniTask task) { #if (UNITASK_NETCORE && NETSTANDARD2_0) return new ValueTask(new UniTaskValueTaskSource(task), 0); #else return task; #endif } public static ValueTask AsValueTask(this in UniTask task) { #if (UNITASK_NETCORE && NETSTANDARD2_0) return new ValueTask(new UniTaskValueTaskSource(task), 0); #else return task; #endif } public static async UniTask AsUniTask(this ValueTask task) { return await task; } public static async UniTask AsUniTask(this ValueTask task) { await task; } #if (UNITASK_NETCORE && NETSTANDARD2_0) class UniTaskValueTaskSource : IValueTaskSource { readonly UniTask task; readonly UniTask.Awaiter awaiter; public UniTaskValueTaskSource(UniTask task) { this.task = task; this.awaiter = task.GetAwaiter(); } public void GetResult(short token) { awaiter.GetResult(); } public ValueTaskSourceStatus GetStatus(short token) { return (ValueTaskSourceStatus)task.Status; } public void OnCompleted(Action continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags) { awaiter.SourceOnCompleted(continuation, state); } } class UniTaskValueTaskSource : IValueTaskSource { readonly UniTask task; readonly UniTask.Awaiter awaiter; public UniTaskValueTaskSource(UniTask task) { this.task = task; this.awaiter = task.GetAwaiter(); } public T GetResult(short token) { return awaiter.GetResult(); } public ValueTaskSourceStatus GetStatus(short token) { return (ValueTaskSourceStatus)task.Status; } public void OnCompleted(Action continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags) { awaiter.SourceOnCompleted(continuation, state); } } #endif } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.AsValueTask.cs.meta ================================================ fileFormatVersion: 2 guid: d38f0478933be42d895c37b862540a1c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Bridge.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections; namespace Cysharp.Threading.Tasks { // UnityEngine Bridges. public partial struct UniTask { public static IEnumerator ToCoroutine(Func taskFactory) { return taskFactory().ToCoroutine(); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Bridge.cs.meta ================================================ fileFormatVersion: 2 guid: bd6beac8e0ebd264e9ba246c39429c72 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using Cysharp.Threading.Tasks.Internal; using System; using System.Collections; using System.Runtime.CompilerServices; using System.Threading; using UnityEngine; namespace Cysharp.Threading.Tasks { public enum DelayType { /// use Time.deltaTime. DeltaTime, /// Ignore timescale, use Time.unscaledDeltaTime. UnscaledDeltaTime, /// use Stopwatch.GetTimestamp(). Realtime } public partial struct UniTask { public static YieldAwaitable Yield() { // optimized for single continuation return new YieldAwaitable(PlayerLoopTiming.Update); } public static YieldAwaitable Yield(PlayerLoopTiming timing) { // optimized for single continuation return new YieldAwaitable(timing); } public static UniTask Yield(CancellationToken cancellationToken, bool cancelImmediately = false) { return new UniTask(YieldPromise.Create(PlayerLoopTiming.Update, cancellationToken, cancelImmediately, out var token), token); } public static UniTask Yield(PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately = false) { return new UniTask(YieldPromise.Create(timing, cancellationToken, cancelImmediately, out var token), token); } /// /// Similar as UniTask.Yield but guaranteed run on next frame. /// public static UniTask NextFrame() { return new UniTask(NextFramePromise.Create(PlayerLoopTiming.Update, CancellationToken.None, false, out var token), token); } /// /// Similar as UniTask.Yield but guaranteed run on next frame. /// public static UniTask NextFrame(PlayerLoopTiming timing) { return new UniTask(NextFramePromise.Create(timing, CancellationToken.None, false, out var token), token); } /// /// Similar as UniTask.Yield but guaranteed run on next frame. /// public static UniTask NextFrame(CancellationToken cancellationToken, bool cancelImmediately = false) { return new UniTask(NextFramePromise.Create(PlayerLoopTiming.Update, cancellationToken, cancelImmediately, out var token), token); } /// /// Similar as UniTask.Yield but guaranteed run on next frame. /// public static UniTask NextFrame(PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately = false) { return new UniTask(NextFramePromise.Create(timing, cancellationToken, cancelImmediately, out var token), token); } #if UNITY_2023_1_OR_NEWER public static async UniTask WaitForEndOfFrame(CancellationToken cancellationToken = default) { await Awaitable.EndOfFrameAsync(cancellationToken); } #else [Obsolete("Use WaitForEndOfFrame(MonoBehaviour) instead or UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate). Equivalent for coroutine's WaitForEndOfFrame requires MonoBehaviour(runner of Coroutine).")] public static YieldAwaitable WaitForEndOfFrame() { return UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate); } [Obsolete("Use WaitForEndOfFrame(MonoBehaviour) instead or UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate). Equivalent for coroutine's WaitForEndOfFrame requires MonoBehaviour(runner of Coroutine).")] public static UniTask WaitForEndOfFrame(CancellationToken cancellationToken, bool cancelImmediately = false) { return UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate, cancellationToken, cancelImmediately); } #endif public static UniTask WaitForEndOfFrame(MonoBehaviour coroutineRunner) { var source = WaitForEndOfFramePromise.Create(coroutineRunner, CancellationToken.None, false, out var token); return new UniTask(source, token); } public static UniTask WaitForEndOfFrame(MonoBehaviour coroutineRunner, CancellationToken cancellationToken, bool cancelImmediately = false) { var source = WaitForEndOfFramePromise.Create(coroutineRunner, cancellationToken, cancelImmediately, out var token); return new UniTask(source, token); } /// /// Same as UniTask.Yield(PlayerLoopTiming.LastFixedUpdate). /// public static YieldAwaitable WaitForFixedUpdate() { // use LastFixedUpdate instead of FixedUpdate // https://github.com/Cysharp/UniTask/issues/377 return UniTask.Yield(PlayerLoopTiming.LastFixedUpdate); } /// /// Same as UniTask.Yield(PlayerLoopTiming.LastFixedUpdate, cancellationToken). /// public static UniTask WaitForFixedUpdate(CancellationToken cancellationToken, bool cancelImmediately = false) { return UniTask.Yield(PlayerLoopTiming.LastFixedUpdate, cancellationToken, cancelImmediately); } public static UniTask WaitForSeconds(float duration, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { return Delay(Mathf.RoundToInt(1000 * duration), ignoreTimeScale, delayTiming, cancellationToken, cancelImmediately); } public static UniTask WaitForSeconds(int duration, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { return Delay(1000 * duration, ignoreTimeScale, delayTiming, cancellationToken, cancelImmediately); } public static UniTask DelayFrame(int delayFrameCount, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { if (delayFrameCount < 0) { throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. delayFrameCount:" + delayFrameCount); } return new UniTask(DelayFramePromise.Create(delayFrameCount, delayTiming, cancellationToken, cancelImmediately, out var token), token); } public static UniTask Delay(int millisecondsDelay, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { var delayTimeSpan = TimeSpan.FromMilliseconds(millisecondsDelay); return Delay(delayTimeSpan, ignoreTimeScale, delayTiming, cancellationToken, cancelImmediately); } public static UniTask Delay(TimeSpan delayTimeSpan, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { var delayType = ignoreTimeScale ? DelayType.UnscaledDeltaTime : DelayType.DeltaTime; return Delay(delayTimeSpan, delayType, delayTiming, cancellationToken, cancelImmediately); } public static UniTask Delay(int millisecondsDelay, DelayType delayType, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { var delayTimeSpan = TimeSpan.FromMilliseconds(millisecondsDelay); return Delay(delayTimeSpan, delayType, delayTiming, cancellationToken, cancelImmediately); } public static UniTask Delay(TimeSpan delayTimeSpan, DelayType delayType, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { if (delayTimeSpan < TimeSpan.Zero) { throw new ArgumentOutOfRangeException("Delay does not allow minus delayTimeSpan. delayTimeSpan:" + delayTimeSpan); } #if UNITY_EDITOR // force use Realtime. if (PlayerLoopHelper.IsMainThread && !UnityEditor.EditorApplication.isPlaying) { delayType = DelayType.Realtime; } #endif switch (delayType) { case DelayType.UnscaledDeltaTime: { return new UniTask(DelayIgnoreTimeScalePromise.Create(delayTimeSpan, delayTiming, cancellationToken, cancelImmediately, out var token), token); } case DelayType.Realtime: { return new UniTask(DelayRealtimePromise.Create(delayTimeSpan, delayTiming, cancellationToken, cancelImmediately, out var token), token); } case DelayType.DeltaTime: default: { return new UniTask(DelayPromise.Create(delayTimeSpan, delayTiming, cancellationToken, cancelImmediately, out var token), token); } } } sealed class YieldPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; YieldPromise nextNode; public ref YieldPromise NextNode => ref nextNode; static YieldPromise() { TaskPool.RegisterSizeGetter(typeof(YieldPromise), () => pool.Size); } CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; YieldPromise() { } public static IUniTaskSource Create(PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new YieldPromise(); } result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (YieldPromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } core.TrySetResult(null); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class NextFramePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; NextFramePromise nextNode; public ref NextFramePromise NextNode => ref nextNode; static NextFramePromise() { TaskPool.RegisterSizeGetter(typeof(NextFramePromise), () => pool.Size); } int frameCount; UniTaskCompletionSourceCore core; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; NextFramePromise() { } public static IUniTaskSource Create(PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new NextFramePromise(); } result.frameCount = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (NextFramePromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (frameCount == Time.frameCount) { return true; } core.TrySetResult(AsyncUnit.Default); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); cancellationToken = default; cancellationTokenRegistration.Dispose(); return pool.TryPush(this); } } sealed class WaitForEndOfFramePromise : IUniTaskSource, ITaskPoolNode, System.Collections.IEnumerator { static TaskPool pool; WaitForEndOfFramePromise nextNode; public ref WaitForEndOfFramePromise NextNode => ref nextNode; static WaitForEndOfFramePromise() { TaskPool.RegisterSizeGetter(typeof(WaitForEndOfFramePromise), () => pool.Size); } UniTaskCompletionSourceCore core; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; WaitForEndOfFramePromise() { } public static IUniTaskSource Create(MonoBehaviour coroutineRunner, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitForEndOfFramePromise(); } result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (WaitForEndOfFramePromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); coroutineRunner.StartCoroutine(result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); Reset(); // Reset Enumerator cancellationToken = default; cancellationTokenRegistration.Dispose(); return pool.TryPush(this); } // Coroutine Runner implementation static readonly WaitForEndOfFrame waitForEndOfFrameYieldInstruction = new WaitForEndOfFrame(); bool isFirst = true; object IEnumerator.Current => waitForEndOfFrameYieldInstruction; bool IEnumerator.MoveNext() { if (isFirst) { isFirst = false; return true; // start WaitForEndOfFrame } if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } core.TrySetResult(null); return false; } public void Reset() { isFirst = true; } } sealed class DelayFramePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; DelayFramePromise nextNode; public ref DelayFramePromise NextNode => ref nextNode; static DelayFramePromise() { TaskPool.RegisterSizeGetter(typeof(DelayFramePromise), () => pool.Size); } int initialFrame; int delayFrameCount; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; int currentFrameCount; UniTaskCompletionSourceCore core; DelayFramePromise() { } public static IUniTaskSource Create(int delayFrameCount, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new DelayFramePromise(); } result.delayFrameCount = delayFrameCount; result.cancellationToken = cancellationToken; result.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (DelayFramePromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (currentFrameCount == 0) { if (delayFrameCount == 0) // same as Yield { core.TrySetResult(AsyncUnit.Default); return false; } // skip in initial frame. if (initialFrame == Time.frameCount) { #if UNITY_EDITOR // force use Realtime. if (PlayerLoopHelper.IsMainThread && !UnityEditor.EditorApplication.isPlaying) { //goto ++currentFrameCount } else { return true; } #else return true; #endif } } if (++currentFrameCount >= delayFrameCount) { core.TrySetResult(AsyncUnit.Default); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); currentFrameCount = default; delayFrameCount = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class DelayPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; DelayPromise nextNode; public ref DelayPromise NextNode => ref nextNode; static DelayPromise() { TaskPool.RegisterSizeGetter(typeof(DelayPromise), () => pool.Size); } int initialFrame; float delayTimeSpan; float elapsed; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; DelayPromise() { } public static IUniTaskSource Create(TimeSpan delayTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new DelayPromise(); } result.elapsed = 0.0f; result.delayTimeSpan = (float)delayTimeSpan.TotalSeconds; result.cancellationToken = cancellationToken; result.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (DelayPromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (elapsed == 0.0f) { if (initialFrame == Time.frameCount) { return true; } } elapsed += Time.deltaTime; if (elapsed >= delayTimeSpan) { core.TrySetResult(null); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); delayTimeSpan = default; elapsed = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class DelayIgnoreTimeScalePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; DelayIgnoreTimeScalePromise nextNode; public ref DelayIgnoreTimeScalePromise NextNode => ref nextNode; static DelayIgnoreTimeScalePromise() { TaskPool.RegisterSizeGetter(typeof(DelayIgnoreTimeScalePromise), () => pool.Size); } float delayFrameTimeSpan; float elapsed; int initialFrame; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; DelayIgnoreTimeScalePromise() { } public static IUniTaskSource Create(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new DelayIgnoreTimeScalePromise(); } result.elapsed = 0.0f; result.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds; result.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (DelayIgnoreTimeScalePromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (elapsed == 0.0f) { if (initialFrame == Time.frameCount) { return true; } } elapsed += Time.unscaledDeltaTime; if (elapsed >= delayFrameTimeSpan) { core.TrySetResult(null); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); delayFrameTimeSpan = default; elapsed = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class DelayRealtimePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; DelayRealtimePromise nextNode; public ref DelayRealtimePromise NextNode => ref nextNode; static DelayRealtimePromise() { TaskPool.RegisterSizeGetter(typeof(DelayRealtimePromise), () => pool.Size); } long delayTimeSpanTicks; ValueStopwatch stopwatch; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; DelayRealtimePromise() { } public static IUniTaskSource Create(TimeSpan delayTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new DelayRealtimePromise(); } result.stopwatch = ValueStopwatch.StartNew(); result.delayTimeSpanTicks = delayTimeSpan.Ticks; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (DelayRealtimePromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (stopwatch.IsInvalid) { core.TrySetResult(AsyncUnit.Default); return false; } if (stopwatch.ElapsedTicks >= delayTimeSpanTicks) { core.TrySetResult(AsyncUnit.Default); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); stopwatch = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } } public readonly struct YieldAwaitable { readonly PlayerLoopTiming timing; public YieldAwaitable(PlayerLoopTiming timing) { this.timing = timing; } public Awaiter GetAwaiter() { return new Awaiter(timing); } public UniTask ToUniTask() { return UniTask.Yield(timing, CancellationToken.None); } public readonly struct Awaiter : ICriticalNotifyCompletion { readonly PlayerLoopTiming timing; public Awaiter(PlayerLoopTiming timing) { this.timing = timing; } public bool IsCompleted => false; public void GetResult() { } public void OnCompleted(Action continuation) { PlayerLoopHelper.AddContinuation(timing, continuation); } public void UnsafeOnCompleted(Action continuation) { PlayerLoopHelper.AddContinuation(timing, continuation); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs.meta ================================================ fileFormatVersion: 2 guid: ecff7972251de0848b2c0fa89bbd3489 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Factory.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using Cysharp.Threading.Tasks.Internal; using System; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Threading; namespace Cysharp.Threading.Tasks { public partial struct UniTask { static readonly UniTask CanceledUniTask = new Func(() => { return new UniTask(new CanceledResultSource(CancellationToken.None), 0); })(); static class CanceledUniTaskCache { public static readonly UniTask Task; static CanceledUniTaskCache() { Task = new UniTask(new CanceledResultSource(CancellationToken.None), 0); } } public static readonly UniTask CompletedTask = new UniTask(); public static UniTask FromException(Exception ex) { if (ex is OperationCanceledException oce) { return FromCanceled(oce.CancellationToken); } return new UniTask(new ExceptionResultSource(ex), 0); } public static UniTask FromException(Exception ex) { if (ex is OperationCanceledException oce) { return FromCanceled(oce.CancellationToken); } return new UniTask(new ExceptionResultSource(ex), 0); } public static UniTask FromResult(T value) { return new UniTask(value); } public static UniTask FromCanceled(CancellationToken cancellationToken = default) { if (cancellationToken == CancellationToken.None) { return CanceledUniTask; } else { return new UniTask(new CanceledResultSource(cancellationToken), 0); } } public static UniTask FromCanceled(CancellationToken cancellationToken = default) { if (cancellationToken == CancellationToken.None) { return CanceledUniTaskCache.Task; } else { return new UniTask(new CanceledResultSource(cancellationToken), 0); } } public static UniTask Create(Func factory) { return factory(); } public static UniTask Create(Func factory, CancellationToken cancellationToken) { return factory(cancellationToken); } public static UniTask Create(T state, Func factory) { return factory(state); } public static UniTask Create(Func> factory) { return factory(); } public static AsyncLazy Lazy(Func factory) { return new AsyncLazy(factory); } public static AsyncLazy Lazy(Func> factory) { return new AsyncLazy(factory); } /// /// helper of fire and forget void action. /// public static void Void(Func asyncAction) { asyncAction().Forget(); } /// /// helper of fire and forget void action. /// public static void Void(Func asyncAction, CancellationToken cancellationToken) { asyncAction(cancellationToken).Forget(); } /// /// helper of fire and forget void action. /// public static void Void(Func asyncAction, T state) { asyncAction(state).Forget(); } /// /// helper of create add UniTaskVoid to delegate. /// For example: FooAction = UniTask.Action(async () => { /* */ }) /// public static Action Action(Func asyncAction) { return () => asyncAction().Forget(); } /// /// helper of create add UniTaskVoid to delegate. /// public static Action Action(Func asyncAction, CancellationToken cancellationToken) { return () => asyncAction(cancellationToken).Forget(); } /// /// helper of create add UniTaskVoid to delegate. /// public static Action Action(T state, Func asyncAction) { return () => asyncAction(state).Forget(); } #if UNITY_2018_3_OR_NEWER /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async () => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction) { return () => asyncAction().Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(FooAsync, this.GetCancellationTokenOnDestroy())) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction, CancellationToken cancellationToken) { return () => asyncAction(cancellationToken).Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(FooAsync, Argument)) /// public static UnityEngine.Events.UnityAction UnityAction(T state, Func asyncAction) { return () => asyncAction(state).Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async (T arg) => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction) { return (arg) => asyncAction(arg).Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async (T0 arg0, T1 arg1) => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction) { return (arg0, arg1) => asyncAction(arg0, arg1).Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async (T0 arg0, T1 arg1, T2 arg2) => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction) { return (arg0, arg1, arg2) => asyncAction(arg0, arg1, arg2).Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async (T0 arg0, T1 arg1, T2 arg2, T3 arg3) => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction) { return (arg0, arg1, arg2, arg3) => asyncAction(arg0, arg1, arg2, arg3).Forget(); } // /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async (T arg, CancellationToken cancellationToken) => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction, CancellationToken cancellationToken) { return (arg) => asyncAction(arg, cancellationToken).Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async (T0 arg0, T1 arg1, CancellationToken cancellationToken) => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction, CancellationToken cancellationToken) { return (arg0, arg1) => asyncAction(arg0, arg1, cancellationToken).Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async (T0 arg0, T1 arg1, T2 arg2, CancellationToken cancellationToken) => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction, CancellationToken cancellationToken) { return (arg0, arg1, arg2) => asyncAction(arg0, arg1, arg2, cancellationToken).Forget(); } /// /// Create async void(UniTaskVoid) UnityAction. /// For example: onClick.AddListener(UniTask.UnityAction(async (T0 arg0, T1 arg1, T2 arg2, T3 arg3, CancellationToken cancellationToken) => { /* */ } )) /// public static UnityEngine.Events.UnityAction UnityAction(Func asyncAction, CancellationToken cancellationToken) { return (arg0, arg1, arg2, arg3) => asyncAction(arg0, arg1, arg2, arg3, cancellationToken).Forget(); } #endif /// /// Defer the task creation just before call await. /// public static UniTask Defer(Func factory) { return new UniTask(new DeferPromise(factory), 0); } /// /// Defer the task creation just before call await. /// public static UniTask Defer(Func> factory) { return new UniTask(new DeferPromise(factory), 0); } /// /// Defer the task creation just before call await. /// public static UniTask Defer(TState state, Func factory) { return new UniTask(new DeferPromiseWithState(state, factory), 0); } /// /// Defer the task creation just before call await. /// public static UniTask Defer(TState state, Func> factory) { return new UniTask(new DeferPromiseWithState(state, factory), 0); } /// /// Never complete. /// public static UniTask Never(CancellationToken cancellationToken) { return new UniTask(new NeverPromise(cancellationToken), 0); } /// /// Never complete. /// public static UniTask Never(CancellationToken cancellationToken) { return new UniTask(new NeverPromise(cancellationToken), 0); } sealed class ExceptionResultSource : IUniTaskSource { readonly ExceptionDispatchInfo exception; bool calledGet; public ExceptionResultSource(Exception exception) { this.exception = ExceptionDispatchInfo.Capture(exception); } public void GetResult(short token) { if (!calledGet) { calledGet = true; GC.SuppressFinalize(this); } exception.Throw(); } public UniTaskStatus GetStatus(short token) { return UniTaskStatus.Faulted; } public UniTaskStatus UnsafeGetStatus() { return UniTaskStatus.Faulted; } public void OnCompleted(Action continuation, object state, short token) { continuation(state); } ~ExceptionResultSource() { if (!calledGet) { UniTaskScheduler.PublishUnobservedTaskException(exception.SourceException); } } } sealed class ExceptionResultSource : IUniTaskSource { readonly ExceptionDispatchInfo exception; bool calledGet; public ExceptionResultSource(Exception exception) { this.exception = ExceptionDispatchInfo.Capture(exception); } public T GetResult(short token) { if (!calledGet) { calledGet = true; GC.SuppressFinalize(this); } exception.Throw(); return default; } void IUniTaskSource.GetResult(short token) { if (!calledGet) { calledGet = true; GC.SuppressFinalize(this); } exception.Throw(); } public UniTaskStatus GetStatus(short token) { return UniTaskStatus.Faulted; } public UniTaskStatus UnsafeGetStatus() { return UniTaskStatus.Faulted; } public void OnCompleted(Action continuation, object state, short token) { continuation(state); } ~ExceptionResultSource() { if (!calledGet) { UniTaskScheduler.PublishUnobservedTaskException(exception.SourceException); } } } sealed class CanceledResultSource : IUniTaskSource { readonly CancellationToken cancellationToken; public CanceledResultSource(CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; } public void GetResult(short token) { throw new OperationCanceledException(cancellationToken); } public UniTaskStatus GetStatus(short token) { return UniTaskStatus.Canceled; } public UniTaskStatus UnsafeGetStatus() { return UniTaskStatus.Canceled; } public void OnCompleted(Action continuation, object state, short token) { continuation(state); } } sealed class CanceledResultSource : IUniTaskSource { readonly CancellationToken cancellationToken; public CanceledResultSource(CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; } public T GetResult(short token) { throw new OperationCanceledException(cancellationToken); } void IUniTaskSource.GetResult(short token) { throw new OperationCanceledException(cancellationToken); } public UniTaskStatus GetStatus(short token) { return UniTaskStatus.Canceled; } public UniTaskStatus UnsafeGetStatus() { return UniTaskStatus.Canceled; } public void OnCompleted(Action continuation, object state, short token) { continuation(state); } } sealed class DeferPromise : IUniTaskSource { Func factory; UniTask task; UniTask.Awaiter awaiter; public DeferPromise(Func factory) { this.factory = factory; } public void GetResult(short token) { awaiter.GetResult(); } public UniTaskStatus GetStatus(short token) { var f = Interlocked.Exchange(ref factory, null); if (f != null) { task = f(); awaiter = task.GetAwaiter(); } return task.Status; } public void OnCompleted(Action continuation, object state, short token) { awaiter.SourceOnCompleted(continuation, state); } public UniTaskStatus UnsafeGetStatus() { return task.Status; } } sealed class DeferPromise : IUniTaskSource { Func> factory; UniTask task; UniTask.Awaiter awaiter; public DeferPromise(Func> factory) { this.factory = factory; } public T GetResult(short token) { return awaiter.GetResult(); } void IUniTaskSource.GetResult(short token) { awaiter.GetResult(); } public UniTaskStatus GetStatus(short token) { var f = Interlocked.Exchange(ref factory, null); if (f != null) { task = f(); awaiter = task.GetAwaiter(); } return task.Status; } public void OnCompleted(Action continuation, object state, short token) { awaiter.SourceOnCompleted(continuation, state); } public UniTaskStatus UnsafeGetStatus() { return task.Status; } } sealed class DeferPromiseWithState : IUniTaskSource { Func factory; TState argument; UniTask task; UniTask.Awaiter awaiter; public DeferPromiseWithState(TState argument, Func factory) { this.argument = argument; this.factory = factory; } public void GetResult(short token) { awaiter.GetResult(); } public UniTaskStatus GetStatus(short token) { var f = Interlocked.Exchange(ref factory, null); if (f != null) { task = f(argument); awaiter = task.GetAwaiter(); } return task.Status; } public void OnCompleted(Action continuation, object state, short token) { awaiter.SourceOnCompleted(continuation, state); } public UniTaskStatus UnsafeGetStatus() { return task.Status; } } sealed class DeferPromiseWithState : IUniTaskSource { Func> factory; TState argument; UniTask task; UniTask.Awaiter awaiter; public DeferPromiseWithState(TState argument, Func> factory) { this.argument = argument; this.factory = factory; } public TResult GetResult(short token) { return awaiter.GetResult(); } void IUniTaskSource.GetResult(short token) { awaiter.GetResult(); } public UniTaskStatus GetStatus(short token) { var f = Interlocked.Exchange(ref factory, null); if (f != null) { task = f(argument); awaiter = task.GetAwaiter(); } return task.Status; } public void OnCompleted(Action continuation, object state, short token) { awaiter.SourceOnCompleted(continuation, state); } public UniTaskStatus UnsafeGetStatus() { return task.Status; } } sealed class NeverPromise : IUniTaskSource { static readonly Action cancellationCallback = CancellationCallback; CancellationToken cancellationToken; UniTaskCompletionSourceCore core; public NeverPromise(CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; if (this.cancellationToken.CanBeCanceled) { this.cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this); } } static void CancellationCallback(object state) { var self = (NeverPromise)state; self.core.TrySetCanceled(self.cancellationToken); } public T GetResult(short token) { return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } void IUniTaskSource.GetResult(short token) { core.GetResult(token); } } } internal static class CompletedTasks { public static readonly UniTask AsyncUnit = UniTask.FromResult(Cysharp.Threading.Tasks.AsyncUnit.Default); public static readonly UniTask True = UniTask.FromResult(true); public static readonly UniTask False = UniTask.FromResult(false); public static readonly UniTask Zero = UniTask.FromResult(0); public static readonly UniTask MinusOne = UniTask.FromResult(-1); public static readonly UniTask One = UniTask.FromResult(1); } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Factory.cs.meta ================================================ fileFormatVersion: 2 guid: 4e12b66d6b9bd7845b04a594cbe386b4 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Run.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; namespace Cysharp.Threading.Tasks { public partial struct UniTask { #region OBSOLETE_RUN [Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")] public static UniTask Run(Action action, bool configureAwait = true, CancellationToken cancellationToken = default) { return RunOnThreadPool(action, configureAwait, cancellationToken); } [Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")] public static UniTask Run(Action action, object state, bool configureAwait = true, CancellationToken cancellationToken = default) { return RunOnThreadPool(action, state, configureAwait, cancellationToken); } [Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")] public static UniTask Run(Func action, bool configureAwait = true, CancellationToken cancellationToken = default) { return RunOnThreadPool(action, configureAwait, cancellationToken); } [Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")] public static UniTask Run(Func action, object state, bool configureAwait = true, CancellationToken cancellationToken = default) { return RunOnThreadPool(action, state, configureAwait, cancellationToken); } [Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")] public static UniTask Run(Func func, bool configureAwait = true, CancellationToken cancellationToken = default) { return RunOnThreadPool(func, configureAwait, cancellationToken); } [Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")] public static UniTask Run(Func> func, bool configureAwait = true, CancellationToken cancellationToken = default) { return RunOnThreadPool(func, configureAwait, cancellationToken); } [Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")] public static UniTask Run(Func func, object state, bool configureAwait = true, CancellationToken cancellationToken = default) { return RunOnThreadPool(func, state, configureAwait, cancellationToken); } [Obsolete("UniTask.Run is similar as Task.Run, it uses ThreadPool. For equivalent behaviour, use UniTask.RunOnThreadPool instead. If you don't want to use ThreadPool, you can use UniTask.Void(async void) or UniTask.Create(async UniTask) too.")] public static UniTask Run(Func> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default) { return RunOnThreadPool(func, state, configureAwait, cancellationToken); } #endregion /// Run action on the threadPool and return to main thread if configureAwait = true. public static async UniTask RunOnThreadPool(Action action, bool configureAwait = true, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await UniTask.SwitchToThreadPool(); cancellationToken.ThrowIfCancellationRequested(); if (configureAwait) { try { action(); } finally { await UniTask.Yield(); } } else { action(); } cancellationToken.ThrowIfCancellationRequested(); } /// Run action on the threadPool and return to main thread if configureAwait = true. public static async UniTask RunOnThreadPool(Action action, object state, bool configureAwait = true, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await UniTask.SwitchToThreadPool(); cancellationToken.ThrowIfCancellationRequested(); if (configureAwait) { try { action(state); } finally { await UniTask.Yield(); } } else { action(state); } cancellationToken.ThrowIfCancellationRequested(); } /// Run action on the threadPool and return to main thread if configureAwait = true. public static async UniTask RunOnThreadPool(Func action, bool configureAwait = true, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await UniTask.SwitchToThreadPool(); cancellationToken.ThrowIfCancellationRequested(); if (configureAwait) { try { await action(); } finally { await UniTask.Yield(); } } else { await action(); } cancellationToken.ThrowIfCancellationRequested(); } /// Run action on the threadPool and return to main thread if configureAwait = true. public static async UniTask RunOnThreadPool(Func action, object state, bool configureAwait = true, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await UniTask.SwitchToThreadPool(); cancellationToken.ThrowIfCancellationRequested(); if (configureAwait) { try { await action(state); } finally { await UniTask.Yield(); } } else { await action(state); } cancellationToken.ThrowIfCancellationRequested(); } /// Run action on the threadPool and return to main thread if configureAwait = true. public static async UniTask RunOnThreadPool(Func func, bool configureAwait = true, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await UniTask.SwitchToThreadPool(); cancellationToken.ThrowIfCancellationRequested(); if (configureAwait) { try { return func(); } finally { await UniTask.Yield(); cancellationToken.ThrowIfCancellationRequested(); } } else { return func(); } } /// Run action on the threadPool and return to main thread if configureAwait = true. public static async UniTask RunOnThreadPool(Func> func, bool configureAwait = true, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await UniTask.SwitchToThreadPool(); cancellationToken.ThrowIfCancellationRequested(); if (configureAwait) { try { return await func(); } finally { cancellationToken.ThrowIfCancellationRequested(); await UniTask.Yield(); cancellationToken.ThrowIfCancellationRequested(); } } else { var result = await func(); cancellationToken.ThrowIfCancellationRequested(); return result; } } /// Run action on the threadPool and return to main thread if configureAwait = true. public static async UniTask RunOnThreadPool(Func func, object state, bool configureAwait = true, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await UniTask.SwitchToThreadPool(); cancellationToken.ThrowIfCancellationRequested(); if (configureAwait) { try { return func(state); } finally { await UniTask.Yield(); cancellationToken.ThrowIfCancellationRequested(); } } else { return func(state); } } /// Run action on the threadPool and return to main thread if configureAwait = true. public static async UniTask RunOnThreadPool(Func> func, object state, bool configureAwait = true, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); await UniTask.SwitchToThreadPool(); cancellationToken.ThrowIfCancellationRequested(); if (configureAwait) { try { return await func(state); } finally { cancellationToken.ThrowIfCancellationRequested(); await UniTask.Yield(); cancellationToken.ThrowIfCancellationRequested(); } } else { var result = await func(state); cancellationToken.ThrowIfCancellationRequested(); return result; } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Run.cs.meta ================================================ fileFormatVersion: 2 guid: 8473162fc285a5f44bcca90f7da073e7 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Threading.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; using System.Threading; using System.Threading.Tasks; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public partial struct UniTask { #if UNITY_2018_3_OR_NEWER /// /// If running on mainthread, do nothing. Otherwise, same as UniTask.Yield(PlayerLoopTiming.Update). /// public static SwitchToMainThreadAwaitable SwitchToMainThread(CancellationToken cancellationToken = default) { return new SwitchToMainThreadAwaitable(PlayerLoopTiming.Update, cancellationToken); } /// /// If running on mainthread, do nothing. Otherwise, same as UniTask.Yield(timing). /// public static SwitchToMainThreadAwaitable SwitchToMainThread(PlayerLoopTiming timing, CancellationToken cancellationToken = default) { return new SwitchToMainThreadAwaitable(timing, cancellationToken); } /// /// Return to mainthread(same as await SwitchToMainThread) after using scope is closed. /// public static ReturnToMainThread ReturnToMainThread(CancellationToken cancellationToken = default) { return new ReturnToMainThread(PlayerLoopTiming.Update, cancellationToken); } /// /// Return to mainthread(same as await SwitchToMainThread) after using scope is closed. /// public static ReturnToMainThread ReturnToMainThread(PlayerLoopTiming timing, CancellationToken cancellationToken = default) { return new ReturnToMainThread(timing, cancellationToken); } /// /// Queue the action to PlayerLoop. /// public static void Post(Action action, PlayerLoopTiming timing = PlayerLoopTiming.Update) { PlayerLoopHelper.AddContinuation(timing, action); } #endif public static SwitchToThreadPoolAwaitable SwitchToThreadPool() { return new SwitchToThreadPoolAwaitable(); } /// /// Note: use SwitchToThreadPool is recommended. /// public static SwitchToTaskPoolAwaitable SwitchToTaskPool() { return new SwitchToTaskPoolAwaitable(); } public static SwitchToSynchronizationContextAwaitable SwitchToSynchronizationContext(SynchronizationContext synchronizationContext, CancellationToken cancellationToken = default) { Error.ThrowArgumentNullException(synchronizationContext, nameof(synchronizationContext)); return new SwitchToSynchronizationContextAwaitable(synchronizationContext, cancellationToken); } public static ReturnToSynchronizationContext ReturnToSynchronizationContext(SynchronizationContext synchronizationContext, CancellationToken cancellationToken = default) { return new ReturnToSynchronizationContext(synchronizationContext, false, cancellationToken); } public static ReturnToSynchronizationContext ReturnToCurrentSynchronizationContext(bool dontPostWhenSameContext = true, CancellationToken cancellationToken = default) { return new ReturnToSynchronizationContext(SynchronizationContext.Current, dontPostWhenSameContext, cancellationToken); } } #if UNITY_2018_3_OR_NEWER public struct SwitchToMainThreadAwaitable { readonly PlayerLoopTiming playerLoopTiming; readonly CancellationToken cancellationToken; public SwitchToMainThreadAwaitable(PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken) { this.playerLoopTiming = playerLoopTiming; this.cancellationToken = cancellationToken; } public Awaiter GetAwaiter() => new Awaiter(playerLoopTiming, cancellationToken); public struct Awaiter : ICriticalNotifyCompletion { readonly PlayerLoopTiming playerLoopTiming; readonly CancellationToken cancellationToken; public Awaiter(PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken) { this.playerLoopTiming = playerLoopTiming; this.cancellationToken = cancellationToken; } public bool IsCompleted { get { var currentThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId; if (PlayerLoopHelper.MainThreadId == currentThreadId) { return true; // run immediate. } else { return false; // register continuation. } } } public void GetResult() { cancellationToken.ThrowIfCancellationRequested(); } public void OnCompleted(Action continuation) { PlayerLoopHelper.AddContinuation(playerLoopTiming, continuation); } public void UnsafeOnCompleted(Action continuation) { PlayerLoopHelper.AddContinuation(playerLoopTiming, continuation); } } } public struct ReturnToMainThread { readonly PlayerLoopTiming playerLoopTiming; readonly CancellationToken cancellationToken; public ReturnToMainThread(PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken) { this.playerLoopTiming = playerLoopTiming; this.cancellationToken = cancellationToken; } public Awaiter DisposeAsync() { return new Awaiter(playerLoopTiming, cancellationToken); // run immediate. } public readonly struct Awaiter : ICriticalNotifyCompletion { readonly PlayerLoopTiming timing; readonly CancellationToken cancellationToken; public Awaiter(PlayerLoopTiming timing, CancellationToken cancellationToken) { this.timing = timing; this.cancellationToken = cancellationToken; } public Awaiter GetAwaiter() => this; public bool IsCompleted => PlayerLoopHelper.MainThreadId == System.Threading.Thread.CurrentThread.ManagedThreadId; public void GetResult() { cancellationToken.ThrowIfCancellationRequested(); } public void OnCompleted(Action continuation) { PlayerLoopHelper.AddContinuation(timing, continuation); } public void UnsafeOnCompleted(Action continuation) { PlayerLoopHelper.AddContinuation(timing, continuation); } } } #endif public struct SwitchToThreadPoolAwaitable { public Awaiter GetAwaiter() => new Awaiter(); public struct Awaiter : ICriticalNotifyCompletion { static readonly WaitCallback switchToCallback = Callback; public bool IsCompleted => false; public void GetResult() { } public void OnCompleted(Action continuation) { ThreadPool.QueueUserWorkItem(switchToCallback, continuation); } public void UnsafeOnCompleted(Action continuation) { #if NETCOREAPP3_1 ThreadPool.UnsafeQueueUserWorkItem(ThreadPoolWorkItem.Create(continuation), false); #else ThreadPool.UnsafeQueueUserWorkItem(switchToCallback, continuation); #endif } static void Callback(object state) { var continuation = (Action)state; continuation(); } } #if NETCOREAPP3_1 sealed class ThreadPoolWorkItem : IThreadPoolWorkItem, ITaskPoolNode { static TaskPool pool; ThreadPoolWorkItem nextNode; public ref ThreadPoolWorkItem NextNode => ref nextNode; static ThreadPoolWorkItem() { TaskPool.RegisterSizeGetter(typeof(ThreadPoolWorkItem), () => pool.Size); } Action continuation; [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ThreadPoolWorkItem Create(Action continuation) { if (!pool.TryPop(out var item)) { item = new ThreadPoolWorkItem(); } item.continuation = continuation; return item; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Execute() { var call = continuation; continuation = null; if (call != null) { pool.TryPush(this); call.Invoke(); } } } #endif } public struct SwitchToTaskPoolAwaitable { public Awaiter GetAwaiter() => new Awaiter(); public struct Awaiter : ICriticalNotifyCompletion { static readonly Action switchToCallback = Callback; public bool IsCompleted => false; public void GetResult() { } public void OnCompleted(Action continuation) { Task.Factory.StartNew(switchToCallback, continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); } public void UnsafeOnCompleted(Action continuation) { Task.Factory.StartNew(switchToCallback, continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); } static void Callback(object state) { var continuation = (Action)state; continuation(); } } } public struct SwitchToSynchronizationContextAwaitable { readonly SynchronizationContext synchronizationContext; readonly CancellationToken cancellationToken; public SwitchToSynchronizationContextAwaitable(SynchronizationContext synchronizationContext, CancellationToken cancellationToken) { this.synchronizationContext = synchronizationContext; this.cancellationToken = cancellationToken; } public Awaiter GetAwaiter() => new Awaiter(synchronizationContext, cancellationToken); public struct Awaiter : ICriticalNotifyCompletion { static readonly SendOrPostCallback switchToCallback = Callback; readonly SynchronizationContext synchronizationContext; readonly CancellationToken cancellationToken; public Awaiter(SynchronizationContext synchronizationContext, CancellationToken cancellationToken) { this.synchronizationContext = synchronizationContext; this.cancellationToken = cancellationToken; } public bool IsCompleted => false; public void GetResult() { cancellationToken.ThrowIfCancellationRequested(); } public void OnCompleted(Action continuation) { synchronizationContext.Post(switchToCallback, continuation); } public void UnsafeOnCompleted(Action continuation) { synchronizationContext.Post(switchToCallback, continuation); } static void Callback(object state) { var continuation = (Action)state; continuation(); } } } public struct ReturnToSynchronizationContext { readonly SynchronizationContext syncContext; readonly bool dontPostWhenSameContext; readonly CancellationToken cancellationToken; public ReturnToSynchronizationContext(SynchronizationContext syncContext, bool dontPostWhenSameContext, CancellationToken cancellationToken) { this.syncContext = syncContext; this.dontPostWhenSameContext = dontPostWhenSameContext; this.cancellationToken = cancellationToken; } public Awaiter DisposeAsync() { return new Awaiter(syncContext, dontPostWhenSameContext, cancellationToken); } public struct Awaiter : ICriticalNotifyCompletion { static readonly SendOrPostCallback switchToCallback = Callback; readonly SynchronizationContext synchronizationContext; readonly bool dontPostWhenSameContext; readonly CancellationToken cancellationToken; public Awaiter(SynchronizationContext synchronizationContext, bool dontPostWhenSameContext, CancellationToken cancellationToken) { this.synchronizationContext = synchronizationContext; this.dontPostWhenSameContext = dontPostWhenSameContext; this.cancellationToken = cancellationToken; } public Awaiter GetAwaiter() => this; public bool IsCompleted { get { if (!dontPostWhenSameContext) return false; var current = SynchronizationContext.Current; if (current == synchronizationContext) { return true; } else { return false; } } } public void GetResult() { cancellationToken.ThrowIfCancellationRequested(); } public void OnCompleted(Action continuation) { synchronizationContext.Post(switchToCallback, continuation); } public void UnsafeOnCompleted(Action continuation) { synchronizationContext.Post(switchToCallback, continuation); } static void Callback(object state) { var continuation = (Action)state; continuation(); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Threading.cs.meta ================================================ fileFormatVersion: 2 guid: 4132ea600454134439fa2c7eb931b5e6 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WaitUntil.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Diagnostics.Tracing; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public partial struct UniTask { public static UniTask WaitUntil(Func predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { return new UniTask(WaitUntilPromise.Create(predicate, timing, cancellationToken, cancelImmediately, out var token), token); } public static UniTask WaitUntil(T state, Func predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { return new UniTask(WaitUntilPromise.Create(state, predicate, timing, cancellationToken, cancelImmediately, out var token), token); } public static UniTask WaitWhile(Func predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { return new UniTask(WaitWhilePromise.Create(predicate, timing, cancellationToken, cancelImmediately, out var token), token); } public static UniTask WaitWhile(T state, Func predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { return new UniTask(WaitWhilePromise.Create(state, predicate, timing, cancellationToken, cancelImmediately, out var token), token); } public static UniTask WaitUntilCanceled(CancellationToken cancellationToken, PlayerLoopTiming timing = PlayerLoopTiming.Update, bool completeImmediately = false) { return new UniTask(WaitUntilCanceledPromise.Create(cancellationToken, timing, completeImmediately, out var token), token); } public static UniTask WaitUntilValueChanged(T target, Func monitorFunction, PlayerLoopTiming monitorTiming = PlayerLoopTiming.Update, IEqualityComparer equalityComparer = null, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) where T : class { var unityObject = target as UnityEngine.Object; var isUnityObject = target is UnityEngine.Object; // don't use (unityObject == null) return new UniTask(isUnityObject ? WaitUntilValueChangedUnityObjectPromise.Create(target, monitorFunction, equalityComparer, monitorTiming, cancellationToken, cancelImmediately, out var token) : WaitUntilValueChangedStandardObjectPromise.Create(target, monitorFunction, equalityComparer, monitorTiming, cancellationToken, cancelImmediately, out token), token); } sealed class WaitUntilPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; WaitUntilPromise nextNode; public ref WaitUntilPromise NextNode => ref nextNode; static WaitUntilPromise() { TaskPool.RegisterSizeGetter(typeof(WaitUntilPromise), () => pool.Size); } Func predicate; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; WaitUntilPromise() { } public static IUniTaskSource Create(Func predicate, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitUntilPromise(); } result.predicate = predicate; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (WaitUntilPromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } try { if (!predicate()) { return true; } } catch (Exception ex) { core.TrySetException(ex); return false; } core.TrySetResult(null); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); predicate = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class WaitUntilPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode> { static TaskPool> pool; WaitUntilPromise nextNode; public ref WaitUntilPromise NextNode => ref nextNode; static WaitUntilPromise() { TaskPool.RegisterSizeGetter(typeof(WaitUntilPromise), () => pool.Size); } Func predicate; T argument; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; WaitUntilPromise() { } public static IUniTaskSource Create(T argument, Func predicate, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitUntilPromise(); } result.predicate = predicate; result.argument = argument; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (WaitUntilPromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } try { if (!predicate(argument)) { return true; } } catch (Exception ex) { core.TrySetException(ex); return false; } core.TrySetResult(null); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); predicate = default; argument = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class WaitWhilePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; WaitWhilePromise nextNode; public ref WaitWhilePromise NextNode => ref nextNode; static WaitWhilePromise() { TaskPool.RegisterSizeGetter(typeof(WaitWhilePromise), () => pool.Size); } Func predicate; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; WaitWhilePromise() { } public static IUniTaskSource Create(Func predicate, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitWhilePromise(); } result.predicate = predicate; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (WaitWhilePromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } try { if (predicate()) { return true; } } catch (Exception ex) { core.TrySetException(ex); return false; } core.TrySetResult(null); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); predicate = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class WaitWhilePromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode> { static TaskPool> pool; WaitWhilePromise nextNode; public ref WaitWhilePromise NextNode => ref nextNode; static WaitWhilePromise() { TaskPool.RegisterSizeGetter(typeof(WaitWhilePromise), () => pool.Size); } Func predicate; T argument; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; WaitWhilePromise() { } public static IUniTaskSource Create(T argument, Func predicate, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitWhilePromise(); } result.predicate = predicate; result.argument = argument; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (WaitWhilePromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } try { if (predicate(argument)) { return true; } } catch (Exception ex) { core.TrySetException(ex); return false; } core.TrySetResult(null); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); predicate = default; argument = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class WaitUntilCanceledPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; WaitUntilCanceledPromise nextNode; public ref WaitUntilCanceledPromise NextNode => ref nextNode; static WaitUntilCanceledPromise() { TaskPool.RegisterSizeGetter(typeof(WaitUntilCanceledPromise), () => pool.Size); } CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; WaitUntilCanceledPromise() { } public static IUniTaskSource Create(CancellationToken cancellationToken, PlayerLoopTiming timing, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitUntilCanceledPromise(); } result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (WaitUntilCanceledPromise)state; promise.core.TrySetResult(null); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetResult(null); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } // where T : UnityEngine.Object, can not add constraint sealed class WaitUntilValueChangedUnityObjectPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode> { static TaskPool> pool; WaitUntilValueChangedUnityObjectPromise nextNode; public ref WaitUntilValueChangedUnityObjectPromise NextNode => ref nextNode; static WaitUntilValueChangedUnityObjectPromise() { TaskPool.RegisterSizeGetter(typeof(WaitUntilValueChangedUnityObjectPromise), () => pool.Size); } T target; UnityEngine.Object targetAsUnityObject; U currentValue; Func monitorFunction; IEqualityComparer equalityComparer; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; WaitUntilValueChangedUnityObjectPromise() { } public static IUniTaskSource Create(T target, Func monitorFunction, IEqualityComparer equalityComparer, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitUntilValueChangedUnityObjectPromise(); } result.target = target; result.targetAsUnityObject = target as UnityEngine.Object; result.monitorFunction = monitorFunction; result.currentValue = monitorFunction(target); result.equalityComparer = equalityComparer ?? UnityEqualityComparer.GetDefault(); result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (WaitUntilValueChangedUnityObjectPromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public U GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested || targetAsUnityObject == null) // destroyed = cancel. { core.TrySetCanceled(cancellationToken); return false; } U nextValue = default(U); try { nextValue = monitorFunction(target); if (equalityComparer.Equals(currentValue, nextValue)) { return true; } } catch (Exception ex) { core.TrySetException(ex); return false; } core.TrySetResult(nextValue); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); target = default; currentValue = default; monitorFunction = default; equalityComparer = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } sealed class WaitUntilValueChangedStandardObjectPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode> where T : class { static TaskPool> pool; WaitUntilValueChangedStandardObjectPromise nextNode; public ref WaitUntilValueChangedStandardObjectPromise NextNode => ref nextNode; static WaitUntilValueChangedStandardObjectPromise() { TaskPool.RegisterSizeGetter(typeof(WaitUntilValueChangedStandardObjectPromise), () => pool.Size); } WeakReference target; U currentValue; Func monitorFunction; IEqualityComparer equalityComparer; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; WaitUntilValueChangedStandardObjectPromise() { } public static IUniTaskSource Create(T target, Func monitorFunction, IEqualityComparer equalityComparer, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new WaitUntilValueChangedStandardObjectPromise(); } result.target = new WeakReference(target, false); // wrap in WeakReference. result.monitorFunction = monitorFunction; result.currentValue = monitorFunction(target); result.equalityComparer = equalityComparer ?? UnityEqualityComparer.GetDefault(); result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (WaitUntilValueChangedStandardObjectPromise)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public U GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested || !target.TryGetTarget(out var t)) // doesn't find = cancel. { core.TrySetCanceled(cancellationToken); return false; } U nextValue = default(U); try { nextValue = monitorFunction(t); if (equalityComparer.Equals(currentValue, nextValue)) { return true; } } catch (Exception ex) { core.TrySetException(ex); return false; } core.TrySetResult(nextValue); return false; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); target = default; currentValue = default; monitorFunction = default; equalityComparer = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WaitUntil.cs.meta ================================================ fileFormatVersion: 2 guid: 87c9c533491903a4288536b5ac173db8 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAll.Generated.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public partial struct UniTask { public static UniTask<(T1, T2)> WhenAll(UniTask task1, UniTask task2) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult())); } return new UniTask<(T1, T2)>(new WhenAllPromise(task1, task2), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2)> { T1 t1 = default; T2 t2 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2)> core; public WhenAllPromise(UniTask task1, UniTask task2) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 2) { self.core.TrySetResult((self.t1, self.t2)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 2) { self.core.TrySetResult((self.t1, self.t2)); } } public (T1, T2) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3)> WhenAll(UniTask task1, UniTask task2, UniTask task3) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3)>(new WhenAllPromise(task1, task2, task3), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 3) { self.core.TrySetResult((self.t1, self.t2, self.t3)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 3) { self.core.TrySetResult((self.t1, self.t2, self.t3)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 3) { self.core.TrySetResult((self.t1, self.t2, self.t3)); } } public (T1, T2, T3) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4)>(new WhenAllPromise(task1, task2, task3, task4), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 4) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 4) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 4) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 4) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4)); } } public (T1, T2, T3, T4) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5)>(new WhenAllPromise(task1, task2, task3, task4, task5), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 5) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 5) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 5) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 5) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 5) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5)); } } public (T1, T2, T3, T4, T5) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 6) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 6) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 6) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 6) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 6) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 6) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6)); } } public (T1, T2, T3, T4, T5, T6) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 7) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 7) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 7) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 7) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 7) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 7) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 7) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7)); } } public (T1, T2, T3, T4, T5, T6, T7) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7, task8), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; T8 t8 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 8) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 8) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 8) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 8) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 8) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 8) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 8) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8)); } } static void TryInvokeContinuationT8(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t8 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 8) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8)); } } public (T1, T2, T3, T4, T5, T6, T7, T8) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; T8 t8 = default; T9 t9 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } static void TryInvokeContinuationT8(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t8 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } static void TryInvokeContinuationT9(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t9 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 9) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9)); } } public (T1, T2, T3, T4, T5, T6, T7, T8, T9) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; T8 t8 = default; T9 t9 = default; T10 t10 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT8(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t8 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT9(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t9 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } static void TryInvokeContinuationT10(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t10 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 10) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10)); } } public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; T8 t8 = default; T9 t9 = default; T10 t10 = default; T11 t11 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT8(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t8 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT9(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t9 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT10(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t10 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } static void TryInvokeContinuationT11(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t11 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 11) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11)); } } public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully() && task12.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult(), task12.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; T8 t8 = default; T9 t9 = default; T10 t10 = default; T11 t11 = default; T12 t12 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task12.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT12(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT12(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT8(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t8 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT9(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t9 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT10(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t10 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT11(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t11 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } static void TryInvokeContinuationT12(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t12 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 12) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12)); } } public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully() && task12.Status.IsCompletedSuccessfully() && task13.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult(), task12.GetAwaiter().GetResult(), task13.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; T8 t8 = default; T9 t9 = default; T10 t10 = default; T11 t11 = default; T12 t12 = default; T13 t13 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task12.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT12(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT12(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task13.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT13(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT13(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT8(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t8 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT9(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t9 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT10(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t10 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT11(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t11 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT12(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t12 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } static void TryInvokeContinuationT13(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t13 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 13) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13)); } } public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully() && task12.Status.IsCompletedSuccessfully() && task13.Status.IsCompletedSuccessfully() && task14.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult(), task12.GetAwaiter().GetResult(), task13.GetAwaiter().GetResult(), task14.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13, task14), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; T8 t8 = default; T9 t9 = default; T10 t10 = default; T11 t11 = default; T12 t12 = default; T13 t13 = default; T14 t14 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task12.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT12(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT12(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task13.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT13(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT13(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task14.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT14(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT14(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT8(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t8 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT9(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t9 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT10(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t10 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT11(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t11 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT12(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t12 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT13(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t13 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } static void TryInvokeContinuationT14(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t14 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 14) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14)); } } public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> WhenAll(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14, UniTask task15) { if (task1.Status.IsCompletedSuccessfully() && task2.Status.IsCompletedSuccessfully() && task3.Status.IsCompletedSuccessfully() && task4.Status.IsCompletedSuccessfully() && task5.Status.IsCompletedSuccessfully() && task6.Status.IsCompletedSuccessfully() && task7.Status.IsCompletedSuccessfully() && task8.Status.IsCompletedSuccessfully() && task9.Status.IsCompletedSuccessfully() && task10.Status.IsCompletedSuccessfully() && task11.Status.IsCompletedSuccessfully() && task12.Status.IsCompletedSuccessfully() && task13.Status.IsCompletedSuccessfully() && task14.Status.IsCompletedSuccessfully() && task15.Status.IsCompletedSuccessfully()) { return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>((task1.GetAwaiter().GetResult(), task2.GetAwaiter().GetResult(), task3.GetAwaiter().GetResult(), task4.GetAwaiter().GetResult(), task5.GetAwaiter().GetResult(), task6.GetAwaiter().GetResult(), task7.GetAwaiter().GetResult(), task8.GetAwaiter().GetResult(), task9.GetAwaiter().GetResult(), task10.GetAwaiter().GetResult(), task11.GetAwaiter().GetResult(), task12.GetAwaiter().GetResult(), task13.GetAwaiter().GetResult(), task14.GetAwaiter().GetResult(), task15.GetAwaiter().GetResult())); } return new UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>(new WhenAllPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13, task14, task15), 0); } sealed class WhenAllPromise : IUniTaskSource<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> { T1 t1 = default; T2 t2 = default; T3 t3 = default; T4 t4 = default; T5 t5 = default; T6 t6 = default; T7 t7 = default; T8 t8 = default; T9 t9 = default; T10 t10 = default; T11 t11 = default; T12 t12 = default; T13 t13 = default; T14 t14 = default; T15 t15 = default; int completedCount; UniTaskCompletionSourceCore<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> core; public WhenAllPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14, UniTask task15) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task12.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT12(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT12(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task13.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT13(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT13(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task14.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT14(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT14(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task15.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT15(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT15(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t1 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT2(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t2 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT3(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t3 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT4(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t4 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT5(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t5 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT6(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t6 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT7(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t7 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT8(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t8 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT9(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t9 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT10(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t10 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT11(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t11 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT12(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t12 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT13(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t13 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT14(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t14 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } static void TryInvokeContinuationT15(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { self.t15 = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 15) { self.core.TrySetResult((self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, self.t11, self.t12, self.t13, self.t14, self.t15)); } } public (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAll.Generated.cs.meta ================================================ fileFormatVersion: 2 guid: 5110117231c8a6d4095fd0cbd3f4c142 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAll.Generated.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public partial struct UniTask { <# for(var i = 2; i <= 15; i++ ) { var range = Enumerable.Range(1, i); var t = string.Join(", ", range.Select(x => "T" + x)); var args = string.Join(", ", range.Select(x => $"UniTask task{x}")); var targs = string.Join(", ", range.Select(x => $"task{x}")); var tresult = string.Join(", ", range.Select(x => $"task{x}.GetAwaiter().GetResult()")); var completedSuccessfullyAnd = string.Join(" && ", range.Select(x => $"task{x}.Status.IsCompletedSuccessfully()")); var tfield = string.Join(", ", range.Select(x => $"self.t{x}")); #> public static UniTask<(<#= t #>)> WhenAll<<#= t #>>(<#= args #>) { if (<#= completedSuccessfullyAnd #>) { return new UniTask<(<#= t #>)>((<#= tresult #>)); } return new UniTask<(<#= t #>)>(new WhenAllPromise<<#= t #>>(<#= targs #>), 0); } sealed class WhenAllPromise<<#= t #>> : IUniTaskSource<(<#= t #>)> { <# for(var j = 1; j <= i; j++) { #> T<#= j #> t<#= j #> = default; <# } #> int completedCount; UniTaskCompletionSourceCore<(<#= t #>)> core; public WhenAllPromise(<#= args #>) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; <# for(var j = 1; j <= i; j++) { #> { var awaiter = task<#= j #>.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT<#= j #>(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple>, UniTask>.Awaiter>)state) { TryInvokeContinuationT<#= j #>(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } <# } #> } <# for(var j = 1; j <= i; j++) { #> static void TryInvokeContinuationT<#= j #>(WhenAllPromise<<#= t #>> self, in UniTask>.Awaiter awaiter) { try { self.t<#= j #> = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == <#= i #>) { self.core.TrySetResult((<#= tfield #>)); } } <# } #> public (<#= t #>) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } <# } #> } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAll.Generated.tt.meta ================================================ fileFormatVersion: 2 guid: 2c2ecfd98ee1b9a4c9fae1b398c32d75 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAll.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public partial struct UniTask { public static UniTask WhenAll(params UniTask[] tasks) { if (tasks.Length == 0) { return UniTask.FromResult(Array.Empty()); } return new UniTask(new WhenAllPromise(tasks, tasks.Length), 0); } public static UniTask WhenAll(IEnumerable> tasks) { using (var span = ArrayPoolUtil.Materialize(tasks)) { var promise = new WhenAllPromise(span.Array, span.Length); // consumed array in constructor. return new UniTask(promise, 0); } } public static UniTask WhenAll(params UniTask[] tasks) { if (tasks.Length == 0) { return UniTask.CompletedTask; } return new UniTask(new WhenAllPromise(tasks, tasks.Length), 0); } public static UniTask WhenAll(IEnumerable tasks) { using (var span = ArrayPoolUtil.Materialize(tasks)) { var promise = new WhenAllPromise(span.Array, span.Length); // consumed array in constructor. return new UniTask(promise, 0); } } sealed class WhenAllPromise : IUniTaskSource { T[] result; int completeCount; UniTaskCompletionSourceCore core; // don't reset(called after GetResult, will invoke TrySetException.) public WhenAllPromise(UniTask[] tasks, int tasksLength) { TaskTracker.TrackActiveTask(this, 3); this.completeCount = 0; if (tasksLength == 0) { this.result = Array.Empty(); core.TrySetResult(result); return; } this.result = new T[tasksLength]; for (int i = 0; i < tasksLength; i++) { UniTask.Awaiter awaiter; try { awaiter = tasks[i].GetAwaiter(); } catch (Exception ex) { core.TrySetException(ex); continue; } if (awaiter.IsCompleted) { TryInvokeContinuation(this, awaiter, i); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter, int>)state) { TryInvokeContinuation(t.Item1, t.Item2, t.Item3); } }, StateTuple.Create(this, awaiter, i)); } } } static void TryInvokeContinuation(WhenAllPromise self, in UniTask.Awaiter awaiter, int i) { try { self.result[i] = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completeCount) == self.result.Length) { self.core.TrySetResult(self.result); } } public T[] GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } sealed class WhenAllPromise : IUniTaskSource { int completeCount; int tasksLength; UniTaskCompletionSourceCore core; // don't reset(called after GetResult, will invoke TrySetException.) public WhenAllPromise(UniTask[] tasks, int tasksLength) { TaskTracker.TrackActiveTask(this, 3); this.tasksLength = tasksLength; this.completeCount = 0; if (tasksLength == 0) { core.TrySetResult(AsyncUnit.Default); return; } for (int i = 0; i < tasksLength; i++) { UniTask.Awaiter awaiter; try { awaiter = tasks[i].GetAwaiter(); } catch (Exception ex) { core.TrySetException(ex); continue; } if (awaiter.IsCompleted) { TryInvokeContinuation(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple)state) { TryInvokeContinuation(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuation(WhenAllPromise self, in UniTask.Awaiter awaiter) { try { awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completeCount) == self.tasksLength) { self.core.TrySetResult(AsyncUnit.Default); } } public void GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAll.cs.meta ================================================ fileFormatVersion: 2 guid: 355997a305ba64248822eec34998a1a0 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAny.Generated.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public partial struct UniTask { public static UniTask<(int winArgumentIndex, T1 result1, T2 result2)> WhenAny(UniTask task1, UniTask task2) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2)>(new WhenAnyPromise(task1, task2), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2)> core; public WhenAnyPromise(UniTask task1, UniTask task2) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result)); } } public (int, T1 result1, T2 result2) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3)> WhenAny(UniTask task1, UniTask task2, UniTask task3) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3)>(new WhenAnyPromise(task1, task2, task3), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4)>(new WhenAnyPromise(task1, task2, task3, task4), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)>(new WhenAnyPromise(task1, task2, task3, task4, task5), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7, task8), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT8(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T8 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((7, default, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT8(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T8 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((7, default, default, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT9(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T9 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((8, default, default, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT8(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T8 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((7, default, default, default, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT9(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T9 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((8, default, default, default, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT10(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T10 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((9, default, default, default, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT8(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T8 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((7, default, default, default, default, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT9(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T9 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((8, default, default, default, default, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT10(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T10 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((9, default, default, default, default, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT11(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T11 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((10, default, default, default, default, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task12.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT12(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT12(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT8(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T8 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((7, default, default, default, default, default, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT9(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T9 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((8, default, default, default, default, default, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT10(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T10 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((9, default, default, default, default, default, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT11(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T11 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((10, default, default, default, default, default, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT12(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T12 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((11, default, default, default, default, default, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task12.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT12(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT12(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task13.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT13(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT13(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT8(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T8 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((7, default, default, default, default, default, default, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT9(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T9 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((8, default, default, default, default, default, default, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT10(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T10 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((9, default, default, default, default, default, default, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT11(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T11 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((10, default, default, default, default, default, default, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT12(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T12 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((11, default, default, default, default, default, default, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT13(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T13 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((12, default, default, default, default, default, default, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13, task14), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task12.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT12(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT12(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task13.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT13(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT13(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task14.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT14(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT14(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT8(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T8 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((7, default, default, default, default, default, default, default, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT9(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T9 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((8, default, default, default, default, default, default, default, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT10(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T10 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((9, default, default, default, default, default, default, default, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT11(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T11 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((10, default, default, default, default, default, default, default, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT12(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T12 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((11, default, default, default, default, default, default, default, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT13(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T13 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((12, default, default, default, default, default, default, default, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT14(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T14 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((13, default, default, default, default, default, default, default, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } public static UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15)> WhenAny(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14, UniTask task15) { return new UniTask<(int winArgumentIndex, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15)>(new WhenAnyPromise(task1, task2, task3, task4, task5, task6, task7, task8, task9, task10, task11, task12, task13, task14, task15), 0); } sealed class WhenAnyPromise : IUniTaskSource<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15)> { int completedCount; UniTaskCompletionSourceCore<(int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15)> core; public WhenAnyPromise(UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14, UniTask task15) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; { var awaiter = task1.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT1(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT1(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task2.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT2(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT2(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task3.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT3(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT3(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task4.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT4(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT4(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task5.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT5(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT5(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task6.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT6(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT6(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task7.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT7(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT7(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task8.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT8(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT8(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task9.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT9(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT9(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task10.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT10(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT10(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task11.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT11(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT11(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task12.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT12(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT12(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task13.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT13(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT13(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task14.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT14(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT14(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } { var awaiter = task15.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT15(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryInvokeContinuationT15(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryInvokeContinuationT1(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T1 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((0, result, default, default, default, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT2(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T2 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((1, default, result, default, default, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT3(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T3 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((2, default, default, result, default, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT4(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T4 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((3, default, default, default, result, default, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT5(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T5 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((4, default, default, default, default, result, default, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT6(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T6 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((5, default, default, default, default, default, result, default, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT7(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T7 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((6, default, default, default, default, default, default, result, default, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT8(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T8 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((7, default, default, default, default, default, default, default, result, default, default, default, default, default, default, default)); } } static void TryInvokeContinuationT9(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T9 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((8, default, default, default, default, default, default, default, default, result, default, default, default, default, default, default)); } } static void TryInvokeContinuationT10(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T10 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((9, default, default, default, default, default, default, default, default, default, result, default, default, default, default, default)); } } static void TryInvokeContinuationT11(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T11 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((10, default, default, default, default, default, default, default, default, default, default, result, default, default, default, default)); } } static void TryInvokeContinuationT12(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T12 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((11, default, default, default, default, default, default, default, default, default, default, default, result, default, default, default)); } } static void TryInvokeContinuationT13(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T13 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((12, default, default, default, default, default, default, default, default, default, default, default, default, result, default, default)); } } static void TryInvokeContinuationT14(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T14 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((13, default, default, default, default, default, default, default, default, default, default, default, default, default, result, default)); } } static void TryInvokeContinuationT15(WhenAnyPromise self, in UniTask.Awaiter awaiter) { T15 result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((14, default, default, default, default, default, default, default, default, default, default, default, default, default, default, result)); } } public (int, T1 result1, T2 result2, T3 result3, T4 result4, T5 result5, T6 result6, T7 result7, T8 result8, T9 result9, T10 result10, T11 result11, T12 result12, T13 result13, T14 result14, T15 result15) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAny.Generated.cs.meta ================================================ fileFormatVersion: 2 guid: 13d604ac281570c4eac9962429f19ca9 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAny.Generated.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public partial struct UniTask { <# for(var i = 2; i <= 15; i++ ) { var range = Enumerable.Range(1, i); var t = string.Join(", ", range.Select(x => "T" + x)); var args = string.Join(", ", range.Select(x => $"UniTask task{x}")); var targs = string.Join(", ", range.Select(x => $"task{x}")); var tresult = string.Join(", ", range.Select(x => $"task{x}.GetAwaiter().GetResult()")); var tBool = string.Join(", ", range.Select(x => $"T{x} result{x}")); var tfield = string.Join(", ", range.Select(x => $"self.t{x}")); Func getResult = j => string.Join(", ", range.Select(x => (x == j) ? "result" : "default")); #> public static UniTask<(int winArgumentIndex, <#= tBool #>)> WhenAny<<#= t #>>(<#= args #>) { return new UniTask<(int winArgumentIndex, <#= tBool #>)>(new WhenAnyPromise<<#= t #>>(<#= targs #>), 0); } sealed class WhenAnyPromise<<#= t #>> : IUniTaskSource<(int, <#= tBool #>)> { int completedCount; UniTaskCompletionSourceCore<(int, <#= tBool #>)> core; public WhenAnyPromise(<#= args #>) { TaskTracker.TrackActiveTask(this, 3); this.completedCount = 0; <# for(var j = 1; j <= i; j++) { #> { var awaiter = task<#= j #>.GetAwaiter(); if (awaiter.IsCompleted) { TryInvokeContinuationT<#= j #>(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple>, UniTask>.Awaiter>)state) { TryInvokeContinuationT<#= j #>(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } <# } #> } <# for(var j = 1; j <= i; j++) { #> static void TryInvokeContinuationT<#= j #>(WhenAnyPromise<<#= t #>> self, in UniTask>.Awaiter awaiter) { T<#= j #> result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((<#= j - 1 #>, <#= getResult(j) #>)); } } <# } #> public (int, <#= tBool #>) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } <# } #> } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAny.Generated.tt.meta ================================================ fileFormatVersion: 2 guid: 71c2c0bce7543454c8ef545083e18170 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAny.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public partial struct UniTask { public static UniTask<(bool hasResultLeft, T result)> WhenAny(UniTask leftTask, UniTask rightTask) { return new UniTask<(bool, T)>(new WhenAnyLRPromise(leftTask, rightTask), 0); } public static UniTask<(int winArgumentIndex, T result)> WhenAny(params UniTask[] tasks) { return new UniTask<(int, T)>(new WhenAnyPromise(tasks, tasks.Length), 0); } public static UniTask<(int winArgumentIndex, T result)> WhenAny(IEnumerable> tasks) { using (var span = ArrayPoolUtil.Materialize(tasks)) { return new UniTask<(int, T)>(new WhenAnyPromise(span.Array, span.Length), 0); } } /// Return value is winArgumentIndex public static UniTask WhenAny(params UniTask[] tasks) { return new UniTask(new WhenAnyPromise(tasks, tasks.Length), 0); } /// Return value is winArgumentIndex public static UniTask WhenAny(IEnumerable tasks) { using (var span = ArrayPoolUtil.Materialize(tasks)) { return new UniTask(new WhenAnyPromise(span.Array, span.Length), 0); } } sealed class WhenAnyLRPromise : IUniTaskSource<(bool, T)> { int completedCount; UniTaskCompletionSourceCore<(bool, T)> core; public WhenAnyLRPromise(UniTask leftTask, UniTask rightTask) { TaskTracker.TrackActiveTask(this, 3); { UniTask.Awaiter awaiter; try { awaiter = leftTask.GetAwaiter(); } catch (Exception ex) { core.TrySetException(ex); goto RIGHT; } if (awaiter.IsCompleted) { TryLeftInvokeContinuation(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryLeftInvokeContinuation(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } RIGHT: { UniTask.Awaiter awaiter; try { awaiter = rightTask.GetAwaiter(); } catch (Exception ex) { core.TrySetException(ex); return; } if (awaiter.IsCompleted) { TryRightInvokeContinuation(this, awaiter); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter>)state) { TryRightInvokeContinuation(t.Item1, t.Item2); } }, StateTuple.Create(this, awaiter)); } } } static void TryLeftInvokeContinuation(WhenAnyLRPromise self, in UniTask.Awaiter awaiter) { T result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((true, result)); } } static void TryRightInvokeContinuation(WhenAnyLRPromise self, in UniTask.Awaiter awaiter) { try { awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((false, default)); } } public (bool, T) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } sealed class WhenAnyPromise : IUniTaskSource<(int, T)> { int completedCount; UniTaskCompletionSourceCore<(int, T)> core; public WhenAnyPromise(UniTask[] tasks, int tasksLength) { if (tasksLength == 0) { throw new ArgumentException("The tasks argument contains no tasks."); } TaskTracker.TrackActiveTask(this, 3); for (int i = 0; i < tasksLength; i++) { UniTask.Awaiter awaiter; try { awaiter = tasks[i].GetAwaiter(); } catch (Exception ex) { core.TrySetException(ex); continue; // consume others. } if (awaiter.IsCompleted) { TryInvokeContinuation(this, awaiter, i); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple, UniTask.Awaiter, int>)state) { TryInvokeContinuation(t.Item1, t.Item2, t.Item3); } }, StateTuple.Create(this, awaiter, i)); } } } static void TryInvokeContinuation(WhenAnyPromise self, in UniTask.Awaiter awaiter, int i) { T result; try { result = awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult((i, result)); } } public (int, T) GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } sealed class WhenAnyPromise : IUniTaskSource { int completedCount; UniTaskCompletionSourceCore core; public WhenAnyPromise(UniTask[] tasks, int tasksLength) { if (tasksLength == 0) { throw new ArgumentException("The tasks argument contains no tasks."); } TaskTracker.TrackActiveTask(this, 3); for (int i = 0; i < tasksLength; i++) { UniTask.Awaiter awaiter; try { awaiter = tasks[i].GetAwaiter(); } catch (Exception ex) { core.TrySetException(ex); continue; // consume others. } if (awaiter.IsCompleted) { TryInvokeContinuation(this, awaiter, i); } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple)state) { TryInvokeContinuation(t.Item1, t.Item2, t.Item3); } }, StateTuple.Create(this, awaiter, i)); } } } static void TryInvokeContinuation(WhenAnyPromise self, in UniTask.Awaiter awaiter, int i) { try { awaiter.GetResult(); } catch (Exception ex) { self.core.TrySetException(ex); return; } if (Interlocked.Increment(ref self.completedCount) == 1) { self.core.TrySetResult(i); } } public int GetResult(short token) { TaskTracker.RemoveTracking(this); GC.SuppressFinalize(this); return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenAny.cs.meta ================================================ fileFormatVersion: 2 guid: c32578978c37eaf41bdd90e1b034637d MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenEach.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Generic; using System.Runtime.ExceptionServices; using System.Threading; namespace Cysharp.Threading.Tasks { public partial struct UniTask { public static IUniTaskAsyncEnumerable> WhenEach(IEnumerable> tasks) { return new WhenEachEnumerable(tasks); } public static IUniTaskAsyncEnumerable> WhenEach(params UniTask[] tasks) { return new WhenEachEnumerable(tasks); } } public readonly struct WhenEachResult { public T Result { get; } public Exception Exception { get; } //[MemberNotNullWhen(false, nameof(Exception))] public bool IsCompletedSuccessfully => Exception == null; //[MemberNotNullWhen(true, nameof(Exception))] public bool IsFaulted => Exception != null; public WhenEachResult(T result) { this.Result = result; this.Exception = null; } public WhenEachResult(Exception exception) { if (exception == null) throw new ArgumentNullException(nameof(exception)); this.Result = default; this.Exception = exception; } public void TryThrow() { if (IsFaulted) { ExceptionDispatchInfo.Capture(Exception).Throw(); } } public T GetResult() { if (IsFaulted) { ExceptionDispatchInfo.Capture(Exception).Throw(); } return Result; } public override string ToString() { if (IsCompletedSuccessfully) { return Result?.ToString() ?? ""; } else { return $"Exception{{{Exception.Message}}}"; } } } internal enum WhenEachState : byte { NotRunning, Running, Completed } internal sealed class WhenEachEnumerable : IUniTaskAsyncEnumerable> { IEnumerable> source; public WhenEachEnumerable(IEnumerable> source) { this.source = source; } public IUniTaskAsyncEnumerator> GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new Enumerator(source, cancellationToken); } sealed class Enumerator : IUniTaskAsyncEnumerator> { readonly IEnumerable> source; CancellationToken cancellationToken; Channel> channel; IUniTaskAsyncEnumerator> channelEnumerator; int completeCount; WhenEachState state; public Enumerator(IEnumerable> source, CancellationToken cancellationToken) { this.source = source; this.cancellationToken = cancellationToken; } public WhenEachResult Current => channelEnumerator.Current; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); if (state == WhenEachState.NotRunning) { state = WhenEachState.Running; channel = Channel.CreateSingleConsumerUnbounded>(); channelEnumerator = channel.Reader.ReadAllAsync().GetAsyncEnumerator(cancellationToken); if (source is UniTask[] array) { ConsumeAll(this, array, array.Length); } else { using (var rentArray = ArrayPoolUtil.Materialize(source)) { ConsumeAll(this, rentArray.Array, rentArray.Length); } } } return channelEnumerator.MoveNextAsync(); } static void ConsumeAll(Enumerator self, UniTask[] array, int length) { for (int i = 0; i < length; i++) { RunWhenEachTask(self, array[i], length).Forget(); } } static async UniTaskVoid RunWhenEachTask(Enumerator self, UniTask task, int length) { try { var result = await task; self.channel.Writer.TryWrite(new WhenEachResult(result)); } catch (Exception ex) { self.channel.Writer.TryWrite(new WhenEachResult(ex)); } if (Interlocked.Increment(ref self.completeCount) == length) { self.state = WhenEachState.Completed; self.channel.Writer.TryComplete(); } } public async UniTask DisposeAsync() { if (channelEnumerator != null) { await channelEnumerator.DisposeAsync(); } if (state != WhenEachState.Completed) { state = WhenEachState.Completed; channel.Writer.TryComplete(new OperationCanceledException()); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.WhenEach.cs.meta ================================================ fileFormatVersion: 2 guid: 7cac24fdda5112047a1cd3dd66b542c4 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.asmdef ================================================ { "name": "UniTask", "rootNamespace": "", "references": [], "includePlatforms": [], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": false, "precompiledReferences": [], "autoReferenced": true, "defineConstraints": [], "versionDefines": [ { "name": "com.unity.modules.assetbundle", "expression": "", "define": "UNITASK_ASSETBUNDLE_SUPPORT" }, { "name": "com.unity.modules.physics", "expression": "", "define": "UNITASK_PHYSICS_SUPPORT" }, { "name": "com.unity.modules.physics2d", "expression": "", "define": "UNITASK_PHYSICS2D_SUPPORT" }, { "name": "com.unity.modules.particlesystem", "expression": "", "define": "UNITASK_PARTICLESYSTEM_SUPPORT" }, { "name": "com.unity.ugui", "expression": "", "define": "UNITASK_UGUI_SUPPORT" }, { "name": "com.unity.modules.unitywebrequest", "expression": "", "define": "UNITASK_WEBREQUEST_SUPPORT" } ], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.asmdef.meta ================================================ fileFormatVersion: 2 guid: f51ebe6a0ceec4240a699833d6309b23 AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member #pragma warning disable CS0436 #if UNITASK_NETCORE || UNITY_2022_3_OR_NEWER #define SUPPORT_VALUETASK #endif using Cysharp.Threading.Tasks.CompilerServices; using System; using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Runtime.InteropServices; namespace Cysharp.Threading.Tasks { internal static class AwaiterActions { internal static readonly Action InvokeContinuationDelegate = Continuation; [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] static void Continuation(object state) { ((Action)state).Invoke(); } } /// /// Lightweight unity specified task-like object. /// [AsyncMethodBuilder(typeof(AsyncUniTaskMethodBuilder))] [StructLayout(LayoutKind.Auto)] public readonly partial struct UniTask { readonly IUniTaskSource source; readonly short token; [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public UniTask(IUniTaskSource source, short token) { this.source = source; this.token = token; } public UniTaskStatus Status { [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] get { if (source == null) return UniTaskStatus.Succeeded; return source.GetStatus(token); } } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public Awaiter GetAwaiter() { return new Awaiter(this); } /// /// returns (bool IsCanceled) instead of throws OperationCanceledException. /// public UniTask SuppressCancellationThrow() { var status = Status; if (status == UniTaskStatus.Succeeded) return CompletedTasks.False; if (status == UniTaskStatus.Canceled) return CompletedTasks.True; return new UniTask(new IsCanceledSource(source), token); } #if SUPPORT_VALUETASK public static implicit operator System.Threading.Tasks.ValueTask(in UniTask self) { if (self.source == null) { return default; } #if (UNITASK_NETCORE && NETSTANDARD2_0) return self.AsValueTask(); #else return new System.Threading.Tasks.ValueTask(self.source, self.token); #endif } #endif public override string ToString() { if (source == null) return "()"; return "(" + source.UnsafeGetStatus() + ")"; } /// /// Memoizing inner IValueTaskSource. The result UniTask can await multiple. /// public UniTask Preserve() { if (source == null) { return this; } else { return new UniTask(new MemoizeSource(source), token); } } public UniTask AsAsyncUnitUniTask() { if (this.source == null) return CompletedTasks.AsyncUnit; var status = this.source.GetStatus(this.token); if (status.IsCompletedSuccessfully()) { this.source.GetResult(this.token); return CompletedTasks.AsyncUnit; } else if (this.source is IUniTaskSource asyncUnitSource) { return new UniTask(asyncUnitSource, this.token); } return new UniTask(new AsyncUnitSource(this.source), this.token); } sealed class AsyncUnitSource : IUniTaskSource { readonly IUniTaskSource source; public AsyncUnitSource(IUniTaskSource source) { this.source = source; } public AsyncUnit GetResult(short token) { source.GetResult(token); return AsyncUnit.Default; } public UniTaskStatus GetStatus(short token) { return source.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { source.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return source.UnsafeGetStatus(); } void IUniTaskSource.GetResult(short token) { GetResult(token); } } sealed class IsCanceledSource : IUniTaskSource { readonly IUniTaskSource source; public IsCanceledSource(IUniTaskSource source) { this.source = source; } public bool GetResult(short token) { if (source.GetStatus(token) == UniTaskStatus.Canceled) { return true; } source.GetResult(token); return false; } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return source.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return source.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { source.OnCompleted(continuation, state, token); } } sealed class MemoizeSource : IUniTaskSource { IUniTaskSource source; ExceptionDispatchInfo exception; UniTaskStatus status; public MemoizeSource(IUniTaskSource source) { this.source = source; } public void GetResult(short token) { if (source == null) { if (exception != null) { exception.Throw(); } } else { try { source.GetResult(token); status = UniTaskStatus.Succeeded; } catch (Exception ex) { exception = ExceptionDispatchInfo.Capture(ex); if (ex is OperationCanceledException) { status = UniTaskStatus.Canceled; } else { status = UniTaskStatus.Faulted; } throw; } finally { source = null; } } } public UniTaskStatus GetStatus(short token) { if (source == null) { return status; } return source.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { if (source == null) { continuation(state); } else { source.OnCompleted(continuation, state, token); } } public UniTaskStatus UnsafeGetStatus() { if (source == null) { return status; } return source.UnsafeGetStatus(); } } public readonly struct Awaiter : ICriticalNotifyCompletion { readonly UniTask task; [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public Awaiter(in UniTask task) { this.task = task; } public bool IsCompleted { [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return task.Status.IsCompleted(); } } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void GetResult() { if (task.source == null) return; task.source.GetResult(task.token); } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void OnCompleted(Action continuation) { if (task.source == null) { continuation(); } else { task.source.OnCompleted(AwaiterActions.InvokeContinuationDelegate, continuation, task.token); } } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void UnsafeOnCompleted(Action continuation) { if (task.source == null) { continuation(); } else { task.source.OnCompleted(AwaiterActions.InvokeContinuationDelegate, continuation, task.token); } } /// /// If register manually continuation, you can use it instead of for compiler OnCompleted methods. /// [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void SourceOnCompleted(Action continuation, object state) { if (task.source == null) { continuation(state); } else { task.source.OnCompleted(continuation, state, task.token); } } } } /// /// Lightweight unity specified task-like object. /// [AsyncMethodBuilder(typeof(AsyncUniTaskMethodBuilder<>))] [StructLayout(LayoutKind.Auto)] public readonly struct UniTask { readonly IUniTaskSource source; readonly T result; readonly short token; [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public UniTask(T result) { this.source = default; this.token = default; this.result = result; } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public UniTask(IUniTaskSource source, short token) { this.source = source; this.token = token; this.result = default; } public UniTaskStatus Status { [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return (source == null) ? UniTaskStatus.Succeeded : source.GetStatus(token); } } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public Awaiter GetAwaiter() { return new Awaiter(this); } /// /// Memoizing inner IValueTaskSource. The result UniTask can await multiple. /// public UniTask Preserve() { if (source == null) { return this; } else { return new UniTask(new MemoizeSource(source), token); } } public UniTask AsUniTask() { if (this.source == null) return UniTask.CompletedTask; var status = this.source.GetStatus(this.token); if (status.IsCompletedSuccessfully()) { this.source.GetResult(this.token); return UniTask.CompletedTask; } // Converting UniTask -> UniTask is zero overhead. return new UniTask(this.source, this.token); } public static implicit operator UniTask(UniTask self) { return self.AsUniTask(); } #if SUPPORT_VALUETASK public static implicit operator System.Threading.Tasks.ValueTask(in UniTask self) { if (self.source == null) { return new System.Threading.Tasks.ValueTask(self.result); } #if (UNITASK_NETCORE && NETSTANDARD2_0) return self.AsValueTask(); #else return new System.Threading.Tasks.ValueTask(self.source, self.token); #endif } #endif /// /// returns (bool IsCanceled, T Result) instead of throws OperationCanceledException. /// public UniTask<(bool IsCanceled, T Result)> SuppressCancellationThrow() { if (source == null) { return new UniTask<(bool IsCanceled, T Result)>((false, result)); } return new UniTask<(bool, T)>(new IsCanceledSource(source), token); } public override string ToString() { return (this.source == null) ? result?.ToString() : "(" + this.source.UnsafeGetStatus() + ")"; } sealed class IsCanceledSource : IUniTaskSource<(bool, T)> { readonly IUniTaskSource source; [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public IsCanceledSource(IUniTaskSource source) { this.source = source; } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public (bool, T) GetResult(short token) { if (source.GetStatus(token) == UniTaskStatus.Canceled) { return (true, default); } var result = source.GetResult(token); return (false, result); } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] void IUniTaskSource.GetResult(short token) { GetResult(token); } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public UniTaskStatus GetStatus(short token) { return source.GetStatus(token); } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public UniTaskStatus UnsafeGetStatus() { return source.UnsafeGetStatus(); } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void OnCompleted(Action continuation, object state, short token) { source.OnCompleted(continuation, state, token); } } sealed class MemoizeSource : IUniTaskSource { IUniTaskSource source; T result; ExceptionDispatchInfo exception; UniTaskStatus status; public MemoizeSource(IUniTaskSource source) { this.source = source; } public T GetResult(short token) { if (source == null) { if (exception != null) { exception.Throw(); } return result; } else { try { result = source.GetResult(token); status = UniTaskStatus.Succeeded; return result; } catch (Exception ex) { exception = ExceptionDispatchInfo.Capture(ex); if (ex is OperationCanceledException) { status = UniTaskStatus.Canceled; } else { status = UniTaskStatus.Faulted; } throw; } finally { source = null; } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { if (source == null) { return status; } return source.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { if (source == null) { continuation(state); } else { source.OnCompleted(continuation, state, token); } } public UniTaskStatus UnsafeGetStatus() { if (source == null) { return status; } return source.UnsafeGetStatus(); } } public readonly struct Awaiter : ICriticalNotifyCompletion { readonly UniTask task; [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public Awaiter(in UniTask task) { this.task = task; } public bool IsCompleted { [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return task.Status.IsCompleted(); } } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public T GetResult() { var s = task.source; if (s == null) { return task.result; } else { return s.GetResult(task.token); } } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void OnCompleted(Action continuation) { var s = task.source; if (s == null) { continuation(); } else { s.OnCompleted(AwaiterActions.InvokeContinuationDelegate, continuation, task.token); } } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void UnsafeOnCompleted(Action continuation) { var s = task.source; if (s == null) { continuation(); } else { s.OnCompleted(AwaiterActions.InvokeContinuationDelegate, continuation, task.token); } } /// /// If register manually continuation, you can use it instead of for compiler OnCompleted methods. /// [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void SourceOnCompleted(Action continuation, object state) { var s = task.source; if (s == null) { continuation(state); } else { s.OnCompleted(continuation, state, task.token); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.cs.meta ================================================ fileFormatVersion: 2 guid: 8947adf23181ff04db73829df217ca94 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskCompletionSource.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections.Generic; using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Runtime.InteropServices; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public interface IResolvePromise { bool TrySetResult(); } public interface IResolvePromise { bool TrySetResult(T value); } public interface IRejectPromise { bool TrySetException(Exception exception); } public interface ICancelPromise { bool TrySetCanceled(CancellationToken cancellationToken = default); } public interface IPromise : IResolvePromise, IRejectPromise, ICancelPromise { } public interface IPromise : IResolvePromise, IRejectPromise, ICancelPromise { } internal class ExceptionHolder { ExceptionDispatchInfo exception; bool calledGet = false; public ExceptionHolder(ExceptionDispatchInfo exception) { this.exception = exception; } public ExceptionDispatchInfo GetException() { if (!calledGet) { calledGet = true; GC.SuppressFinalize(this); } return exception; } ~ExceptionHolder() { if (!calledGet) { UniTaskScheduler.PublishUnobservedTaskException(exception.SourceException); } } } [StructLayout(LayoutKind.Auto)] public struct UniTaskCompletionSourceCore { // Struct Size: TResult + (8 + 2 + 1 + 1 + 8 + 8) TResult result; object error; // ExceptionHolder or OperationCanceledException short version; bool hasUnhandledError; int completedCount; // 0: completed == false Action continuation; object continuationState; [DebuggerHidden] public void Reset() { ReportUnhandledError(); unchecked { version += 1; // incr version. } completedCount = 0; result = default; error = null; hasUnhandledError = false; continuation = null; continuationState = null; } void ReportUnhandledError() { if (hasUnhandledError) { try { if (error is OperationCanceledException oc) { UniTaskScheduler.PublishUnobservedTaskException(oc); } else if (error is ExceptionHolder e) { UniTaskScheduler.PublishUnobservedTaskException(e.GetException().SourceException); } } catch { } } } internal void MarkHandled() { hasUnhandledError = false; } /// Completes with a successful result. /// The result. [DebuggerHidden] public bool TrySetResult(TResult result) { if (Interlocked.Increment(ref completedCount) == 1) { // setup result this.result = result; if (continuation != null || Interlocked.CompareExchange(ref this.continuation, UniTaskCompletionSourceCoreShared.s_sentinel, null) != null) { continuation(continuationState); } return true; } return false; } /// Completes with an error. /// The exception. [DebuggerHidden] public bool TrySetException(Exception error) { if (Interlocked.Increment(ref completedCount) == 1) { // setup result this.hasUnhandledError = true; if (error is OperationCanceledException) { this.error = error; } else { this.error = new ExceptionHolder(ExceptionDispatchInfo.Capture(error)); } if (continuation != null || Interlocked.CompareExchange(ref this.continuation, UniTaskCompletionSourceCoreShared.s_sentinel, null) != null) { continuation(continuationState); } return true; } return false; } [DebuggerHidden] public bool TrySetCanceled(CancellationToken cancellationToken = default) { if (Interlocked.Increment(ref completedCount) == 1) { // setup result this.hasUnhandledError = true; this.error = new OperationCanceledException(cancellationToken); if (continuation != null || Interlocked.CompareExchange(ref this.continuation, UniTaskCompletionSourceCoreShared.s_sentinel, null) != null) { continuation(continuationState); } return true; } return false; } /// Gets the operation version. [DebuggerHidden] public short Version => version; /// Gets the status of the operation. /// Opaque value that was provided to the 's constructor. [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public UniTaskStatus GetStatus(short token) { ValidateToken(token); return (continuation == null || (completedCount == 0)) ? UniTaskStatus.Pending : (error == null) ? UniTaskStatus.Succeeded : (error is OperationCanceledException) ? UniTaskStatus.Canceled : UniTaskStatus.Faulted; } /// Gets the status of the operation without token validation. [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public UniTaskStatus UnsafeGetStatus() { return (continuation == null || (completedCount == 0)) ? UniTaskStatus.Pending : (error == null) ? UniTaskStatus.Succeeded : (error is OperationCanceledException) ? UniTaskStatus.Canceled : UniTaskStatus.Faulted; } /// Gets the result of the operation. /// Opaque value that was provided to the 's constructor. // [StackTraceHidden] [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public TResult GetResult(short token) { ValidateToken(token); if (completedCount == 0) { throw new InvalidOperationException("Not yet completed, UniTask only allow to use await."); } if (error != null) { hasUnhandledError = false; if (error is OperationCanceledException oce) { throw oce; } else if (error is ExceptionHolder eh) { eh.GetException().Throw(); } throw new InvalidOperationException("Critical: invalid exception type was held."); } return result; } /// Schedules the continuation action for this operation. /// The continuation to invoke when the operation has completed. /// The state object to pass to when it's invoked. /// Opaque value that was provided to the 's constructor. [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public void OnCompleted(Action continuation, object state, short token /*, ValueTaskSourceOnCompletedFlags flags */) { if (continuation == null) { throw new ArgumentNullException(nameof(continuation)); } ValidateToken(token); /* no use ValueTaskSourceOnCOmpletedFlags, always no capture ExecutionContext and SynchronizationContext. */ /* PatternA: GetStatus=Pending => OnCompleted => TrySet*** => GetResult PatternB: TrySet*** => GetStatus=!Pending => GetResult PatternC: GetStatus=Pending => TrySet/OnCompleted(race condition) => GetResult C.1: win OnCompleted -> TrySet invoke saved continuation C.2: win TrySet -> should invoke continuation here. */ // not set continuation yet. object oldContinuation = this.continuation; if (oldContinuation == null) { continuationState = state; oldContinuation = Interlocked.CompareExchange(ref this.continuation, continuation, null); } if (oldContinuation != null) { // already running continuation in TrySet. // It will cause call OnCompleted multiple time, invalid. if (!ReferenceEquals(oldContinuation, UniTaskCompletionSourceCoreShared.s_sentinel)) { throw new InvalidOperationException("Already continuation registered, can not await twice or get Status after await."); } continuation(state); } } [DebuggerHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] private void ValidateToken(short token) { if (token != version) { throw new InvalidOperationException("Token version is not matched, can not await twice or get Status after await."); } } } internal static class UniTaskCompletionSourceCoreShared // separated out of generic to avoid unnecessary duplication { internal static readonly Action s_sentinel = CompletionSentinel; private static void CompletionSentinel(object _) // named method to aid debugging { throw new InvalidOperationException("The sentinel delegate should never be invoked."); } } public class AutoResetUniTaskCompletionSource : IUniTaskSource, ITaskPoolNode, IPromise { static TaskPool pool; AutoResetUniTaskCompletionSource nextNode; public ref AutoResetUniTaskCompletionSource NextNode => ref nextNode; static AutoResetUniTaskCompletionSource() { TaskPool.RegisterSizeGetter(typeof(AutoResetUniTaskCompletionSource), () => pool.Size); } UniTaskCompletionSourceCore core; short version; AutoResetUniTaskCompletionSource() { } [DebuggerHidden] public static AutoResetUniTaskCompletionSource Create() { if (!pool.TryPop(out var result)) { result = new AutoResetUniTaskCompletionSource(); } result.version = result.core.Version; TaskTracker.TrackActiveTask(result, 2); return result; } [DebuggerHidden] public static AutoResetUniTaskCompletionSource CreateFromCanceled(CancellationToken cancellationToken, out short token) { var source = Create(); source.TrySetCanceled(cancellationToken); token = source.core.Version; return source; } [DebuggerHidden] public static AutoResetUniTaskCompletionSource CreateFromException(Exception exception, out short token) { var source = Create(); source.TrySetException(exception); token = source.core.Version; return source; } [DebuggerHidden] public static AutoResetUniTaskCompletionSource CreateCompleted(out short token) { var source = Create(); source.TrySetResult(); token = source.core.Version; return source; } public UniTask Task { [DebuggerHidden] get { return new UniTask(this, core.Version); } } [DebuggerHidden] public bool TrySetResult() { return version == core.Version && core.TrySetResult(AsyncUnit.Default); } [DebuggerHidden] public bool TrySetCanceled(CancellationToken cancellationToken = default) { return version == core.Version && core.TrySetCanceled(cancellationToken); } [DebuggerHidden] public bool TrySetException(Exception exception) { return version == core.Version && core.TrySetException(exception); } [DebuggerHidden] public void GetResult(short token) { try { core.GetResult(token); } finally { TryReturn(); } } [DebuggerHidden] public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } [DebuggerHidden] public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } [DebuggerHidden] public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } [DebuggerHidden] bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); return pool.TryPush(this); } } public class AutoResetUniTaskCompletionSource : IUniTaskSource, ITaskPoolNode>, IPromise { static TaskPool> pool; AutoResetUniTaskCompletionSource nextNode; public ref AutoResetUniTaskCompletionSource NextNode => ref nextNode; static AutoResetUniTaskCompletionSource() { TaskPool.RegisterSizeGetter(typeof(AutoResetUniTaskCompletionSource), () => pool.Size); } UniTaskCompletionSourceCore core; short version; AutoResetUniTaskCompletionSource() { } [DebuggerHidden] public static AutoResetUniTaskCompletionSource Create() { if (!pool.TryPop(out var result)) { result = new AutoResetUniTaskCompletionSource(); } result.version = result.core.Version; TaskTracker.TrackActiveTask(result, 2); return result; } [DebuggerHidden] public static AutoResetUniTaskCompletionSource CreateFromCanceled(CancellationToken cancellationToken, out short token) { var source = Create(); source.TrySetCanceled(cancellationToken); token = source.core.Version; return source; } [DebuggerHidden] public static AutoResetUniTaskCompletionSource CreateFromException(Exception exception, out short token) { var source = Create(); source.TrySetException(exception); token = source.core.Version; return source; } [DebuggerHidden] public static AutoResetUniTaskCompletionSource CreateFromResult(T result, out short token) { var source = Create(); source.TrySetResult(result); token = source.core.Version; return source; } public UniTask Task { [DebuggerHidden] get { return new UniTask(this, core.Version); } } [DebuggerHidden] public bool TrySetResult(T result) { return version == core.Version && core.TrySetResult(result); } [DebuggerHidden] public bool TrySetCanceled(CancellationToken cancellationToken = default) { return version == core.Version && core.TrySetCanceled(cancellationToken); } [DebuggerHidden] public bool TrySetException(Exception exception) { return version == core.Version && core.TrySetException(exception); } [DebuggerHidden] public T GetResult(short token) { try { return core.GetResult(token); } finally { TryReturn(); } } [DebuggerHidden] void IUniTaskSource.GetResult(short token) { GetResult(token); } [DebuggerHidden] public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } [DebuggerHidden] public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } [DebuggerHidden] public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } [DebuggerHidden] bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); return pool.TryPush(this); } } public class UniTaskCompletionSource : IUniTaskSource, IPromise { CancellationToken cancellationToken; ExceptionHolder exception; object gate; Action singleContinuation; object singleState; List<(Action, object)> secondaryContinuationList; int intStatus; // UniTaskStatus bool handled = false; public UniTaskCompletionSource() { TaskTracker.TrackActiveTask(this, 2); } [DebuggerHidden] internal void MarkHandled() { if (!handled) { handled = true; TaskTracker.RemoveTracking(this); } } public UniTask Task { [DebuggerHidden] get { return new UniTask(this, 0); } } [DebuggerHidden] public bool TrySetResult() { return TrySignalCompletion(UniTaskStatus.Succeeded); } [DebuggerHidden] public bool TrySetCanceled(CancellationToken cancellationToken = default) { if (UnsafeGetStatus() != UniTaskStatus.Pending) return false; this.cancellationToken = cancellationToken; return TrySignalCompletion(UniTaskStatus.Canceled); } [DebuggerHidden] public bool TrySetException(Exception exception) { if (exception is OperationCanceledException oce) { return TrySetCanceled(oce.CancellationToken); } if (UnsafeGetStatus() != UniTaskStatus.Pending) return false; this.exception = new ExceptionHolder(ExceptionDispatchInfo.Capture(exception)); return TrySignalCompletion(UniTaskStatus.Faulted); } [DebuggerHidden] public void GetResult(short token) { MarkHandled(); var status = (UniTaskStatus)intStatus; switch (status) { case UniTaskStatus.Succeeded: return; case UniTaskStatus.Faulted: exception.GetException().Throw(); return; case UniTaskStatus.Canceled: throw new OperationCanceledException(cancellationToken); default: case UniTaskStatus.Pending: throw new InvalidOperationException("not yet completed."); } } [DebuggerHidden] public UniTaskStatus GetStatus(short token) { return (UniTaskStatus)intStatus; } [DebuggerHidden] public UniTaskStatus UnsafeGetStatus() { return (UniTaskStatus)intStatus; } [DebuggerHidden] public void OnCompleted(Action continuation, object state, short token) { if (gate == null) { Interlocked.CompareExchange(ref gate, new object(), null); } var lockGate = Thread.VolatileRead(ref gate); lock (lockGate) // wait TrySignalCompletion, after status is not pending. { if ((UniTaskStatus)intStatus != UniTaskStatus.Pending) { continuation(state); return; } if (singleContinuation == null) { singleContinuation = continuation; singleState = state; } else { if (secondaryContinuationList == null) { secondaryContinuationList = new List<(Action, object)>(); } secondaryContinuationList.Add((continuation, state)); } } } [DebuggerHidden] bool TrySignalCompletion(UniTaskStatus status) { if (Interlocked.CompareExchange(ref intStatus, (int)status, (int)UniTaskStatus.Pending) == (int)UniTaskStatus.Pending) { if (gate == null) { Interlocked.CompareExchange(ref gate, new object(), null); } var lockGate = Thread.VolatileRead(ref gate); lock (lockGate) // wait OnCompleted. { if (singleContinuation != null) { try { singleContinuation(singleState); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } if (secondaryContinuationList != null) { foreach (var (c, state) in secondaryContinuationList) { try { c(state); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } } singleContinuation = null; singleState = null; secondaryContinuationList = null; } return true; } return false; } } public class UniTaskCompletionSource : IUniTaskSource, IPromise { CancellationToken cancellationToken; T result; ExceptionHolder exception; object gate; Action singleContinuation; object singleState; List<(Action, object)> secondaryContinuationList; int intStatus; // UniTaskStatus bool handled = false; public UniTaskCompletionSource() { TaskTracker.TrackActiveTask(this, 2); } [DebuggerHidden] internal void MarkHandled() { if (!handled) { handled = true; TaskTracker.RemoveTracking(this); } } public UniTask Task { [DebuggerHidden] get { return new UniTask(this, 0); } } [DebuggerHidden] public bool TrySetResult(T result) { if (UnsafeGetStatus() != UniTaskStatus.Pending) return false; this.result = result; return TrySignalCompletion(UniTaskStatus.Succeeded); } [DebuggerHidden] public bool TrySetCanceled(CancellationToken cancellationToken = default) { if (UnsafeGetStatus() != UniTaskStatus.Pending) return false; this.cancellationToken = cancellationToken; return TrySignalCompletion(UniTaskStatus.Canceled); } [DebuggerHidden] public bool TrySetException(Exception exception) { if (exception is OperationCanceledException oce) { return TrySetCanceled(oce.CancellationToken); } if (UnsafeGetStatus() != UniTaskStatus.Pending) return false; this.exception = new ExceptionHolder(ExceptionDispatchInfo.Capture(exception)); return TrySignalCompletion(UniTaskStatus.Faulted); } [DebuggerHidden] public T GetResult(short token) { MarkHandled(); var status = (UniTaskStatus)intStatus; switch (status) { case UniTaskStatus.Succeeded: return result; case UniTaskStatus.Faulted: exception.GetException().Throw(); return default; case UniTaskStatus.Canceled: throw new OperationCanceledException(cancellationToken); default: case UniTaskStatus.Pending: throw new InvalidOperationException("not yet completed."); } } [DebuggerHidden] void IUniTaskSource.GetResult(short token) { GetResult(token); } [DebuggerHidden] public UniTaskStatus GetStatus(short token) { return (UniTaskStatus)intStatus; } [DebuggerHidden] public UniTaskStatus UnsafeGetStatus() { return (UniTaskStatus)intStatus; } [DebuggerHidden] public void OnCompleted(Action continuation, object state, short token) { if (gate == null) { Interlocked.CompareExchange(ref gate, new object(), null); } var lockGate = Thread.VolatileRead(ref gate); lock (lockGate) // wait TrySignalCompletion, after status is not pending. { if ((UniTaskStatus)intStatus != UniTaskStatus.Pending) { continuation(state); return; } if (singleContinuation == null) { singleContinuation = continuation; singleState = state; } else { if (secondaryContinuationList == null) { secondaryContinuationList = new List<(Action, object)>(); } secondaryContinuationList.Add((continuation, state)); } } } [DebuggerHidden] bool TrySignalCompletion(UniTaskStatus status) { if (Interlocked.CompareExchange(ref intStatus, (int)status, (int)UniTaskStatus.Pending) == (int)UniTaskStatus.Pending) { if (gate == null) { Interlocked.CompareExchange(ref gate, new object(), null); } var lockGate = Thread.VolatileRead(ref gate); lock (lockGate) // wait OnCompleted. { if (singleContinuation != null) { try { singleContinuation(singleState); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } if (secondaryContinuationList != null) { foreach (var (c, state) in secondaryContinuationList) { try { c(state); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } } singleContinuation = null; singleState = null; secondaryContinuationList = null; } return true; } return false; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskCompletionSource.cs.meta ================================================ fileFormatVersion: 2 guid: ed03524d09e7eb24a9fb9137198feb84 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.Shorthand.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Collections.Generic; namespace Cysharp.Threading.Tasks { public static partial class UniTaskExtensions { // shorthand of WhenAll public static UniTask.Awaiter GetAwaiter(this UniTask[] tasks) { return UniTask.WhenAll(tasks).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this IEnumerable tasks) { return UniTask.WhenAll(tasks).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this UniTask[] tasks) { return UniTask.WhenAll(tasks).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this IEnumerable> tasks) { return UniTask.WhenAll(tasks).GetAwaiter(); } public static UniTask<(T1, T2)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2).GetAwaiter(); } public static UniTask<(T1, T2, T3)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11, tasks.Item12).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11, tasks.Item12, tasks.Item13).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11, tasks.Item12, tasks.Item13, tasks.Item14).GetAwaiter(); } public static UniTask<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14, UniTask task15) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11, tasks.Item12, tasks.Item13, tasks.Item14, tasks.Item15).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11, tasks.Item12).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11, tasks.Item12, tasks.Item13).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11, tasks.Item12, tasks.Item13, tasks.Item14).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this (UniTask task1, UniTask task2, UniTask task3, UniTask task4, UniTask task5, UniTask task6, UniTask task7, UniTask task8, UniTask task9, UniTask task10, UniTask task11, UniTask task12, UniTask task13, UniTask task14, UniTask task15) tasks) { return UniTask.WhenAll(tasks.Item1, tasks.Item2, tasks.Item3, tasks.Item4, tasks.Item5, tasks.Item6, tasks.Item7, tasks.Item8, tasks.Item9, tasks.Item10, tasks.Item11, tasks.Item12, tasks.Item13, tasks.Item14, tasks.Item15).GetAwaiter(); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.Shorthand.cs.meta ================================================ fileFormatVersion: 2 guid: 4b4ff020f73dc6d4b8ebd4760d61fb43 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.Shorthand.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System.Collections.Generic; namespace Cysharp.Threading.Tasks { public static partial class UniTaskExtensions { // shorthand of WhenAll public static UniTask.Awaiter GetAwaiter(this UniTask[] tasks) { return UniTask.WhenAll(tasks).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this IEnumerable tasks) { return UniTask.WhenAll(tasks).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this UniTask[] tasks) { return UniTask.WhenAll(tasks).GetAwaiter(); } public static UniTask.Awaiter GetAwaiter(this IEnumerable> tasks) { return UniTask.WhenAll(tasks).GetAwaiter(); } <# for(var i = 2; i <= 15; i++ ) { var range = Enumerable.Range(1, i); var t = string.Join(", ", range.Select(x => "T" + x)); var args = string.Join(", ", range.Select(x => $"UniTask task{x}")); var titems = string.Join(", ", range.Select(x => $"tasks.Item{x}")); #> public static UniTask<(<#= t #>)>.Awaiter GetAwaiter<<#= t #>>(this (<#= args #>) tasks) { return UniTask.WhenAll(<#= titems #>).GetAwaiter(); } <# } #> <# for(var i = 2; i <= 15; i++ ) { var range = Enumerable.Range(1, i); var args = string.Join(", ", range.Select(x => $"UniTask task{x}")); var titems = string.Join(", ", range.Select(x => $"tasks.Item{x}")); #> public static UniTask.Awaiter GetAwaiter(this (<#= args #>) tasks) { return UniTask.WhenAll(<#= titems #>).GetAwaiter(); } <# } #> } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.Shorthand.tt.meta ================================================ fileFormatVersion: 2 guid: 9a75b5d7e55a5a34fb6476586df37c72 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Collections; using System.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public static partial class UniTaskExtensions { /// /// Convert Task[T] -> UniTask[T]. /// public static UniTask AsUniTask(this Task task, bool useCurrentSynchronizationContext = true) { var promise = new UniTaskCompletionSource(); task.ContinueWith((x, state) => { var p = (UniTaskCompletionSource)state; switch (x.Status) { case TaskStatus.Canceled: p.TrySetCanceled(); break; case TaskStatus.Faulted: p.TrySetException(x.Exception.InnerException ?? x.Exception); break; case TaskStatus.RanToCompletion: p.TrySetResult(x.Result); break; default: throw new NotSupportedException(); } }, promise, useCurrentSynchronizationContext ? TaskScheduler.FromCurrentSynchronizationContext() : TaskScheduler.Current); return promise.Task; } /// /// Convert Task -> UniTask. /// public static UniTask AsUniTask(this Task task, bool useCurrentSynchronizationContext = true) { var promise = new UniTaskCompletionSource(); task.ContinueWith((x, state) => { var p = (UniTaskCompletionSource)state; switch (x.Status) { case TaskStatus.Canceled: p.TrySetCanceled(); break; case TaskStatus.Faulted: p.TrySetException(x.Exception.InnerException ?? x.Exception); break; case TaskStatus.RanToCompletion: p.TrySetResult(); break; default: throw new NotSupportedException(); } }, promise, useCurrentSynchronizationContext ? TaskScheduler.FromCurrentSynchronizationContext() : TaskScheduler.Current); return promise.Task; } public static Task AsTask(this UniTask task) { try { UniTask.Awaiter awaiter; try { awaiter = task.GetAwaiter(); } catch (Exception ex) { return Task.FromException(ex); } if (awaiter.IsCompleted) { try { var result = awaiter.GetResult(); return Task.FromResult(result); } catch (Exception ex) { return Task.FromException(ex); } } var tcs = new TaskCompletionSource(); awaiter.SourceOnCompleted(state => { using (var tuple = (StateTuple, UniTask.Awaiter>)state) { var (inTcs, inAwaiter) = tuple; try { var result = inAwaiter.GetResult(); inTcs.SetResult(result); } catch (Exception ex) { inTcs.SetException(ex); } } }, StateTuple.Create(tcs, awaiter)); return tcs.Task; } catch (Exception ex) { return Task.FromException(ex); } } public static Task AsTask(this UniTask task) { try { UniTask.Awaiter awaiter; try { awaiter = task.GetAwaiter(); } catch (Exception ex) { return Task.FromException(ex); } if (awaiter.IsCompleted) { try { awaiter.GetResult(); // check token valid on Succeeded return Task.CompletedTask; } catch (Exception ex) { return Task.FromException(ex); } } var tcs = new TaskCompletionSource(); awaiter.SourceOnCompleted(state => { using (var tuple = (StateTuple, UniTask.Awaiter>)state) { var (inTcs, inAwaiter) = tuple; try { inAwaiter.GetResult(); inTcs.SetResult(null); } catch (Exception ex) { inTcs.SetException(ex); } } }, StateTuple.Create(tcs, awaiter)); return tcs.Task; } catch (Exception ex) { return Task.FromException(ex); } } public static AsyncLazy ToAsyncLazy(this UniTask task) { return new AsyncLazy(task); } public static AsyncLazy ToAsyncLazy(this UniTask task) { return new AsyncLazy(task); } /// /// Ignore task result when cancel raised first. /// public static UniTask AttachExternalCancellation(this UniTask task, CancellationToken cancellationToken) { if (!cancellationToken.CanBeCanceled) { return task; } if (cancellationToken.IsCancellationRequested) { task.Forget(); return UniTask.FromCanceled(cancellationToken); } if (task.Status.IsCompleted()) { return task; } return new UniTask(new AttachExternalCancellationSource(task, cancellationToken), 0); } /// /// Ignore task result when cancel raised first. /// public static UniTask AttachExternalCancellation(this UniTask task, CancellationToken cancellationToken) { if (!cancellationToken.CanBeCanceled) { return task; } if (cancellationToken.IsCancellationRequested) { task.Forget(); return UniTask.FromCanceled(cancellationToken); } if (task.Status.IsCompleted()) { return task; } return new UniTask(new AttachExternalCancellationSource(task, cancellationToken), 0); } sealed class AttachExternalCancellationSource : IUniTaskSource { static readonly Action cancellationCallbackDelegate = CancellationCallback; CancellationToken cancellationToken; CancellationTokenRegistration tokenRegistration; UniTaskCompletionSourceCore core; public AttachExternalCancellationSource(UniTask task, CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; this.tokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallbackDelegate, this); RunTask(task).Forget(); } async UniTaskVoid RunTask(UniTask task) { try { await task; core.TrySetResult(AsyncUnit.Default); } catch (Exception ex) { core.TrySetException(ex); } finally { tokenRegistration.Dispose(); } } static void CancellationCallback(object state) { var self = (AttachExternalCancellationSource)state; self.core.TrySetCanceled(self.cancellationToken); } public void GetResult(short token) { core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } } sealed class AttachExternalCancellationSource : IUniTaskSource { static readonly Action cancellationCallbackDelegate = CancellationCallback; CancellationToken cancellationToken; CancellationTokenRegistration tokenRegistration; UniTaskCompletionSourceCore core; public AttachExternalCancellationSource(UniTask task, CancellationToken cancellationToken) { this.cancellationToken = cancellationToken; this.tokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallbackDelegate, this); RunTask(task).Forget(); } async UniTaskVoid RunTask(UniTask task) { try { core.TrySetResult(await task); } catch (Exception ex) { core.TrySetException(ex); } finally { tokenRegistration.Dispose(); } } static void CancellationCallback(object state) { var self = (AttachExternalCancellationSource)state; self.core.TrySetCanceled(self.cancellationToken); } void IUniTaskSource.GetResult(short token) { core.GetResult(token); } public T GetResult(short token) { return core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } } #if UNITY_2018_3_OR_NEWER public static IEnumerator ToCoroutine(this UniTask task, Action resultHandler = null, Action exceptionHandler = null) { return new ToCoroutineEnumerator(task, resultHandler, exceptionHandler); } public static IEnumerator ToCoroutine(this UniTask task, Action exceptionHandler = null) { return new ToCoroutineEnumerator(task, exceptionHandler); } public static async UniTask Timeout(this UniTask task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null) { var delayCancellationTokenSource = new CancellationTokenSource(); var timeoutTask = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow(); int winArgIndex; bool taskResultIsCanceled; try { (winArgIndex, taskResultIsCanceled, _) = await UniTask.WhenAny(task.SuppressCancellationThrow(), timeoutTask); } catch { delayCancellationTokenSource.Cancel(); delayCancellationTokenSource.Dispose(); throw; } // timeout if (winArgIndex == 1) { if (taskCancellationTokenSource != null) { taskCancellationTokenSource.Cancel(); taskCancellationTokenSource.Dispose(); } throw new TimeoutException("Exceed Timeout:" + timeout); } else { delayCancellationTokenSource.Cancel(); delayCancellationTokenSource.Dispose(); } if (taskResultIsCanceled) { Error.ThrowOperationCanceledException(); } } public static async UniTask Timeout(this UniTask task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null) { var delayCancellationTokenSource = new CancellationTokenSource(); var timeoutTask = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow(); int winArgIndex; (bool IsCanceled, T Result) taskResult; try { (winArgIndex, taskResult, _) = await UniTask.WhenAny(task.SuppressCancellationThrow(), timeoutTask); } catch { delayCancellationTokenSource.Cancel(); delayCancellationTokenSource.Dispose(); throw; } // timeout if (winArgIndex == 1) { if (taskCancellationTokenSource != null) { taskCancellationTokenSource.Cancel(); taskCancellationTokenSource.Dispose(); } throw new TimeoutException("Exceed Timeout:" + timeout); } else { delayCancellationTokenSource.Cancel(); delayCancellationTokenSource.Dispose(); } if (taskResult.IsCanceled) { Error.ThrowOperationCanceledException(); } return taskResult.Result; } /// /// Timeout with suppress OperationCanceledException. Returns (bool, IsCanceled). /// public static async UniTask TimeoutWithoutException(this UniTask task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null) { var delayCancellationTokenSource = new CancellationTokenSource(); var timeoutTask = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow(); int winArgIndex; bool taskResultIsCanceled; try { (winArgIndex, taskResultIsCanceled, _) = await UniTask.WhenAny(task.SuppressCancellationThrow(), timeoutTask); } catch { delayCancellationTokenSource.Cancel(); delayCancellationTokenSource.Dispose(); return true; } // timeout if (winArgIndex == 1) { if (taskCancellationTokenSource != null) { taskCancellationTokenSource.Cancel(); taskCancellationTokenSource.Dispose(); } return true; } else { delayCancellationTokenSource.Cancel(); delayCancellationTokenSource.Dispose(); } if (taskResultIsCanceled) { return true; } return false; } /// /// Timeout with suppress OperationCanceledException. Returns (bool IsTimeout, T Result). /// public static async UniTask<(bool IsTimeout, T Result)> TimeoutWithoutException(this UniTask task, TimeSpan timeout, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming timeoutCheckTiming = PlayerLoopTiming.Update, CancellationTokenSource taskCancellationTokenSource = null) { var delayCancellationTokenSource = new CancellationTokenSource(); var timeoutTask = UniTask.Delay(timeout, delayType, timeoutCheckTiming, delayCancellationTokenSource.Token).SuppressCancellationThrow(); int winArgIndex; (bool IsCanceled, T Result) taskResult; try { (winArgIndex, taskResult, _) = await UniTask.WhenAny(task.SuppressCancellationThrow(), timeoutTask); } catch { delayCancellationTokenSource.Cancel(); delayCancellationTokenSource.Dispose(); return (true, default); } // timeout if (winArgIndex == 1) { if (taskCancellationTokenSource != null) { taskCancellationTokenSource.Cancel(); taskCancellationTokenSource.Dispose(); } return (true, default); } else { delayCancellationTokenSource.Cancel(); delayCancellationTokenSource.Dispose(); } if (taskResult.IsCanceled) { return (true, default); } return (false, taskResult.Result); } #endif public static void Forget(this UniTask task) { var awaiter = task.GetAwaiter(); if (awaiter.IsCompleted) { try { awaiter.GetResult(); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple)state) { try { t.Item1.GetResult(); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } }, StateTuple.Create(awaiter)); } } public static void Forget(this UniTask task, Action exceptionHandler, bool handleExceptionOnMainThread = true) { if (exceptionHandler == null) { Forget(task); } else { ForgetCoreWithCatch(task, exceptionHandler, handleExceptionOnMainThread).Forget(); } } static async UniTaskVoid ForgetCoreWithCatch(UniTask task, Action exceptionHandler, bool handleExceptionOnMainThread) { try { await task; } catch (Exception ex) { try { if (handleExceptionOnMainThread) { #if UNITY_2018_3_OR_NEWER await UniTask.SwitchToMainThread(); #endif } exceptionHandler(ex); } catch (Exception ex2) { UniTaskScheduler.PublishUnobservedTaskException(ex2); } } } public static void Forget(this UniTask task) { var awaiter = task.GetAwaiter(); if (awaiter.IsCompleted) { try { awaiter.GetResult(); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } else { awaiter.SourceOnCompleted(state => { using (var t = (StateTuple.Awaiter>)state) { try { t.Item1.GetResult(); } catch (Exception ex) { UniTaskScheduler.PublishUnobservedTaskException(ex); } } }, StateTuple.Create(awaiter)); } } public static void Forget(this UniTask task, Action exceptionHandler, bool handleExceptionOnMainThread = true) { if (exceptionHandler == null) { task.Forget(); } else { ForgetCoreWithCatch(task, exceptionHandler, handleExceptionOnMainThread).Forget(); } } static async UniTaskVoid ForgetCoreWithCatch(UniTask task, Action exceptionHandler, bool handleExceptionOnMainThread) { try { await task; } catch (Exception ex) { try { if (handleExceptionOnMainThread) { #if UNITY_2018_3_OR_NEWER await UniTask.SwitchToMainThread(); #endif } exceptionHandler(ex); } catch (Exception ex2) { UniTaskScheduler.PublishUnobservedTaskException(ex2); } } } public static async UniTask ContinueWith(this UniTask task, Action continuationFunction) { continuationFunction(await task); } public static async UniTask ContinueWith(this UniTask task, Func continuationFunction) { await continuationFunction(await task); } public static async UniTask ContinueWith(this UniTask task, Func continuationFunction) { return continuationFunction(await task); } public static async UniTask ContinueWith(this UniTask task, Func> continuationFunction) { return await continuationFunction(await task); } public static async UniTask ContinueWith(this UniTask task, Action continuationFunction) { await task; continuationFunction(); } public static async UniTask ContinueWith(this UniTask task, Func continuationFunction) { await task; await continuationFunction(); } public static async UniTask ContinueWith(this UniTask task, Func continuationFunction) { await task; return continuationFunction(); } public static async UniTask ContinueWith(this UniTask task, Func> continuationFunction) { await task; return await continuationFunction(); } public static async UniTask Unwrap(this UniTask> task) { return await await task; } public static async UniTask Unwrap(this UniTask task) { await await task; } public static async UniTask Unwrap(this Task> task) { return await await task; } public static async UniTask Unwrap(this Task> task, bool continueOnCapturedContext) { return await await task.ConfigureAwait(continueOnCapturedContext); } public static async UniTask Unwrap(this Task task) { await await task; } public static async UniTask Unwrap(this Task task, bool continueOnCapturedContext) { await await task.ConfigureAwait(continueOnCapturedContext); } public static async UniTask Unwrap(this UniTask> task) { return await await task; } public static async UniTask Unwrap(this UniTask> task, bool continueOnCapturedContext) { return await (await task).ConfigureAwait(continueOnCapturedContext); } public static async UniTask Unwrap(this UniTask task) { await await task; } public static async UniTask Unwrap(this UniTask task, bool continueOnCapturedContext) { await (await task).ConfigureAwait(continueOnCapturedContext); } #if UNITY_2018_3_OR_NEWER sealed class ToCoroutineEnumerator : IEnumerator { bool completed; UniTask task; Action exceptionHandler = null; bool isStarted = false; ExceptionDispatchInfo exception; public ToCoroutineEnumerator(UniTask task, Action exceptionHandler) { completed = false; this.exceptionHandler = exceptionHandler; this.task = task; } async UniTaskVoid RunTask(UniTask task) { try { await task; } catch (Exception ex) { if (exceptionHandler != null) { exceptionHandler(ex); } else { this.exception = ExceptionDispatchInfo.Capture(ex); } } finally { completed = true; } } public object Current => null; public bool MoveNext() { if (!isStarted) { isStarted = true; RunTask(task).Forget(); } if (exception != null) { exception.Throw(); return false; } return !completed; } void IEnumerator.Reset() { } } sealed class ToCoroutineEnumerator : IEnumerator { bool completed; Action resultHandler = null; Action exceptionHandler = null; bool isStarted = false; UniTask task; object current = null; ExceptionDispatchInfo exception; public ToCoroutineEnumerator(UniTask task, Action resultHandler, Action exceptionHandler) { completed = false; this.task = task; this.resultHandler = resultHandler; this.exceptionHandler = exceptionHandler; } async UniTaskVoid RunTask(UniTask task) { try { var value = await task; current = value; // boxed if T is struct... if (resultHandler != null) { resultHandler(value); } } catch (Exception ex) { if (exceptionHandler != null) { exceptionHandler(ex); } else { this.exception = ExceptionDispatchInfo.Capture(ex); } } finally { completed = true; } } public object Current => current; public bool MoveNext() { if (!isStarted) { isStarted = true; RunTask(task).Forget(); } if (exception != null) { exception.Throw(); return false; } return !completed; } void IEnumerator.Reset() { } } #endif } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 05460c617dae1e440861a7438535389f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskObservableExtensions.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.ExceptionServices; using System.Threading; using Cysharp.Threading.Tasks.Internal; namespace Cysharp.Threading.Tasks { public static class UniTaskObservableExtensions { public static UniTask ToUniTask(this IObservable source, bool useFirstValue = false, CancellationToken cancellationToken = default) { var promise = new UniTaskCompletionSource(); var disposable = new SingleAssignmentDisposable(); var observer = useFirstValue ? (IObserver)new FirstValueToUniTaskObserver(promise, disposable, cancellationToken) : (IObserver)new ToUniTaskObserver(promise, disposable, cancellationToken); try { disposable.Disposable = source.Subscribe(observer); } catch (Exception ex) { promise.TrySetException(ex); } return promise.Task; } public static IObservable ToObservable(this UniTask task) { if (task.Status.IsCompleted()) { try { return new ReturnObservable(task.GetAwaiter().GetResult()); } catch (Exception ex) { return new ThrowObservable(ex); } } var subject = new AsyncSubject(); Fire(subject, task).Forget(); return subject; } /// /// Ideally returns IObservabl[Unit] is best but Cysharp.Threading.Tasks does not have Unit so return AsyncUnit instead. /// public static IObservable ToObservable(this UniTask task) { if (task.Status.IsCompleted()) { try { task.GetAwaiter().GetResult(); return new ReturnObservable(AsyncUnit.Default); } catch (Exception ex) { return new ThrowObservable(ex); } } var subject = new AsyncSubject(); Fire(subject, task).Forget(); return subject; } static async UniTaskVoid Fire(AsyncSubject subject, UniTask task) { T value; try { value = await task; } catch (Exception ex) { subject.OnError(ex); return; } subject.OnNext(value); subject.OnCompleted(); } static async UniTaskVoid Fire(AsyncSubject subject, UniTask task) { try { await task; } catch (Exception ex) { subject.OnError(ex); return; } subject.OnNext(AsyncUnit.Default); subject.OnCompleted(); } class ToUniTaskObserver : IObserver { static readonly Action callback = OnCanceled; readonly UniTaskCompletionSource promise; readonly SingleAssignmentDisposable disposable; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration registration; bool hasValue; T latestValue; public ToUniTaskObserver(UniTaskCompletionSource promise, SingleAssignmentDisposable disposable, CancellationToken cancellationToken) { this.promise = promise; this.disposable = disposable; this.cancellationToken = cancellationToken; if (this.cancellationToken.CanBeCanceled) { this.registration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(callback, this); } } static void OnCanceled(object state) { var self = (ToUniTaskObserver)state; self.disposable.Dispose(); self.promise.TrySetCanceled(self.cancellationToken); } public void OnNext(T value) { hasValue = true; latestValue = value; } public void OnError(Exception error) { try { promise.TrySetException(error); } finally { registration.Dispose(); disposable.Dispose(); } } public void OnCompleted() { try { if (hasValue) { promise.TrySetResult(latestValue); } else { promise.TrySetException(new InvalidOperationException("Sequence has no elements")); } } finally { registration.Dispose(); disposable.Dispose(); } } } class FirstValueToUniTaskObserver : IObserver { static readonly Action callback = OnCanceled; readonly UniTaskCompletionSource promise; readonly SingleAssignmentDisposable disposable; readonly CancellationToken cancellationToken; readonly CancellationTokenRegistration registration; bool hasValue; public FirstValueToUniTaskObserver(UniTaskCompletionSource promise, SingleAssignmentDisposable disposable, CancellationToken cancellationToken) { this.promise = promise; this.disposable = disposable; this.cancellationToken = cancellationToken; if (this.cancellationToken.CanBeCanceled) { this.registration = this.cancellationToken.RegisterWithoutCaptureExecutionContext(callback, this); } } static void OnCanceled(object state) { var self = (FirstValueToUniTaskObserver)state; self.disposable.Dispose(); self.promise.TrySetCanceled(self.cancellationToken); } public void OnNext(T value) { hasValue = true; try { promise.TrySetResult(value); } finally { registration.Dispose(); disposable.Dispose(); } } public void OnError(Exception error) { try { promise.TrySetException(error); } finally { registration.Dispose(); disposable.Dispose(); } } public void OnCompleted() { try { if (!hasValue) { promise.TrySetException(new InvalidOperationException("Sequence has no elements")); } } finally { registration.Dispose(); disposable.Dispose(); } } } class ReturnObservable : IObservable { readonly T value; public ReturnObservable(T value) { this.value = value; } public IDisposable Subscribe(IObserver observer) { observer.OnNext(value); observer.OnCompleted(); return EmptyDisposable.Instance; } } class ThrowObservable : IObservable { readonly Exception value; public ThrowObservable(Exception value) { this.value = value; } public IDisposable Subscribe(IObserver observer) { observer.OnError(value); return EmptyDisposable.Instance; } } } } namespace Cysharp.Threading.Tasks.Internal { // Bridges for Rx. internal class EmptyDisposable : IDisposable { public static EmptyDisposable Instance = new EmptyDisposable(); EmptyDisposable() { } public void Dispose() { } } internal sealed class SingleAssignmentDisposable : IDisposable { readonly object gate = new object(); IDisposable current; bool disposed; public bool IsDisposed { get { lock (gate) { return disposed; } } } public IDisposable Disposable { get { return current; } set { var old = default(IDisposable); bool alreadyDisposed; lock (gate) { alreadyDisposed = disposed; old = current; if (!alreadyDisposed) { if (value == null) return; current = value; } } if (alreadyDisposed && value != null) { value.Dispose(); return; } if (old != null) throw new InvalidOperationException("Disposable is already set"); } } public void Dispose() { IDisposable old = null; lock (gate) { if (!disposed) { disposed = true; old = current; current = null; } } if (old != null) old.Dispose(); } } internal sealed class AsyncSubject : IObservable, IObserver { object observerLock = new object(); T lastValue; bool hasValue; bool isStopped; bool isDisposed; Exception lastError; IObserver outObserver = EmptyObserver.Instance; public T Value { get { ThrowIfDisposed(); if (!isStopped) throw new InvalidOperationException("AsyncSubject is not completed yet"); if (lastError != null) ExceptionDispatchInfo.Capture(lastError).Throw(); return lastValue; } } public bool HasObservers { get { return !(outObserver is EmptyObserver) && !isStopped && !isDisposed; } } public bool IsCompleted { get { return isStopped; } } public void OnCompleted() { IObserver old; T v; bool hv; lock (observerLock) { ThrowIfDisposed(); if (isStopped) return; old = outObserver; outObserver = EmptyObserver.Instance; isStopped = true; v = lastValue; hv = hasValue; } if (hv) { old.OnNext(v); old.OnCompleted(); } else { old.OnCompleted(); } } public void OnError(Exception error) { if (error == null) throw new ArgumentNullException("error"); IObserver old; lock (observerLock) { ThrowIfDisposed(); if (isStopped) return; old = outObserver; outObserver = EmptyObserver.Instance; isStopped = true; lastError = error; } old.OnError(error); } public void OnNext(T value) { lock (observerLock) { ThrowIfDisposed(); if (isStopped) return; this.hasValue = true; this.lastValue = value; } } public IDisposable Subscribe(IObserver observer) { if (observer == null) throw new ArgumentNullException("observer"); var ex = default(Exception); var v = default(T); var hv = false; lock (observerLock) { ThrowIfDisposed(); if (!isStopped) { var listObserver = outObserver as ListObserver; if (listObserver != null) { outObserver = listObserver.Add(observer); } else { var current = outObserver; if (current is EmptyObserver) { outObserver = observer; } else { outObserver = new ListObserver(new ImmutableList>(new[] { current, observer })); } } return new Subscription(this, observer); } ex = lastError; v = lastValue; hv = hasValue; } if (ex != null) { observer.OnError(ex); } else if (hv) { observer.OnNext(v); observer.OnCompleted(); } else { observer.OnCompleted(); } return EmptyDisposable.Instance; } public void Dispose() { lock (observerLock) { isDisposed = true; outObserver = DisposedObserver.Instance; lastError = null; lastValue = default(T); } } void ThrowIfDisposed() { if (isDisposed) throw new ObjectDisposedException(""); } class Subscription : IDisposable { readonly object gate = new object(); AsyncSubject parent; IObserver unsubscribeTarget; public Subscription(AsyncSubject parent, IObserver unsubscribeTarget) { this.parent = parent; this.unsubscribeTarget = unsubscribeTarget; } public void Dispose() { lock (gate) { if (parent != null) { lock (parent.observerLock) { var listObserver = parent.outObserver as ListObserver; if (listObserver != null) { parent.outObserver = listObserver.Remove(unsubscribeTarget); } else { parent.outObserver = EmptyObserver.Instance; } unsubscribeTarget = null; parent = null; } } } } } } internal class ListObserver : IObserver { private readonly ImmutableList> _observers; public ListObserver(ImmutableList> observers) { _observers = observers; } public void OnCompleted() { var targetObservers = _observers.Data; for (int i = 0; i < targetObservers.Length; i++) { targetObservers[i].OnCompleted(); } } public void OnError(Exception error) { var targetObservers = _observers.Data; for (int i = 0; i < targetObservers.Length; i++) { targetObservers[i].OnError(error); } } public void OnNext(T value) { var targetObservers = _observers.Data; for (int i = 0; i < targetObservers.Length; i++) { targetObservers[i].OnNext(value); } } internal IObserver Add(IObserver observer) { return new ListObserver(_observers.Add(observer)); } internal IObserver Remove(IObserver observer) { var i = Array.IndexOf(_observers.Data, observer); if (i < 0) return this; if (_observers.Data.Length == 2) { return _observers.Data[1 - i]; } else { return new ListObserver(_observers.Remove(observer)); } } } internal class EmptyObserver : IObserver { public static readonly EmptyObserver Instance = new EmptyObserver(); EmptyObserver() { } public void OnCompleted() { } public void OnError(Exception error) { } public void OnNext(T value) { } } internal class ThrowObserver : IObserver { public static readonly ThrowObserver Instance = new ThrowObserver(); ThrowObserver() { } public void OnCompleted() { } public void OnError(Exception error) { ExceptionDispatchInfo.Capture(error).Throw(); } public void OnNext(T value) { } } internal class DisposedObserver : IObserver { public static readonly DisposedObserver Instance = new DisposedObserver(); DisposedObserver() { } public void OnCompleted() { throw new ObjectDisposedException(""); } public void OnError(Exception error) { throw new ObjectDisposedException(""); } public void OnNext(T value) { throw new ObjectDisposedException(""); } } internal class ImmutableList { public static readonly ImmutableList Empty = new ImmutableList(); T[] data; public T[] Data { get { return data; } } ImmutableList() { data = new T[0]; } public ImmutableList(T[] data) { this.data = data; } public ImmutableList Add(T value) { var newData = new T[data.Length + 1]; Array.Copy(data, newData, data.Length); newData[data.Length] = value; return new ImmutableList(newData); } public ImmutableList Remove(T value) { var i = IndexOf(value); if (i < 0) return this; var length = data.Length; if (length == 1) return Empty; var newData = new T[length - 1]; Array.Copy(data, 0, newData, 0, i); Array.Copy(data, i + 1, newData, i, length - i - 1); return new ImmutableList(newData); } public int IndexOf(T value) { for (var i = 0; i < data.Length; ++i) { // ImmutableList only use for IObserver(no worry for boxed) if (object.Equals(data[i], value)) return i; } return -1; } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskObservableExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: eaea262a5ad393d419c15b3b2901d664 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskScheduler.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; namespace Cysharp.Threading.Tasks { // UniTask has no scheduler like TaskScheduler. // Only handle unobserved exception. public static class UniTaskScheduler { public static event Action UnobservedTaskException; /// /// Propagate OperationCanceledException to UnobservedTaskException when true. Default is false. /// public static bool PropagateOperationCanceledException = false; #if UNITY_2018_3_OR_NEWER /// /// Write log type when catch unobserved exception and not registered UnobservedTaskException. Default is Exception. /// public static UnityEngine.LogType UnobservedExceptionWriteLogType = UnityEngine.LogType.Exception; /// /// Dispatch exception event to Unity MainThread. Default is true. /// public static bool DispatchUnityMainThread = true; // cache delegate. static readonly SendOrPostCallback handleExceptionInvoke = InvokeUnobservedTaskException; static void InvokeUnobservedTaskException(object state) { UnobservedTaskException((Exception)state); } #endif internal static void PublishUnobservedTaskException(Exception ex) { if (ex != null) { if (!PropagateOperationCanceledException && ex is OperationCanceledException) { return; } if (UnobservedTaskException != null) { #if UNITY_2018_3_OR_NEWER if (!DispatchUnityMainThread || Thread.CurrentThread.ManagedThreadId == PlayerLoopHelper.MainThreadId) { // allows inlining call. UnobservedTaskException.Invoke(ex); } else { // Post to MainThread. PlayerLoopHelper.UnitySynchronizationContext.Post(handleExceptionInvoke, ex); } #else UnobservedTaskException.Invoke(ex); #endif } else { #if UNITY_2018_3_OR_NEWER string msg = null; if (UnobservedExceptionWriteLogType != UnityEngine.LogType.Exception) { msg = "UnobservedTaskException: " + ex.ToString(); } switch (UnobservedExceptionWriteLogType) { case UnityEngine.LogType.Error: UnityEngine.Debug.LogError(msg); break; case UnityEngine.LogType.Assert: UnityEngine.Debug.LogAssertion(msg); break; case UnityEngine.LogType.Warning: UnityEngine.Debug.LogWarning(msg); break; case UnityEngine.LogType.Log: UnityEngine.Debug.Log(msg); break; case UnityEngine.LogType.Exception: UnityEngine.Debug.LogException(ex); break; default: break; } #else Console.WriteLine("UnobservedTaskException: " + ex.ToString()); #endif } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskScheduler.cs.meta ================================================ fileFormatVersion: 2 guid: d6cad69921702d5488d96b5ef30df1b0 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskSynchronizationContext.cs ================================================ using System; using System.Runtime.InteropServices; using System.Threading; namespace Cysharp.Threading.Tasks { public class UniTaskSynchronizationContext : SynchronizationContext { const int MaxArrayLength = 0X7FEFFFFF; const int InitialSize = 16; static SpinLock gate = new SpinLock(false); static bool dequing = false; static int actionListCount = 0; static Callback[] actionList = new Callback[InitialSize]; static int waitingListCount = 0; static Callback[] waitingList = new Callback[InitialSize]; static int opCount; public override void Send(SendOrPostCallback d, object state) { d(state); } public override void Post(SendOrPostCallback d, object state) { bool lockTaken = false; try { gate.Enter(ref lockTaken); if (dequing) { // Ensure Capacity if (waitingList.Length == waitingListCount) { var newLength = waitingListCount * 2; if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength; var newArray = new Callback[newLength]; Array.Copy(waitingList, newArray, waitingListCount); waitingList = newArray; } waitingList[waitingListCount] = new Callback(d, state); waitingListCount++; } else { // Ensure Capacity if (actionList.Length == actionListCount) { var newLength = actionListCount * 2; if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength; var newArray = new Callback[newLength]; Array.Copy(actionList, newArray, actionListCount); actionList = newArray; } actionList[actionListCount] = new Callback(d, state); actionListCount++; } } finally { if (lockTaken) gate.Exit(false); } } public override void OperationStarted() { Interlocked.Increment(ref opCount); } public override void OperationCompleted() { Interlocked.Decrement(ref opCount); } public override SynchronizationContext CreateCopy() { return this; } // delegate entrypoint. internal static void Run() { { bool lockTaken = false; try { gate.Enter(ref lockTaken); if (actionListCount == 0) return; dequing = true; } finally { if (lockTaken) gate.Exit(false); } } for (int i = 0; i < actionListCount; i++) { var action = actionList[i]; actionList[i] = default; action.Invoke(); } { bool lockTaken = false; try { gate.Enter(ref lockTaken); dequing = false; var swapTempActionList = actionList; actionListCount = waitingListCount; actionList = waitingList; waitingListCount = 0; waitingList = swapTempActionList; } finally { if (lockTaken) gate.Exit(false); } } } [StructLayout(LayoutKind.Auto)] readonly struct Callback { readonly SendOrPostCallback callback; readonly object state; public Callback(SendOrPostCallback callback, object state) { this.callback = callback; this.state = state; } public void Invoke() { try { callback(state); } catch (Exception ex) { UnityEngine.Debug.LogException(ex); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskSynchronizationContext.cs.meta ================================================ fileFormatVersion: 2 guid: abf3aae9813db2849bce518f8596e920 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskVoid.cs ================================================ #pragma warning disable CS1591 #pragma warning disable CS0436 using System; using System.Diagnostics; using System.Runtime.CompilerServices; using Cysharp.Threading.Tasks.CompilerServices; namespace Cysharp.Threading.Tasks { [AsyncMethodBuilder(typeof(AsyncUniTaskVoidMethodBuilder))] public readonly struct UniTaskVoid { public void Forget() { } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskVoid.cs.meta ================================================ fileFormatVersion: 2 guid: e9f28cd922179634d863011548f89ae7 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AssetBundleRequestAllAssets.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member #if UNITY_2018_4 || UNITY_2019_4_OR_NEWER #if UNITASK_ASSETBUNDLE_SUPPORT using Cysharp.Threading.Tasks.Internal; using System; using System.Runtime.CompilerServices; using System.Threading; using UnityEngine; namespace Cysharp.Threading.Tasks { public static partial class UnityAsyncExtensions { public static AssetBundleRequestAllAssetsAwaiter AwaitForAllAssets(this AssetBundleRequest asyncOperation) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); return new AssetBundleRequestAllAssetsAwaiter(asyncOperation); } public static UniTask AwaitForAllAssets(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken) { return AwaitForAllAssets(asyncOperation, null, PlayerLoopTiming.Update, cancellationToken: cancellationToken); } public static UniTask AwaitForAllAssets(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return AwaitForAllAssets(asyncOperation, progress: null, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask AwaitForAllAssets(this AssetBundleRequest asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.allAssets); return new UniTask(AssetBundleRequestAllAssetsConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } public struct AssetBundleRequestAllAssetsAwaiter : ICriticalNotifyCompletion { AssetBundleRequest asyncOperation; Action continuationAction; public AssetBundleRequestAllAssetsAwaiter(AssetBundleRequest asyncOperation) { this.asyncOperation = asyncOperation; this.continuationAction = null; } public AssetBundleRequestAllAssetsAwaiter GetAwaiter() { return this; } public bool IsCompleted => asyncOperation.isDone; public UnityEngine.Object[] GetResult() { if (continuationAction != null) { asyncOperation.completed -= continuationAction; continuationAction = null; var result = asyncOperation.allAssets; asyncOperation = null; return result; } else { var result = asyncOperation.allAssets; asyncOperation = null; return result; } } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction); continuationAction = PooledDelegate.Create(continuation); asyncOperation.completed += continuationAction; } } sealed class AssetBundleRequestAllAssetsConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; AssetBundleRequestAllAssetsConfiguredSource nextNode; public ref AssetBundleRequestAllAssetsConfiguredSource NextNode => ref nextNode; static AssetBundleRequestAllAssetsConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestAllAssetsConfiguredSource), () => pool.Size); } AssetBundleRequest asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; Action continuationAction; AssetBundleRequestAllAssetsConfiguredSource() { continuationAction = Continuation; } public static IUniTaskSource Create(AssetBundleRequest asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AssetBundleRequestAllAssetsConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (AssetBundleRequestAllAssetsConfiguredSource)state; source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public UnityEngine.Object[] GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { core.TrySetResult(asyncOperation.allAssets); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } else { core.TrySetResult(asyncOperation.allAssets); } } } } } #endif #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AssetBundleRequestAllAssets.cs.meta ================================================ fileFormatVersion: 2 guid: e9147caba40da434da95b39709c13784 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AsyncGPUReadback.cs ================================================  #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; using UnityEngine.Rendering; namespace Cysharp.Threading.Tasks { public static partial class UnityAsyncExtensions { #region AsyncGPUReadbackRequest public static UniTask.Awaiter GetAwaiter(this AsyncGPUReadbackRequest asyncOperation) { return ToUniTask(asyncOperation).GetAwaiter(); } public static UniTask WithCancellation(this AsyncGPUReadbackRequest asyncOperation, CancellationToken cancellationToken) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static UniTask WithCancellation(this AsyncGPUReadbackRequest asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask ToUniTask(this AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { if (asyncOperation.done) return UniTask.FromResult(asyncOperation); return new UniTask(AsyncGPUReadbackRequestAwaiterConfiguredSource.Create(asyncOperation, timing, cancellationToken, cancelImmediately, out var token), token); } sealed class AsyncGPUReadbackRequestAwaiterConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; AsyncGPUReadbackRequestAwaiterConfiguredSource nextNode; public ref AsyncGPUReadbackRequestAwaiterConfiguredSource NextNode => ref nextNode; static AsyncGPUReadbackRequestAwaiterConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AsyncGPUReadbackRequestAwaiterConfiguredSource), () => pool.Size); } AsyncGPUReadbackRequest asyncOperation; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; UniTaskCompletionSourceCore core; AsyncGPUReadbackRequestAwaiterConfiguredSource() { } public static IUniTaskSource Create(AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AsyncGPUReadbackRequestAwaiterConfiguredSource(); } result.asyncOperation = asyncOperation; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var promise = (AsyncGPUReadbackRequestAwaiterConfiguredSource)state; promise.core.TrySetCanceled(promise.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public AsyncGPUReadbackRequest GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (asyncOperation.hasError) { core.TrySetException(new Exception("AsyncGPUReadbackRequest.hasError = true")); return false; } if (asyncOperation.done) { core.TrySetResult(asyncOperation); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } } #endregion } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AsyncGPUReadback.cs.meta ================================================ fileFormatVersion: 2 guid: 98f5fedb44749ab4688674d79126b46a MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AsyncInstantiate.cs ================================================ // AsyncInstantiateOperation was added since Unity 2022.3.20 / 2023.3.0b7 #if UNITY_2022_3 && !(UNITY_2022_3_0 || UNITY_2022_3_1 || UNITY_2022_3_2 || UNITY_2022_3_3 || UNITY_2022_3_4 || UNITY_2022_3_5 || UNITY_2022_3_6 || UNITY_2022_3_7 || UNITY_2022_3_8 || UNITY_2022_3_9 || UNITY_2022_3_10 || UNITY_2022_3_11 || UNITY_2022_3_12 || UNITY_2022_3_13 || UNITY_2022_3_14 || UNITY_2022_3_15 || UNITY_2022_3_16 || UNITY_2022_3_17 || UNITY_2022_3_18 || UNITY_2022_3_19) #define UNITY_2022_SUPPORT #endif #if UNITY_2022_SUPPORT || UNITY_2023_3_OR_NEWER using Cysharp.Threading.Tasks.Internal; using System; using System.Threading; using UnityEngine; namespace Cysharp.Threading.Tasks { public static class AsyncInstantiateOperationExtensions { // AsyncInstantiateOperation has GetAwaiter so no need to impl // public static UniTask.Awaiter GetAwaiter(this AsyncInstantiateOperation operation) where T : Object public static UniTask WithCancellation(this AsyncInstantiateOperation asyncOperation, CancellationToken cancellationToken) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static UniTask WithCancellation(this AsyncInstantiateOperation asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask ToUniTask(this AsyncInstantiateOperation asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.Result); return new UniTask(AsyncInstantiateOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } public static UniTask WithCancellation(this AsyncInstantiateOperation asyncOperation, CancellationToken cancellationToken) where T : UnityEngine.Object { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static UniTask WithCancellation(this AsyncInstantiateOperation asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) where T : UnityEngine.Object { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask ToUniTask(this AsyncInstantiateOperation asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) where T : UnityEngine.Object { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.Result); return new UniTask(AsyncInstantiateOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } sealed class AsyncInstantiateOperationConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; AsyncInstantiateOperationConfiguredSource nextNode; public ref AsyncInstantiateOperationConfiguredSource NextNode => ref nextNode; static AsyncInstantiateOperationConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AsyncInstantiateOperationConfiguredSource), () => pool.Size); } AsyncInstantiateOperation asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; Action continuationAction; AsyncInstantiateOperationConfiguredSource() { continuationAction = Continuation; } public static IUniTaskSource Create(AsyncInstantiateOperation asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AsyncInstantiateOperationConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (AsyncInstantiateOperationConfiguredSource)state; source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public UnityEngine.Object[] GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { core.TrySetResult(asyncOperation.Result); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation.completed -= continuationAction; asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } else { core.TrySetResult(asyncOperation.Result); } } } sealed class AsyncInstantiateOperationConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode> where T : UnityEngine.Object { static TaskPool> pool; AsyncInstantiateOperationConfiguredSource nextNode; public ref AsyncInstantiateOperationConfiguredSource NextNode => ref nextNode; static AsyncInstantiateOperationConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AsyncInstantiateOperationConfiguredSource), () => pool.Size); } AsyncInstantiateOperation asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; Action continuationAction; AsyncInstantiateOperationConfiguredSource() { continuationAction = Continuation; } public static IUniTaskSource Create(AsyncInstantiateOperation asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AsyncInstantiateOperationConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (AsyncInstantiateOperationConfiguredSource)state; source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public T[] GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { core.TrySetResult(asyncOperation.Result); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation.completed -= continuationAction; asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } else { core.TrySetResult(asyncOperation.Result); } } } } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.AsyncInstantiate.cs.meta ================================================ fileFormatVersion: 2 guid: 8321f4244edfdcd4798b4fcc92a736c9 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.Jobs.cs ================================================ #if ENABLE_MANAGED_JOBS #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Threading; using Unity.Jobs; using UnityEngine; namespace Cysharp.Threading.Tasks { public static partial class UnityAsyncExtensions { public static async UniTask WaitAsync(this JobHandle jobHandle, PlayerLoopTiming waitTiming, CancellationToken cancellationToken = default) { await UniTask.Yield(waitTiming); jobHandle.Complete(); cancellationToken.ThrowIfCancellationRequested(); // call cancel after Complete. } public static UniTask.Awaiter GetAwaiter(this JobHandle jobHandle) { var handler = JobHandlePromise.Create(jobHandle, out var token); { PlayerLoopHelper.AddAction(PlayerLoopTiming.EarlyUpdate, handler); PlayerLoopHelper.AddAction(PlayerLoopTiming.PreUpdate, handler); PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, handler); PlayerLoopHelper.AddAction(PlayerLoopTiming.PreLateUpdate, handler); PlayerLoopHelper.AddAction(PlayerLoopTiming.PostLateUpdate, handler); } return new UniTask(handler, token).GetAwaiter(); } // can not pass CancellationToken because can't handle JobHandle's Complete and NativeArray.Dispose. public static UniTask ToUniTask(this JobHandle jobHandle, PlayerLoopTiming waitTiming) { var handler = JobHandlePromise.Create(jobHandle, out var token); { PlayerLoopHelper.AddAction(waitTiming, handler); } return new UniTask(handler, token); } sealed class JobHandlePromise : IUniTaskSource, IPlayerLoopItem { JobHandle jobHandle; UniTaskCompletionSourceCore core; // Cancellation is not supported. public static JobHandlePromise Create(JobHandle jobHandle, out short token) { // not use pool. var result = new JobHandlePromise(); result.jobHandle = jobHandle; TaskTracker.TrackActiveTask(result, 3); token = result.core.Version; return result; } public void GetResult(short token) { TaskTracker.RemoveTracking(this); core.GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { if (jobHandle.IsCompleted | PlayerLoopHelper.IsEditorApplicationQuitting) { jobHandle.Complete(); core.TrySetResult(AsyncUnit.Default); return false; } return true; } } } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.Jobs.cs.meta ================================================ fileFormatVersion: 2 guid: 30979a768fbd4b94f8694eee8a305c99 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.MonoBehaviour.cs ================================================ using System; using System.Threading; namespace Cysharp.Threading.Tasks { public static partial class UnityAsyncExtensions { public static UniTask StartAsyncCoroutine(this UnityEngine.MonoBehaviour monoBehaviour, Func asyncCoroutine) { var token = monoBehaviour.GetCancellationTokenOnDestroy(); return asyncCoroutine(token); } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.MonoBehaviour.cs.meta ================================================ fileFormatVersion: 2 guid: 2edd588bb09eb0a4695d039d6a1f02b2 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; using System.Threading; using UnityEngine; using Cysharp.Threading.Tasks.Internal; #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT) using UnityEngine.Networking; #endif namespace Cysharp.Threading.Tasks { public static partial class UnityAsyncExtensions { #region AsyncOperation #if !UNITY_2023_1_OR_NEWER // from Unity2023.1.0a15, AsyncOperationAwaitableExtensions.GetAwaiter is defined in UnityEngine. public static AsyncOperationAwaiter GetAwaiter(this AsyncOperation asyncOperation) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); return new AsyncOperationAwaiter(asyncOperation); } #endif public static UniTask WithCancellation(this AsyncOperation asyncOperation, CancellationToken cancellationToken) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static UniTask WithCancellation(this AsyncOperation asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask ToUniTask(this AsyncOperation asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (asyncOperation.isDone) return UniTask.CompletedTask; return new UniTask(AsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } public struct AsyncOperationAwaiter : ICriticalNotifyCompletion { AsyncOperation asyncOperation; Action continuationAction; public AsyncOperationAwaiter(AsyncOperation asyncOperation) { this.asyncOperation = asyncOperation; this.continuationAction = null; } public bool IsCompleted => asyncOperation.isDone; public void GetResult() { if (continuationAction != null) { asyncOperation.completed -= continuationAction; continuationAction = null; asyncOperation = null; } else { asyncOperation = null; } } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction); continuationAction = PooledDelegate.Create(continuation); asyncOperation.completed += continuationAction; } } sealed class AsyncOperationConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; AsyncOperationConfiguredSource nextNode; public ref AsyncOperationConfiguredSource NextNode => ref nextNode; static AsyncOperationConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AsyncOperationConfiguredSource), () => pool.Size); } AsyncOperation asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; Action continuationAction; AsyncOperationConfiguredSource() { continuationAction = Continuation; } public static IUniTaskSource Create(AsyncOperation asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AsyncOperationConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (AsyncOperationConfiguredSource)state; source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public void GetResult(short token) { try { core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { core.TrySetResult(AsyncUnit.Default); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation.completed -= continuationAction; asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } else { core.TrySetResult(AsyncUnit.Default); } } } #endregion #region ResourceRequest public static ResourceRequestAwaiter GetAwaiter(this ResourceRequest asyncOperation) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); return new ResourceRequestAwaiter(asyncOperation); } public static UniTask WithCancellation(this ResourceRequest asyncOperation, CancellationToken cancellationToken) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static UniTask WithCancellation(this ResourceRequest asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask ToUniTask(this ResourceRequest asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset); return new UniTask(ResourceRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } public struct ResourceRequestAwaiter : ICriticalNotifyCompletion { ResourceRequest asyncOperation; Action continuationAction; public ResourceRequestAwaiter(ResourceRequest asyncOperation) { this.asyncOperation = asyncOperation; this.continuationAction = null; } public bool IsCompleted => asyncOperation.isDone; public UnityEngine.Object GetResult() { if (continuationAction != null) { asyncOperation.completed -= continuationAction; continuationAction = null; var result = asyncOperation.asset; asyncOperation = null; return result; } else { var result = asyncOperation.asset; asyncOperation = null; return result; } } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction); continuationAction = PooledDelegate.Create(continuation); asyncOperation.completed += continuationAction; } } sealed class ResourceRequestConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; ResourceRequestConfiguredSource nextNode; public ref ResourceRequestConfiguredSource NextNode => ref nextNode; static ResourceRequestConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(ResourceRequestConfiguredSource), () => pool.Size); } ResourceRequest asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; Action continuationAction; ResourceRequestConfiguredSource() { continuationAction = Continuation; } public static IUniTaskSource Create(ResourceRequest asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new ResourceRequestConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (ResourceRequestConfiguredSource)state; source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public UnityEngine.Object GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { core.TrySetResult(asyncOperation.asset); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation.completed -= continuationAction; asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } else { core.TrySetResult(asyncOperation.asset); } } } #endregion #if UNITASK_ASSETBUNDLE_SUPPORT #region AssetBundleRequest public static AssetBundleRequestAwaiter GetAwaiter(this AssetBundleRequest asyncOperation) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); return new AssetBundleRequestAwaiter(asyncOperation); } public static UniTask WithCancellation(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static UniTask WithCancellation(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask ToUniTask(this AssetBundleRequest asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset); return new UniTask(AssetBundleRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } public struct AssetBundleRequestAwaiter : ICriticalNotifyCompletion { AssetBundleRequest asyncOperation; Action continuationAction; public AssetBundleRequestAwaiter(AssetBundleRequest asyncOperation) { this.asyncOperation = asyncOperation; this.continuationAction = null; } public bool IsCompleted => asyncOperation.isDone; public UnityEngine.Object GetResult() { if (continuationAction != null) { asyncOperation.completed -= continuationAction; continuationAction = null; var result = asyncOperation.asset; asyncOperation = null; return result; } else { var result = asyncOperation.asset; asyncOperation = null; return result; } } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction); continuationAction = PooledDelegate.Create(continuation); asyncOperation.completed += continuationAction; } } sealed class AssetBundleRequestConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; AssetBundleRequestConfiguredSource nextNode; public ref AssetBundleRequestConfiguredSource NextNode => ref nextNode; static AssetBundleRequestConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestConfiguredSource), () => pool.Size); } AssetBundleRequest asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; Action continuationAction; AssetBundleRequestConfiguredSource() { continuationAction = Continuation; } public static IUniTaskSource Create(AssetBundleRequest asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AssetBundleRequestConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (AssetBundleRequestConfiguredSource)state; source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public UnityEngine.Object GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { core.TrySetResult(asyncOperation.asset); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation.completed -= continuationAction; asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } else { core.TrySetResult(asyncOperation.asset); } } } #endregion #endif #if UNITASK_ASSETBUNDLE_SUPPORT #region AssetBundleCreateRequest public static AssetBundleCreateRequestAwaiter GetAwaiter(this AssetBundleCreateRequest asyncOperation) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); return new AssetBundleCreateRequestAwaiter(asyncOperation); } public static UniTask WithCancellation(this AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static UniTask WithCancellation(this AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask ToUniTask(this AssetBundleCreateRequest asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle); return new UniTask(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } public struct AssetBundleCreateRequestAwaiter : ICriticalNotifyCompletion { AssetBundleCreateRequest asyncOperation; Action continuationAction; public AssetBundleCreateRequestAwaiter(AssetBundleCreateRequest asyncOperation) { this.asyncOperation = asyncOperation; this.continuationAction = null; } public bool IsCompleted => asyncOperation.isDone; public AssetBundle GetResult() { if (continuationAction != null) { asyncOperation.completed -= continuationAction; continuationAction = null; var result = asyncOperation.assetBundle; asyncOperation = null; return result; } else { var result = asyncOperation.assetBundle; asyncOperation = null; return result; } } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction); continuationAction = PooledDelegate.Create(continuation); asyncOperation.completed += continuationAction; } } sealed class AssetBundleCreateRequestConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; AssetBundleCreateRequestConfiguredSource nextNode; public ref AssetBundleCreateRequestConfiguredSource NextNode => ref nextNode; static AssetBundleCreateRequestConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(AssetBundleCreateRequestConfiguredSource), () => pool.Size); } AssetBundleCreateRequest asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; Action continuationAction; AssetBundleCreateRequestConfiguredSource() { continuationAction = Continuation; } public static IUniTaskSource Create(AssetBundleCreateRequest asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new AssetBundleCreateRequestConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (AssetBundleCreateRequestConfiguredSource)state; source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public AssetBundle GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { core.TrySetResult(asyncOperation.assetBundle); return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation.completed -= continuationAction; asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } else { core.TrySetResult(asyncOperation.assetBundle); } } } #endregion #endif #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT) #region UnityWebRequestAsyncOperation public static UnityWebRequestAsyncOperationAwaiter GetAwaiter(this UnityWebRequestAsyncOperation asyncOperation) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); return new UnityWebRequestAsyncOperationAwaiter(asyncOperation); } public static UniTask WithCancellation(this UnityWebRequestAsyncOperation asyncOperation, CancellationToken cancellationToken) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static UniTask WithCancellation(this UnityWebRequestAsyncOperation asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static UniTask ToUniTask(this UnityWebRequestAsyncOperation asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled(cancellationToken); if (asyncOperation.isDone) { if (asyncOperation.webRequest.IsError()) { return UniTask.FromException(new UnityWebRequestException(asyncOperation.webRequest)); } return UniTask.FromResult(asyncOperation.webRequest); } return new UniTask(UnityWebRequestAsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } public struct UnityWebRequestAsyncOperationAwaiter : ICriticalNotifyCompletion { UnityWebRequestAsyncOperation asyncOperation; Action continuationAction; public UnityWebRequestAsyncOperationAwaiter(UnityWebRequestAsyncOperation asyncOperation) { this.asyncOperation = asyncOperation; this.continuationAction = null; } public bool IsCompleted => asyncOperation.isDone; public UnityWebRequest GetResult() { if (continuationAction != null) { asyncOperation.completed -= continuationAction; continuationAction = null; var result = asyncOperation.webRequest; asyncOperation = null; if (result.IsError()) { throw new UnityWebRequestException(result); } return result; } else { var result = asyncOperation.webRequest; asyncOperation = null; if (result.IsError()) { throw new UnityWebRequestException(result); } return result; } } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction); continuationAction = PooledDelegate.Create(continuation); asyncOperation.completed += continuationAction; } } sealed class UnityWebRequestAsyncOperationConfiguredSource : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode { static TaskPool pool; UnityWebRequestAsyncOperationConfiguredSource nextNode; public ref UnityWebRequestAsyncOperationConfiguredSource NextNode => ref nextNode; static UnityWebRequestAsyncOperationConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(UnityWebRequestAsyncOperationConfiguredSource), () => pool.Size); } UnityWebRequestAsyncOperation asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore core; Action continuationAction; UnityWebRequestAsyncOperationConfiguredSource() { continuationAction = Continuation; } public static IUniTaskSource Create(UnityWebRequestAsyncOperation asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new UnityWebRequestAsyncOperationConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (UnityWebRequestAsyncOperationConfiguredSource)state; source.asyncOperation.webRequest.Abort(); source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public UnityWebRequest GetResult(short token) { try { return core.GetResult(token); } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } else { TaskTracker.RemoveTracking(this); } } } void IUniTaskSource.GetResult(short token) { GetResult(token); } public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { asyncOperation.webRequest.Abort(); core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { if (asyncOperation.webRequest.IsError()) { core.TrySetException(new UnityWebRequestException(asyncOperation.webRequest)); } else { core.TrySetResult(asyncOperation.webRequest); } return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation.completed -= continuationAction; asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } else if (asyncOperation.webRequest.IsError()) { core.TrySetException(new UnityWebRequestException(asyncOperation.webRequest)); } else { core.TrySetResult(asyncOperation.webRequest); } } } #endregion #endif } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 8cc7fd65dd1433e419be4764aeb51391 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.tt ================================================ <#@ template debug="false" hostspecific="false" language="C#" #> <#@ assembly name="System.Core" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Collections.Generic" #> <#@ output extension=".cs" #> <# var types = new (string typeName, string returnType, string returnField)[] { ("AsyncOperation", "void", null), ("ResourceRequest", "UnityEngine.Object", "asset"), ("AssetBundleRequest", "UnityEngine.Object", "asset"), // allAssets? ("AssetBundleCreateRequest", "AssetBundle", "assetBundle"), ("UnityWebRequestAsyncOperation", "UnityWebRequest", "webRequest") // -> #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT) }; Func ToUniTaskReturnType = x => (x == "void") ? "UniTask" : $"UniTask<{x}>"; Func ToIUniTaskSourceReturnType = x => (x == "void") ? "IUniTaskSource" : $"IUniTaskSource<{x}>"; Func<(string typeName, string returnType, string returnField), bool> IsAsyncOperationBase = x => x.typeName == "AsyncOperation"; Func<(string typeName, string returnType, string returnField), bool> IsUnityWebRequest = x => x.returnType == "UnityWebRequest"; Func<(string typeName, string returnType, string returnField), bool> IsAssetBundleModule = x => x.typeName == "AssetBundleRequest" || x.typeName == "AssetBundleCreateRequest"; Func<(string typeName, string returnType, string returnField), bool> IsVoid = x => x.returnType == "void"; #> #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using System; using System.Runtime.CompilerServices; using System.Threading; using UnityEngine; using Cysharp.Threading.Tasks.Internal; #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT) using UnityEngine.Networking; #endif namespace Cysharp.Threading.Tasks { public static partial class UnityAsyncExtensions { <# foreach(var t in types) { #> <# if(IsUnityWebRequest(t)) { #> #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT) <# } else if(IsAssetBundleModule(t)) { #> #if UNITASK_ASSETBUNDLE_SUPPORT <# } #> #region <#= t.typeName #> <# if (IsAsyncOperationBase(t)) { #> #if !UNITY_2023_1_OR_NEWER // from Unity2023.1.0a15, AsyncOperationAwaitableExtensions.GetAwaiter is defined in UnityEngine. <# } #> public static <#= t.typeName #>Awaiter GetAwaiter(this <#= t.typeName #> asyncOperation) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); return new <#= t.typeName #>Awaiter(asyncOperation); } <# if (IsAsyncOperationBase(t)) { #> #endif <# } #> public static <#= ToUniTaskReturnType(t.returnType) #> WithCancellation(this <#= t.typeName #> asyncOperation, CancellationToken cancellationToken) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken); } public static <#= ToUniTaskReturnType(t.returnType) #> WithCancellation(this <#= t.typeName #> asyncOperation, CancellationToken cancellationToken, bool cancelImmediately) { return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately); } public static <#= ToUniTaskReturnType(t.returnType) #> ToUniTask(this <#= t.typeName #> asyncOperation, IProgress progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false) { Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation)); if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<#= IsVoid(t) ? "" : "<" + t.returnType + ">" #>(cancellationToken); <# if(IsUnityWebRequest(t)) { #> if (asyncOperation.isDone) { if (asyncOperation.webRequest.IsError()) { return UniTask.FromException(new UnityWebRequestException(asyncOperation.webRequest)); } return UniTask.FromResult(asyncOperation.webRequest); } <# } else { #> if (asyncOperation.isDone) return <#= IsVoid(t) ? "UniTask.CompletedTask" : $"UniTask.FromResult(asyncOperation.{t.returnField})" #>; <# } #> return new <#= ToUniTaskReturnType(t.returnType) #>(<#= t.typeName #>ConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, cancelImmediately, out var token), token); } public struct <#= t.typeName #>Awaiter : ICriticalNotifyCompletion { <#= t.typeName #> asyncOperation; Action continuationAction; public <#= t.typeName #>Awaiter(<#= t.typeName #> asyncOperation) { this.asyncOperation = asyncOperation; this.continuationAction = null; } public bool IsCompleted => asyncOperation.isDone; public <#= t.returnType #> GetResult() { if (continuationAction != null) { asyncOperation.completed -= continuationAction; continuationAction = null; <# if (!IsVoid(t)) { #> var result = <#= $"asyncOperation.{t.returnField}" #>; asyncOperation = null; <# if(IsUnityWebRequest(t)) { #> if (result.IsError()) { throw new UnityWebRequestException(result); } <# } #> return result; <# } else { #> asyncOperation = null; <# } #> } else { <# if (!IsVoid(t)) { #> var result = <#= $"asyncOperation.{t.returnField}" #>; asyncOperation = null; <# if(IsUnityWebRequest(t)) { #> if (result.IsError()) { throw new UnityWebRequestException(result); } <# } #> return result; <# } else { #> asyncOperation = null; <# } #> } } public void OnCompleted(Action continuation) { UnsafeOnCompleted(continuation); } public void UnsafeOnCompleted(Action continuation) { Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction); continuationAction = PooledDelegate.Create(continuation); asyncOperation.completed += continuationAction; } } sealed class <#= t.typeName #>ConfiguredSource : <#= ToIUniTaskSourceReturnType(t.returnType) #>, IPlayerLoopItem, ITaskPoolNode<<#= t.typeName #>ConfiguredSource> { static TaskPool<<#= t.typeName #>ConfiguredSource> pool; <#= t.typeName #>ConfiguredSource nextNode; public ref <#= t.typeName #>ConfiguredSource NextNode => ref nextNode; static <#= t.typeName #>ConfiguredSource() { TaskPool.RegisterSizeGetter(typeof(<#= t.typeName #>ConfiguredSource), () => pool.Size); } <#= t.typeName #> asyncOperation; IProgress progress; CancellationToken cancellationToken; CancellationTokenRegistration cancellationTokenRegistration; bool cancelImmediately; bool completed; UniTaskCompletionSourceCore<<#= IsVoid(t) ? "AsyncUnit" : t.returnType #>> core; Action continuationAction; <#= t.typeName #>ConfiguredSource() { continuationAction = Continuation; } public static <#= ToIUniTaskSourceReturnType(t.returnType) #> Create(<#= t.typeName #> asyncOperation, PlayerLoopTiming timing, IProgress progress, CancellationToken cancellationToken, bool cancelImmediately, out short token) { if (cancellationToken.IsCancellationRequested) { return AutoResetUniTaskCompletionSource<#= IsVoid(t) ? "" : $"<{t.returnType}>" #>.CreateFromCanceled(cancellationToken, out token); } if (!pool.TryPop(out var result)) { result = new <#= t.typeName #>ConfiguredSource(); } result.asyncOperation = asyncOperation; result.progress = progress; result.cancellationToken = cancellationToken; result.cancelImmediately = cancelImmediately; result.completed = false; asyncOperation.completed += result.continuationAction; if (cancelImmediately && cancellationToken.CanBeCanceled) { result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state => { var source = (<#= t.typeName #>ConfiguredSource)state; <# if(IsUnityWebRequest(t)) { #> source.asyncOperation.webRequest.Abort(); <# } #> source.core.TrySetCanceled(source.cancellationToken); }, result); } TaskTracker.TrackActiveTask(result, 3); PlayerLoopHelper.AddAction(timing, result); token = result.core.Version; return result; } public <#= t.returnType #> GetResult(short token) { try { <# if (!IsVoid(t)) { #> return core.GetResult(token); <# } else { #> core.GetResult(token); <# } #> } finally { if (!(cancelImmediately && cancellationToken.IsCancellationRequested)) { TryReturn(); } } } <# if (!IsVoid(t)) { #> void IUniTaskSource.GetResult(short token) { GetResult(token); } <# } #> public UniTaskStatus GetStatus(short token) { return core.GetStatus(token); } public UniTaskStatus UnsafeGetStatus() { return core.UnsafeGetStatus(); } public void OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } public bool MoveNext() { // Already completed if (completed || asyncOperation == null) { return false; } if (cancellationToken.IsCancellationRequested) { <# if(IsUnityWebRequest(t)) { #> asyncOperation.webRequest.Abort(); <# } #> core.TrySetCanceled(cancellationToken); return false; } if (progress != null) { progress.Report(asyncOperation.progress); } if (asyncOperation.isDone) { <# if(IsUnityWebRequest(t)) { #> if (asyncOperation.webRequest.IsError()) { core.TrySetException(new UnityWebRequestException(asyncOperation.webRequest)); } else { core.TrySetResult(asyncOperation.webRequest); } <# } else { #> core.TrySetResult(<#= IsVoid(t) ? "AsyncUnit.Default" : $"asyncOperation.{t.returnField}" #>); <# } #> return false; } return true; } bool TryReturn() { TaskTracker.RemoveTracking(this); core.Reset(); asyncOperation.completed -= continuationAction; asyncOperation = default; progress = default; cancellationToken = default; cancellationTokenRegistration.Dispose(); cancelImmediately = default; return pool.TryPush(this); } void Continuation(AsyncOperation _) { if (completed) { return; } completed = true; if (cancellationToken.IsCancellationRequested) { core.TrySetCanceled(cancellationToken); } <# if(IsUnityWebRequest(t)) { #> else if (asyncOperation.webRequest.IsError()) { core.TrySetException(new UnityWebRequestException(asyncOperation.webRequest)); } else { core.TrySetResult(asyncOperation.webRequest); } <# } else { #> else { core.TrySetResult(<#= IsVoid(t) ? "AsyncUnit.Default" : $"asyncOperation.{t.returnField}" #>); } <# } #> } } #endregion <# if(IsUnityWebRequest(t) || IsAssetBundleModule(t)) { #> #endif <# } #> <# } #> } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.tt.meta ================================================ fileFormatVersion: 2 guid: b1053c85b3f0794488b10e6de53e9c02 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.uGUI.cs ================================================ #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT using System; using System.Threading; using UnityEngine; using UnityEngine.Events; using UnityEngine.UI; namespace Cysharp.Threading.Tasks { public static partial class UnityAsyncExtensions { public static AsyncUnityEventHandler GetAsyncEventHandler(this UnityEvent unityEvent, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(unityEvent, cancellationToken, false); } public static UniTask OnInvokeAsync(this UnityEvent unityEvent, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(unityEvent, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnInvokeAsAsyncEnumerable(this UnityEvent unityEvent, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(unityEvent, cancellationToken); } public static AsyncUnityEventHandler GetAsyncEventHandler(this UnityEvent unityEvent, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(unityEvent, cancellationToken, false); } public static UniTask OnInvokeAsync(this UnityEvent unityEvent, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(unityEvent, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnInvokeAsAsyncEnumerable(this UnityEvent unityEvent, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(unityEvent, cancellationToken); } public static IAsyncClickEventHandler GetAsyncClickEventHandler(this Button button) { return new AsyncUnityEventHandler(button.onClick, button.GetCancellationTokenOnDestroy(), false); } public static IAsyncClickEventHandler GetAsyncClickEventHandler(this Button button, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(button.onClick, cancellationToken, false); } public static UniTask OnClickAsync(this Button button) { return new AsyncUnityEventHandler(button.onClick, button.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnClickAsync(this Button button, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(button.onClick, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnClickAsAsyncEnumerable(this Button button) { return new UnityEventHandlerAsyncEnumerable(button.onClick, button.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnClickAsAsyncEnumerable(this Button button, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(button.onClick, cancellationToken); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this Toggle toggle) { return new AsyncUnityEventHandler(toggle.onValueChanged, toggle.GetCancellationTokenOnDestroy(), false); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this Toggle toggle, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(toggle.onValueChanged, cancellationToken, false); } public static UniTask OnValueChangedAsync(this Toggle toggle) { return new AsyncUnityEventHandler(toggle.onValueChanged, toggle.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnValueChangedAsync(this Toggle toggle, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(toggle.onValueChanged, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this Toggle toggle) { return new UnityEventHandlerAsyncEnumerable(toggle.onValueChanged, toggle.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this Toggle toggle, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(toggle.onValueChanged, cancellationToken); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this Scrollbar scrollbar) { return new AsyncUnityEventHandler(scrollbar.onValueChanged, scrollbar.GetCancellationTokenOnDestroy(), false); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this Scrollbar scrollbar, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(scrollbar.onValueChanged, cancellationToken, false); } public static UniTask OnValueChangedAsync(this Scrollbar scrollbar) { return new AsyncUnityEventHandler(scrollbar.onValueChanged, scrollbar.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnValueChangedAsync(this Scrollbar scrollbar, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(scrollbar.onValueChanged, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this Scrollbar scrollbar) { return new UnityEventHandlerAsyncEnumerable(scrollbar.onValueChanged, scrollbar.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this Scrollbar scrollbar, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(scrollbar.onValueChanged, cancellationToken); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this ScrollRect scrollRect) { return new AsyncUnityEventHandler(scrollRect.onValueChanged, scrollRect.GetCancellationTokenOnDestroy(), false); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this ScrollRect scrollRect, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(scrollRect.onValueChanged, cancellationToken, false); } public static UniTask OnValueChangedAsync(this ScrollRect scrollRect) { return new AsyncUnityEventHandler(scrollRect.onValueChanged, scrollRect.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnValueChangedAsync(this ScrollRect scrollRect, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(scrollRect.onValueChanged, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this ScrollRect scrollRect) { return new UnityEventHandlerAsyncEnumerable(scrollRect.onValueChanged, scrollRect.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this ScrollRect scrollRect, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(scrollRect.onValueChanged, cancellationToken); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this Slider slider) { return new AsyncUnityEventHandler(slider.onValueChanged, slider.GetCancellationTokenOnDestroy(), false); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this Slider slider, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(slider.onValueChanged, cancellationToken, false); } public static UniTask OnValueChangedAsync(this Slider slider) { return new AsyncUnityEventHandler(slider.onValueChanged, slider.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnValueChangedAsync(this Slider slider, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(slider.onValueChanged, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this Slider slider) { return new UnityEventHandlerAsyncEnumerable(slider.onValueChanged, slider.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this Slider slider, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(slider.onValueChanged, cancellationToken); } public static IAsyncEndEditEventHandler GetAsyncEndEditEventHandler(this InputField inputField) { return new AsyncUnityEventHandler(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncEndEditEventHandler GetAsyncEndEditEventHandler(this InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onEndEdit, cancellationToken, false); } public static UniTask OnEndEditAsync(this InputField inputField) { return new AsyncUnityEventHandler(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnEndEditAsync(this InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onEndEdit, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnEndEditAsAsyncEnumerable(this InputField inputField) { return new UnityEventHandlerAsyncEnumerable(inputField.onEndEdit, inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnEndEditAsAsyncEnumerable(this InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(inputField.onEndEdit, cancellationToken); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this InputField inputField) { return new AsyncUnityEventHandler(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy(), false); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onValueChanged, cancellationToken, false); } public static UniTask OnValueChangedAsync(this InputField inputField) { return new AsyncUnityEventHandler(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnValueChangedAsync(this InputField inputField, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(inputField.onValueChanged, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this InputField inputField) { return new UnityEventHandlerAsyncEnumerable(inputField.onValueChanged, inputField.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this InputField inputField, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(inputField.onValueChanged, cancellationToken); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this Dropdown dropdown) { return new AsyncUnityEventHandler(dropdown.onValueChanged, dropdown.GetCancellationTokenOnDestroy(), false); } public static IAsyncValueChangedEventHandler GetAsyncValueChangedEventHandler(this Dropdown dropdown, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(dropdown.onValueChanged, cancellationToken, false); } public static UniTask OnValueChangedAsync(this Dropdown dropdown) { return new AsyncUnityEventHandler(dropdown.onValueChanged, dropdown.GetCancellationTokenOnDestroy(), true).OnInvokeAsync(); } public static UniTask OnValueChangedAsync(this Dropdown dropdown, CancellationToken cancellationToken) { return new AsyncUnityEventHandler(dropdown.onValueChanged, cancellationToken, true).OnInvokeAsync(); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this Dropdown dropdown) { return new UnityEventHandlerAsyncEnumerable(dropdown.onValueChanged, dropdown.GetCancellationTokenOnDestroy()); } public static IUniTaskAsyncEnumerable OnValueChangedAsAsyncEnumerable(this Dropdown dropdown, CancellationToken cancellationToken) { return new UnityEventHandlerAsyncEnumerable(dropdown.onValueChanged, cancellationToken); } } public interface IAsyncClickEventHandler : IDisposable { UniTask OnClickAsync(); } public interface IAsyncValueChangedEventHandler : IDisposable { UniTask OnValueChangedAsync(); } public interface IAsyncEndEditEventHandler : IDisposable { UniTask OnEndEditAsync(); } // for TMP_PRO public interface IAsyncEndTextSelectionEventHandler : IDisposable { UniTask OnEndTextSelectionAsync(); } public interface IAsyncTextSelectionEventHandler : IDisposable { UniTask OnTextSelectionAsync(); } public interface IAsyncDeselectEventHandler : IDisposable { UniTask OnDeselectAsync(); } public interface IAsyncSelectEventHandler : IDisposable { UniTask OnSelectAsync(); } public interface IAsyncSubmitEventHandler : IDisposable { UniTask OnSubmitAsync(); } internal class TextSelectionEventConverter : UnityEvent<(string, int, int)>, IDisposable { readonly UnityEvent innerEvent; readonly UnityAction invokeDelegate; public TextSelectionEventConverter(UnityEvent unityEvent) { this.innerEvent = unityEvent; this.invokeDelegate = InvokeCore; innerEvent.AddListener(invokeDelegate); } void InvokeCore(string item1, int item2, int item3) { Invoke((item1, item2, item3)); } public void Dispose() { innerEvent.RemoveListener(invokeDelegate); } } public class AsyncUnityEventHandler : IUniTaskSource, IDisposable, IAsyncClickEventHandler { static Action cancellationCallback = CancellationCallback; readonly UnityAction action; readonly UnityEvent unityEvent; CancellationToken cancellationToken; CancellationTokenRegistration registration; bool isDisposed; bool callOnce; UniTaskCompletionSourceCore core; public AsyncUnityEventHandler(UnityEvent unityEvent, CancellationToken cancellationToken, bool callOnce) { this.cancellationToken = cancellationToken; if (cancellationToken.IsCancellationRequested) { isDisposed = true; return; } this.action = Invoke; this.unityEvent = unityEvent; this.callOnce = callOnce; unityEvent.AddListener(action); if (cancellationToken.CanBeCanceled) { registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this); } TaskTracker.TrackActiveTask(this, 3); } public UniTask OnInvokeAsync() { core.Reset(); if (isDisposed) { core.TrySetCanceled(this.cancellationToken); } return new UniTask(this, core.Version); } void Invoke() { core.TrySetResult(AsyncUnit.Default); } static void CancellationCallback(object state) { var self = (AsyncUnityEventHandler)state; self.Dispose(); } public void Dispose() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); registration.Dispose(); if (unityEvent != null) { unityEvent.RemoveListener(action); } core.TrySetCanceled(cancellationToken); } } UniTask IAsyncClickEventHandler.OnClickAsync() { return OnInvokeAsync(); } void IUniTaskSource.GetResult(short token) { try { core.GetResult(token); } finally { if (callOnce) { Dispose(); } } } UniTaskStatus IUniTaskSource.GetStatus(short token) { return core.GetStatus(token); } UniTaskStatus IUniTaskSource.UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public class AsyncUnityEventHandler : IUniTaskSource, IDisposable, IAsyncValueChangedEventHandler, IAsyncEndEditEventHandler , IAsyncEndTextSelectionEventHandler, IAsyncTextSelectionEventHandler, IAsyncDeselectEventHandler, IAsyncSelectEventHandler, IAsyncSubmitEventHandler { static Action cancellationCallback = CancellationCallback; readonly UnityAction action; readonly UnityEvent unityEvent; CancellationToken cancellationToken; CancellationTokenRegistration registration; bool isDisposed; bool callOnce; UniTaskCompletionSourceCore core; public AsyncUnityEventHandler(UnityEvent unityEvent, CancellationToken cancellationToken, bool callOnce) { this.cancellationToken = cancellationToken; if (cancellationToken.IsCancellationRequested) { isDisposed = true; return; } this.action = Invoke; this.unityEvent = unityEvent; this.callOnce = callOnce; unityEvent.AddListener(action); if (cancellationToken.CanBeCanceled) { registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this); } TaskTracker.TrackActiveTask(this, 3); } public UniTask OnInvokeAsync() { core.Reset(); if (isDisposed) { core.TrySetCanceled(this.cancellationToken); } return new UniTask(this, core.Version); } void Invoke(T result) { core.TrySetResult(result); } static void CancellationCallback(object state) { var self = (AsyncUnityEventHandler)state; self.Dispose(); } public void Dispose() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); registration.Dispose(); if (unityEvent != null) { // Dispose inner delegate for TextSelectionEventConverter if (unityEvent is IDisposable disp) { disp.Dispose(); } unityEvent.RemoveListener(action); } core.TrySetCanceled(); } } UniTask IAsyncValueChangedEventHandler.OnValueChangedAsync() { return OnInvokeAsync(); } UniTask IAsyncEndEditEventHandler.OnEndEditAsync() { return OnInvokeAsync(); } UniTask IAsyncEndTextSelectionEventHandler.OnEndTextSelectionAsync() { return OnInvokeAsync(); } UniTask IAsyncTextSelectionEventHandler.OnTextSelectionAsync() { return OnInvokeAsync(); } UniTask IAsyncDeselectEventHandler.OnDeselectAsync() { return OnInvokeAsync(); } UniTask IAsyncSelectEventHandler.OnSelectAsync() { return OnInvokeAsync(); } UniTask IAsyncSubmitEventHandler.OnSubmitAsync() { return OnInvokeAsync(); } T IUniTaskSource.GetResult(short token) { try { return core.GetResult(token); } finally { if (callOnce) { Dispose(); } } } void IUniTaskSource.GetResult(short token) { ((IUniTaskSource)this).GetResult(token); } UniTaskStatus IUniTaskSource.GetStatus(short token) { return core.GetStatus(token); } UniTaskStatus IUniTaskSource.UnsafeGetStatus() { return core.UnsafeGetStatus(); } void IUniTaskSource.OnCompleted(Action continuation, object state, short token) { core.OnCompleted(continuation, state, token); } } public class UnityEventHandlerAsyncEnumerable : IUniTaskAsyncEnumerable { readonly UnityEvent unityEvent; readonly CancellationToken cancellationToken1; public UnityEventHandlerAsyncEnumerable(UnityEvent unityEvent, CancellationToken cancellationToken) { this.unityEvent = unityEvent; this.cancellationToken1 = cancellationToken; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { if (this.cancellationToken1 == cancellationToken) { return new UnityEventHandlerAsyncEnumerator(unityEvent, this.cancellationToken1, CancellationToken.None); } else { return new UnityEventHandlerAsyncEnumerator(unityEvent, this.cancellationToken1, cancellationToken); } } class UnityEventHandlerAsyncEnumerator : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action cancel1 = OnCanceled1; static readonly Action cancel2 = OnCanceled2; readonly UnityEvent unityEvent; CancellationToken cancellationToken1; CancellationToken cancellationToken2; UnityAction unityAction; CancellationTokenRegistration registration1; CancellationTokenRegistration registration2; bool isDisposed; public UnityEventHandlerAsyncEnumerator(UnityEvent unityEvent, CancellationToken cancellationToken1, CancellationToken cancellationToken2) { this.unityEvent = unityEvent; this.cancellationToken1 = cancellationToken1; this.cancellationToken2 = cancellationToken2; } public AsyncUnit Current => default; public UniTask MoveNextAsync() { cancellationToken1.ThrowIfCancellationRequested(); cancellationToken2.ThrowIfCancellationRequested(); completionSource.Reset(); if (unityAction == null) { unityAction = Invoke; TaskTracker.TrackActiveTask(this, 3); unityEvent.AddListener(unityAction); if (cancellationToken1.CanBeCanceled) { registration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(cancel1, this); } if (cancellationToken2.CanBeCanceled) { registration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(cancel2, this); } } return new UniTask(this, completionSource.Version); } void Invoke() { completionSource.TrySetResult(true); } static void OnCanceled1(object state) { var self = (UnityEventHandlerAsyncEnumerator)state; try { self.completionSource.TrySetCanceled(self.cancellationToken1); } finally { self.DisposeAsync().Forget(); } } static void OnCanceled2(object state) { var self = (UnityEventHandlerAsyncEnumerator)state; try { self.completionSource.TrySetCanceled(self.cancellationToken2); } finally { self.DisposeAsync().Forget(); } } public UniTask DisposeAsync() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); registration1.Dispose(); registration2.Dispose(); unityEvent.RemoveListener(unityAction); completionSource.TrySetCanceled(); } return default; } } } public class UnityEventHandlerAsyncEnumerable : IUniTaskAsyncEnumerable { readonly UnityEvent unityEvent; readonly CancellationToken cancellationToken1; public UnityEventHandlerAsyncEnumerable(UnityEvent unityEvent, CancellationToken cancellationToken) { this.unityEvent = unityEvent; this.cancellationToken1 = cancellationToken; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { if (this.cancellationToken1 == cancellationToken) { return new UnityEventHandlerAsyncEnumerator(unityEvent, this.cancellationToken1, CancellationToken.None); } else { return new UnityEventHandlerAsyncEnumerator(unityEvent, this.cancellationToken1, cancellationToken); } } class UnityEventHandlerAsyncEnumerator : MoveNextSource, IUniTaskAsyncEnumerator { static readonly Action cancel1 = OnCanceled1; static readonly Action cancel2 = OnCanceled2; readonly UnityEvent unityEvent; CancellationToken cancellationToken1; CancellationToken cancellationToken2; UnityAction unityAction; CancellationTokenRegistration registration1; CancellationTokenRegistration registration2; bool isDisposed; public UnityEventHandlerAsyncEnumerator(UnityEvent unityEvent, CancellationToken cancellationToken1, CancellationToken cancellationToken2) { this.unityEvent = unityEvent; this.cancellationToken1 = cancellationToken1; this.cancellationToken2 = cancellationToken2; } public T Current { get; private set; } public UniTask MoveNextAsync() { cancellationToken1.ThrowIfCancellationRequested(); cancellationToken2.ThrowIfCancellationRequested(); completionSource.Reset(); if (unityAction == null) { unityAction = Invoke; TaskTracker.TrackActiveTask(this, 3); unityEvent.AddListener(unityAction); if (cancellationToken1.CanBeCanceled) { registration1 = cancellationToken1.RegisterWithoutCaptureExecutionContext(cancel1, this); } if (cancellationToken2.CanBeCanceled) { registration2 = cancellationToken2.RegisterWithoutCaptureExecutionContext(cancel2, this); } } return new UniTask(this, completionSource.Version); } void Invoke(T value) { Current = value; completionSource.TrySetResult(true); } static void OnCanceled1(object state) { var self = (UnityEventHandlerAsyncEnumerator)state; try { self.completionSource.TrySetCanceled(self.cancellationToken1); } finally { self.DisposeAsync().Forget(); } } static void OnCanceled2(object state) { var self = (UnityEventHandlerAsyncEnumerator)state; try { self.completionSource.TrySetCanceled(self.cancellationToken2); } finally { self.DisposeAsync().Forget(); } } public UniTask DisposeAsync() { if (!isDisposed) { isDisposed = true; TaskTracker.RemoveTracking(this); registration1.Dispose(); registration2.Dispose(); if (unityEvent is IDisposable disp) { disp.Dispose(); } unityEvent.RemoveListener(unityAction); completionSource.TrySetCanceled(); } return default; } } } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.uGUI.cs.meta ================================================ fileFormatVersion: 2 guid: 6804799fba2376d4099561d176101aff MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAwaitableExtensions.cs ================================================ #if UNITY_2023_1_OR_NEWER namespace Cysharp.Threading.Tasks { public static class UnityAwaitableExtensions { public static async UniTask AsUniTask(this UnityEngine.Awaitable awaitable) { await awaitable; } public static async UniTask AsUniTask(this UnityEngine.Awaitable awaitable) { return await awaitable; } } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAwaitableExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: c29533c9e4284dee914b71a6579ea274 timeCreated: 1698895807 ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityBindingExtensions.cs ================================================ using System; using System.Threading; using UnityEngine; #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT using UnityEngine.UI; #endif namespace Cysharp.Threading.Tasks { public static class UnityBindingExtensions { #if !UNITY_2019_1_OR_NEWER || UNITASK_UGUI_SUPPORT // -> Text public static void BindTo(this IUniTaskAsyncEnumerable source, UnityEngine.UI.Text text, bool rebindOnError = true) { BindToCore(source, text, text.GetCancellationTokenOnDestroy(), rebindOnError).Forget(); } public static void BindTo(this IUniTaskAsyncEnumerable source, UnityEngine.UI.Text text, CancellationToken cancellationToken, bool rebindOnError = true) { BindToCore(source, text, cancellationToken, rebindOnError).Forget(); } static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable source, UnityEngine.UI.Text text, CancellationToken cancellationToken, bool rebindOnError) { var repeat = false; BIND_AGAIN: var e = source.GetAsyncEnumerator(cancellationToken); try { while (true) { bool moveNext; try { moveNext = await e.MoveNextAsync(); repeat = false; } catch (Exception ex) { if (ex is OperationCanceledException) return; if (rebindOnError && !repeat) { repeat = true; goto BIND_AGAIN; } else { throw; } } if (!moveNext) return; text.text = e.Current; } } finally { if (e != null) { await e.DisposeAsync(); } } } // -> Text public static void BindTo(this IUniTaskAsyncEnumerable source, UnityEngine.UI.Text text, bool rebindOnError = true) { BindToCore(source, text, text.GetCancellationTokenOnDestroy(), rebindOnError).Forget(); } public static void BindTo(this IUniTaskAsyncEnumerable source, UnityEngine.UI.Text text, CancellationToken cancellationToken, bool rebindOnError = true) { BindToCore(source, text, cancellationToken, rebindOnError).Forget(); } public static void BindTo(this AsyncReactiveProperty source, UnityEngine.UI.Text text, bool rebindOnError = true) { BindToCore(source, text, text.GetCancellationTokenOnDestroy(), rebindOnError).Forget(); } static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable source, UnityEngine.UI.Text text, CancellationToken cancellationToken, bool rebindOnError) { var repeat = false; BIND_AGAIN: var e = source.GetAsyncEnumerator(cancellationToken); try { while (true) { bool moveNext; try { moveNext = await e.MoveNextAsync(); repeat = false; } catch (Exception ex) { if (ex is OperationCanceledException) return; if (rebindOnError && !repeat) { repeat = true; goto BIND_AGAIN; } else { throw; } } if (!moveNext) return; text.text = e.Current.ToString(); } } finally { if (e != null) { await e.DisposeAsync(); } } } // -> Selectable public static void BindTo(this IUniTaskAsyncEnumerable source, Selectable selectable, bool rebindOnError = true) { BindToCore(source, selectable, selectable.GetCancellationTokenOnDestroy(), rebindOnError).Forget(); } public static void BindTo(this IUniTaskAsyncEnumerable source, Selectable selectable, CancellationToken cancellationToken, bool rebindOnError = true) { BindToCore(source, selectable, cancellationToken, rebindOnError).Forget(); } static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable source, Selectable selectable, CancellationToken cancellationToken, bool rebindOnError) { var repeat = false; BIND_AGAIN: var e = source.GetAsyncEnumerator(cancellationToken); try { while (true) { bool moveNext; try { moveNext = await e.MoveNextAsync(); repeat = false; } catch (Exception ex) { if (ex is OperationCanceledException) return; if (rebindOnError && !repeat) { repeat = true; goto BIND_AGAIN; } else { throw; } } if (!moveNext) return; selectable.interactable = e.Current; } } finally { if (e != null) { await e.DisposeAsync(); } } } #endif // -> Action public static void BindTo(this IUniTaskAsyncEnumerable source, TObject monoBehaviour, Action bindAction, bool rebindOnError = true) where TObject : MonoBehaviour { BindToCore(source, monoBehaviour, bindAction, monoBehaviour.GetCancellationTokenOnDestroy(), rebindOnError).Forget(); } public static void BindTo(this IUniTaskAsyncEnumerable source, TObject bindTarget, Action bindAction, CancellationToken cancellationToken, bool rebindOnError = true) { BindToCore(source, bindTarget, bindAction, cancellationToken, rebindOnError).Forget(); } static async UniTaskVoid BindToCore(IUniTaskAsyncEnumerable source, TObject bindTarget, Action bindAction, CancellationToken cancellationToken, bool rebindOnError) { var repeat = false; BIND_AGAIN: var e = source.GetAsyncEnumerator(cancellationToken); try { while (true) { bool moveNext; try { moveNext = await e.MoveNextAsync(); repeat = false; } catch (Exception ex) { if (ex is OperationCanceledException) return; if (rebindOnError && !repeat) { repeat = true; goto BIND_AGAIN; } else { throw; } } if (!moveNext) return; bindAction(bindTarget, e.Current); } } finally { if (e != null) { await e.DisposeAsync(); } } } } } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityBindingExtensions.cs.meta ================================================ fileFormatVersion: 2 guid: 090b20e3528552b4a8d751f7df525c2b MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityWebRequestException.cs ================================================ #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT) using System; using System.Collections.Generic; using UnityEngine.Networking; namespace Cysharp.Threading.Tasks { public class UnityWebRequestException : Exception { public UnityWebRequest UnityWebRequest { get; } #if UNITY_2020_2_OR_NEWER public UnityWebRequest.Result Result { get; } #else public bool IsNetworkError { get; } public bool IsHttpError { get; } #endif public string Error { get; } public string Text { get; } public long ResponseCode { get; } public Dictionary ResponseHeaders { get; } string msg; public UnityWebRequestException(UnityWebRequest unityWebRequest) { this.UnityWebRequest = unityWebRequest; #if UNITY_2020_2_OR_NEWER this.Result = unityWebRequest.result; #else this.IsNetworkError = unityWebRequest.isNetworkError; this.IsHttpError = unityWebRequest.isHttpError; #endif this.Error = unityWebRequest.error; this.ResponseCode = unityWebRequest.responseCode; if (UnityWebRequest.downloadHandler != null) { if (unityWebRequest.downloadHandler is DownloadHandlerBuffer dhb) { this.Text = dhb.text; } } this.ResponseHeaders = unityWebRequest.GetResponseHeaders(); } public override string Message { get { if (msg == null) { if(!string.IsNullOrWhiteSpace(Text)) { msg = Error + Environment.NewLine + Text; } else { msg = Error; } } return msg; } } } } #endif ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/UnityWebRequestException.cs.meta ================================================ fileFormatVersion: 2 guid: 013a499e522703a42962a779b4d9850c MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/_InternalVisibleTo.cs ================================================ using System.Runtime.CompilerServices; [assembly: InternalsVisibleTo("UniTask.Linq")] [assembly: InternalsVisibleTo("UniTask.Addressables")] [assembly: InternalsVisibleTo("UniTask.DOTween")] [assembly: InternalsVisibleTo("UniTask.TextMeshPro")] ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime/_InternalVisibleTo.cs.meta ================================================ fileFormatVersion: 2 guid: 8507e97eb606fad4b99c6edf92e19cb8 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/Runtime.meta ================================================ fileFormatVersion: 2 guid: aa765154468d4b34eb34304100d39e64 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/package.json ================================================ { "name": "com.cysharp.unitask", "displayName": "UniTask", "author": { "name": "Cysharp, Inc.", "url": "https://cysharp.co.jp/en/" }, "version": "2.5.10", "unity": "2018.4", "description": "Provides an efficient async/await integration to Unity.", "keywords": [ "async/await", "async", "Task", "UniTask" ], "license": "MIT", "category": "Task", "dependencies": {} } ================================================ FILE: src/UniTask/Assets/Plugins/UniTask/package.json.meta ================================================ fileFormatVersion: 2 guid: d1a9a71f68bb0d04db91ddaa3329abf9 TextScriptImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins/UniTask.meta ================================================ fileFormatVersion: 2 guid: 4929ac1f6fcfe944a99529b6fb5bd9ef folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Plugins.meta ================================================ fileFormatVersion: 2 guid: b42c9a22c4f7bc7448ed60496a4dc359 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Scenes/EditorTest1.cs ================================================ #if UNITY_EDITOR using System; using Cysharp.Threading.Tasks; using UnityEditor; using UnityEngine; public class Test1 { [MenuItem("Test/Test1")] public static async UniTaskVoid TestFunc() { await DoSomeThing(); //string[] scenes = new string[] //{ // "Assets/Scenes/SandboxMain.unity", //}; //try //{ // Debug.Log("Build Begin"); // BuildPipeline.BuildPlayer(scenes, Application.dataPath + "../target", BuildTarget.StandaloneWindows, BuildOptions.CompressWithLz4); // Debug.Log("Build After"); //} //catch (Exception e) //{ // Debug.LogError(e.Message); //} } public static async UniTask DoSomeThing() { Debug.Log("Dosomething"); await UniTask.Delay(1500, DelayType.DeltaTime); Debug.Log("Dosomething 2"); await UniTask.Delay(1000, DelayType.DeltaTime); Debug.Log("Dosomething 3"); Debug.Log("and Quit."); Environment.Exit(0); } } #endif ================================================ FILE: src/UniTask/Assets/Scenes/EditorTest1.cs.meta ================================================ fileFormatVersion: 2 guid: 48003021292963e48b2493e915dca5ac MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Scenes/ExceptionExamples.cs ================================================ using Cysharp.Threading.Tasks; using System; using System.Collections.Generic; using UnityEngine; // using UnityEngine.AddressableAssets; /*UNniTastWhenAnyTester*/ [ExecuteInEditMode] public class ExceptionExamples : MonoBehaviour { public bool apply = false; private async UniTaskVoid Update() { if (apply) { apply = false; await LaunchTasksAndDetectWhenAnyDone(5); } } private async UniTask LaunchTasksAndDetectWhenAnyDone(int nbTasks) { List> sleeptasks = new List>(); for (int i = 0; i < nbTasks; i++) { sleeptasks.Add(SleepAndReturnTrue(i).ToAsyncLazy().Task); } while (sleeptasks.Count > 0) { Debug.Log(DateTime.Now.ToString() + " waiting for " + sleeptasks.Count + " tasks..."); try { (int index, int taskID) = await UniTask.WhenAny(sleeptasks); Debug.Log(DateTime.Now.ToString() + " Sleep task " + taskID + " done"); sleeptasks.RemoveAt(index); } catch { throw; //Debug.Log("Error: " + e.Message); //return; } } } private async UniTask SleepAndReturnTrue(int taskIndex) { await UniTask.Delay(100); return taskIndex; } //void AddressablesTest() //{ // Addressables.ClearDependencyCacheAsync("key", true); //} } ================================================ FILE: src/UniTask/Assets/Scenes/ExceptionExamples.cs.meta ================================================ fileFormatVersion: 2 guid: 329ff620b32b4ef4abdc99884242ee67 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Scenes/ExceptionExamples.unity ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!29 &1 OcclusionCullingSettings: m_ObjectHideFlags: 0 serializedVersion: 2 m_OcclusionBakeSettings: smallestOccluder: 5 smallestHole: 0.25 backfaceThreshold: 100 m_SceneGUID: 00000000000000000000000000000000 m_OcclusionCullingData: {fileID: 0} --- !u!104 &2 RenderSettings: m_ObjectHideFlags: 0 serializedVersion: 9 m_Fog: 0 m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1} m_FogMode: 3 m_FogDensity: 0.01 m_LinearFogStart: 0 m_LinearFogEnd: 300 m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1} m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1} m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1} m_AmbientIntensity: 1 m_AmbientMode: 3 m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1} m_SkyboxMaterial: {fileID: 0} m_HaloStrength: 0.5 m_FlareStrength: 1 m_FlareFadeSpeed: 3 m_HaloTexture: {fileID: 0} m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0} m_DefaultReflectionMode: 0 m_DefaultReflectionResolution: 128 m_ReflectionBounces: 1 m_ReflectionIntensity: 1 m_CustomReflection: {fileID: 0} m_Sun: {fileID: 0} m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1} m_UseRadianceAmbientProbe: 0 --- !u!157 &3 LightmapSettings: m_ObjectHideFlags: 0 serializedVersion: 11 m_GIWorkflowMode: 1 m_GISettings: serializedVersion: 2 m_BounceScale: 1 m_IndirectOutputScale: 1 m_AlbedoBoost: 1 m_EnvironmentLightingMode: 0 m_EnableBakedLightmaps: 0 m_EnableRealtimeLightmaps: 0 m_LightmapEditorSettings: serializedVersion: 12 m_Resolution: 2 m_BakeResolution: 40 m_AtlasSize: 1024 m_AO: 0 m_AOMaxDistance: 1 m_CompAOExponent: 1 m_CompAOExponentDirect: 0 m_ExtractAmbientOcclusion: 0 m_Padding: 2 m_LightmapParameters: {fileID: 0} m_LightmapsBakeMode: 1 m_TextureCompression: 1 m_FinalGather: 0 m_FinalGatherFiltering: 1 m_FinalGatherRayCount: 256 m_ReflectionCompression: 2 m_MixedBakeMode: 2 m_BakeBackend: 1 m_PVRSampling: 1 m_PVRDirectSampleCount: 32 m_PVRSampleCount: 512 m_PVRBounces: 2 m_PVREnvironmentSampleCount: 256 m_PVREnvironmentReferencePointCount: 2048 m_PVRFilteringMode: 1 m_PVRDenoiserTypeDirect: 1 m_PVRDenoiserTypeIndirect: 1 m_PVRDenoiserTypeAO: 1 m_PVRFilterTypeDirect: 0 m_PVRFilterTypeIndirect: 0 m_PVRFilterTypeAO: 0 m_PVREnvironmentMIS: 1 m_PVRCulling: 1 m_PVRFilteringGaussRadiusDirect: 1 m_PVRFilteringGaussRadiusIndirect: 5 m_PVRFilteringGaussRadiusAO: 2 m_PVRFilteringAtrousPositionSigmaDirect: 0.5 m_PVRFilteringAtrousPositionSigmaIndirect: 2 m_PVRFilteringAtrousPositionSigmaAO: 1 m_ExportTrainingData: 0 m_TrainingDataDestination: TrainingData m_LightProbeSampleCountMultiplier: 4 m_LightingDataAsset: {fileID: 0} m_UseShadowmask: 1 --- !u!196 &4 NavMeshSettings: serializedVersion: 2 m_ObjectHideFlags: 0 m_BuildSettings: serializedVersion: 2 agentTypeID: 0 agentRadius: 0.5 agentHeight: 2 agentSlope: 45 agentClimb: 0.4 ledgeDropHeight: 0 maxJumpAcrossDistance: 0 minRegionArea: 2 manualCellSize: 0 cellSize: 0.16666667 manualTileSize: 0 tileSize: 256 accuratePlacement: 0 debug: m_Flags: 0 m_NavMeshData: {fileID: 0} --- !u!1 &542336983 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 542336986} - component: {fileID: 542336985} - component: {fileID: 542336984} m_Layer: 0 m_Name: EventSystem m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!114 &542336984 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 542336983} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 4f231c4fb786f3946a6b90b886c48677, type: 3} m_Name: m_EditorClassIdentifier: m_HorizontalAxis: Horizontal m_VerticalAxis: Vertical m_SubmitButton: Submit m_CancelButton: Cancel m_InputActionsPerSecond: 10 m_RepeatDelay: 0.5 m_ForceModuleActive: 0 --- !u!114 &542336985 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 542336983} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3} m_Name: m_EditorClassIdentifier: m_FirstSelected: {fileID: 0} m_sendNavigationEvents: 1 m_DragThreshold: 10 --- !u!4 &542336986 Transform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 542336983} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_Children: [] m_Father: {fileID: 0} m_RootOrder: 1 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} --- !u!1 &730559310 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 730559311} - component: {fileID: 730559313} - component: {fileID: 730559312} m_Layer: 5 m_Name: Text m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!224 &730559311 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 730559310} m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_Children: [] m_Father: {fileID: 1587363385} m_RootOrder: 0 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 1, y: 1} m_AnchoredPosition: {x: 0, y: 0} m_SizeDelta: {x: 0, y: 0} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &730559312 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 730559310} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3} m_Name: m_EditorClassIdentifier: m_Material: {fileID: 0} m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} m_RaycastTarget: 1 m_OnCullStateChanged: m_PersistentCalls: m_Calls: [] m_FontData: m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0} m_FontSize: 14 m_FontStyle: 0 m_BestFit: 0 m_MinSize: 10 m_MaxSize: 40 m_Alignment: 4 m_AlignByGeometry: 0 m_RichText: 1 m_HorizontalOverflow: 0 m_VerticalOverflow: 0 m_LineSpacing: 1 m_Text: Button --- !u!222 &730559313 CanvasRenderer: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 730559310} m_CullTransparentMesh: 0 --- !u!1 &735985614 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 735985618} - component: {fileID: 735985617} - component: {fileID: 735985616} - component: {fileID: 735985615} m_Layer: 0 m_Name: Main Camera m_TagString: MainCamera m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!114 &735985615 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 735985614} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 329ff620b32b4ef4abdc99884242ee67, type: 3} m_Name: m_EditorClassIdentifier: ButtonTest: {fileID: 1587363386} --- !u!81 &735985616 AudioListener: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 735985614} m_Enabled: 1 --- !u!20 &735985617 Camera: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 735985614} m_Enabled: 1 serializedVersion: 2 m_ClearFlags: 1 m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0} m_projectionMatrixMode: 1 m_GateFitMode: 2 m_FOVAxisMode: 0 m_SensorSize: {x: 36, y: 24} m_LensShift: {x: 0, y: 0} m_FocalLength: 50 m_NormalizedViewPortRect: serializedVersion: 2 x: 0 y: 0 width: 1 height: 1 near clip plane: 0.3 far clip plane: 1000 field of view: 60 orthographic: 1 orthographic size: 5 m_Depth: -1 m_CullingMask: serializedVersion: 2 m_Bits: 4294967295 m_RenderingPath: -1 m_TargetTexture: {fileID: 0} m_TargetDisplay: 0 m_TargetEye: 3 m_HDR: 1 m_AllowMSAA: 1 m_AllowDynamicResolution: 0 m_ForceIntoRT: 0 m_OcclusionCulling: 1 m_StereoConvergence: 10 m_StereoSeparation: 0.022 --- !u!4 &735985618 Transform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 735985614} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: -10} m_LocalScale: {x: 1, y: 1, z: 1} m_Children: - {fileID: 1323586517} m_Father: {fileID: 0} m_RootOrder: 0 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} --- !u!1 &1323586516 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 1323586517} - component: {fileID: 1323586520} - component: {fileID: 1323586519} - component: {fileID: 1323586518} m_Layer: 5 m_Name: Canvas m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!224 &1323586517 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1323586516} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 0, y: 0, z: 0} m_Children: - {fileID: 1587363385} m_Father: {fileID: 735985618} m_RootOrder: 0 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 0, y: 0} m_AnchoredPosition: {x: 0, y: 0} m_SizeDelta: {x: 0, y: 0} m_Pivot: {x: 0, y: 0} --- !u!114 &1323586518 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1323586516} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3} m_Name: m_EditorClassIdentifier: m_IgnoreReversedGraphics: 1 m_BlockingObjects: 0 m_BlockingMask: serializedVersion: 2 m_Bits: 4294967295 --- !u!114 &1323586519 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1323586516} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3} m_Name: m_EditorClassIdentifier: m_UiScaleMode: 0 m_ReferencePixelsPerUnit: 100 m_ScaleFactor: 1 m_ReferenceResolution: {x: 800, y: 600} m_ScreenMatchMode: 0 m_MatchWidthOrHeight: 0 m_PhysicalUnit: 3 m_FallbackScreenDPI: 96 m_DefaultSpriteDPI: 96 m_DynamicPixelsPerUnit: 1 --- !u!223 &1323586520 Canvas: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1323586516} m_Enabled: 1 serializedVersion: 3 m_RenderMode: 0 m_Camera: {fileID: 0} m_PlaneDistance: 100 m_PixelPerfect: 0 m_ReceivesEvents: 1 m_OverrideSorting: 0 m_OverridePixelPerfect: 0 m_SortingBucketNormalizedSize: 0 m_AdditionalShaderChannelsFlag: 0 m_SortingLayerID: 0 m_SortingOrder: 0 m_TargetDisplay: 0 --- !u!1 &1587363384 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 1587363385} - component: {fileID: 1587363388} - component: {fileID: 1587363387} - component: {fileID: 1587363386} m_Layer: 5 m_Name: Button m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!224 &1587363385 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1587363384} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_Children: - {fileID: 730559311} m_Father: {fileID: 1323586517} m_RootOrder: 0 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0.5, y: 0.5} m_AnchorMax: {x: 0.5, y: 0.5} m_AnchoredPosition: {x: 0, y: 0} m_SizeDelta: {x: 160, y: 30} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &1587363386 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1587363384} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3} m_Name: m_EditorClassIdentifier: m_Navigation: m_Mode: 3 m_SelectOnUp: {fileID: 0} m_SelectOnDown: {fileID: 0} m_SelectOnLeft: {fileID: 0} m_SelectOnRight: {fileID: 0} m_Transition: 1 m_Colors: m_NormalColor: {r: 1, g: 1, b: 1, a: 1} m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} m_ColorMultiplier: 1 m_FadeDuration: 0.1 m_SpriteState: m_HighlightedSprite: {fileID: 0} m_PressedSprite: {fileID: 0} m_SelectedSprite: {fileID: 0} m_DisabledSprite: {fileID: 0} m_AnimationTriggers: m_NormalTrigger: Normal m_HighlightedTrigger: Highlighted m_PressedTrigger: Pressed m_SelectedTrigger: Selected m_DisabledTrigger: Disabled m_Interactable: 1 m_TargetGraphic: {fileID: 1587363387} m_OnClick: m_PersistentCalls: m_Calls: [] --- !u!114 &1587363387 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1587363384} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} m_Name: m_EditorClassIdentifier: m_Material: {fileID: 0} m_Color: {r: 1, g: 1, b: 1, a: 1} m_RaycastTarget: 1 m_OnCullStateChanged: m_PersistentCalls: m_Calls: [] m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0} m_Type: 1 m_PreserveAspect: 0 m_FillCenter: 1 m_FillMethod: 4 m_FillAmount: 1 m_FillClockwise: 1 m_FillOrigin: 0 m_UseSpriteMesh: 0 m_PixelsPerUnitMultiplier: 1 --- !u!222 &1587363388 CanvasRenderer: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1587363384} m_CullTransparentMesh: 0 ================================================ FILE: src/UniTask/Assets/Scenes/ExceptionExamples.unity.meta ================================================ fileFormatVersion: 2 guid: b5fed17e3ece238439bc796d8747df5d DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Scenes/MiddlewareSample.cs ================================================ //using Cysharp.Threading.Tasks; //using System; //using System.Collections.Generic; //using System.Diagnostics; //using System.Linq; //using System.Text; //using System.Threading; //using System.Threading.Tasks; //using UnityEngine; //using UnityEngine.Networking; //using UnityEngine.SceneManagement; //using UnityEngine.UI; //namespace Cysharp.Threading.Tasks.Sample //{ // //public class Sample2 // //{ // // public Sample2() // // { // // // デコレーターの詰まったClientを生成（これは一度作ったらフィールドに保存可） // // var client = new NetworkClient("http://localhost", TimeSpan.FromSeconds(10), // // new QueueRequestDecorator(), // // new LoggingDecorator(), // // new AppendTokenDecorator(), // // new SetupHeaderDecorator()); // // await client.PostAsync("/User/Register", new { Id = 100 }); // // } // //} // public class ReturnToTitleDecorator : IAsyncDecorator // { // public async UniTask SendAsync(RequestContext context, CancellationToken cancellationToken, Func> next) // { // try // { // return await next(context, cancellationToken); // } // catch (Exception ex) // { // if (ex is OperationCanceledException) // { // // キャンセルはきっと想定されている処理なのでそのまんまスルー（呼び出し側でOperationCanceledExceptionとして飛んでいく) // throw; // } // if (ex is UnityWebRequestException uwe) // { // // ステータスコードを使って、タイトルに戻す例外です、とかリトライさせる例外です、とかハンドリングさせると便利 // // if (uwe.ResponseCode) { }... // } // // サーバー例外のMessageを直接出すなんて乱暴なことはデバッグ時だけですよ勿論。 // var result = await MessageDialog.ShowAsync(ex.Message); // // OK か Cancelかで分岐するなら。今回はボタン一個、OKのみの想定なので無視 // // if (result == DialogResult.Ok) { }... // // シーン呼び出しはawaitしないこと！awaitして正常終了しちゃうと、この通信の呼び出し元に処理が戻って続行してしまいます // // のでForget。 // SceneManager.LoadSceneAsync("TitleScene").ToUniTask().Forget(); // // そしてOperationCanceledExceptionを投げて、この通信の呼び出し元の処理はキャンセル扱いにして終了させる // throw new OperationCanceledException(); // } // } // } // public enum DialogResult // { // Ok, // Cancel // } // public static class MessageDialog // { // public static async UniTask ShowAsync(string message) // { // // (例えば)Prefabで作っておいたダイアログを生成する // var view = await Resources.LoadAsync("Prefabs/Dialog"); // // Ok, Cancelボタンのどちらかが押されるのを待機 // return await (view as GameObject).GetComponent().ClickResult; // } // } // public class MessageDialogView : MonoBehaviour // { // [SerializeField] Button okButton = default; // [SerializeField] Button closeButton = default; // UniTaskCompletionSource taskCompletion; // // これでどちらかが押されるまで無限に待つを表現 // public UniTask ClickResult => taskCompletion.Task; // private void Start() // { // taskCompletion = new UniTaskCompletionSource(); // okButton.onClick.AddListener(() => // { // taskCompletion.TrySetResult(DialogResult.Ok); // }); // closeButton.onClick.AddListener(() => // { // taskCompletion.TrySetResult(DialogResult.Cancel); // }); // } // // もしボタンが押されずに消滅した場合にネンノタメ。 // private void OnDestroy() // { // taskCompletion.TrySetResult(DialogResult.Cancel); // } // } // public class MockDecorator : IAsyncDecorator // { // Dictionary mock; // // Pathと型を1:1にして事前定義したオブジェクトを返す辞書を渡す // public MockDecorator(Dictionary mock) // { // this.mock = mock; // } // public UniTask SendAsync(RequestContext context, CancellationToken cancellationToken, Func> next) // { // if (mock.TryGetValue(context.Path, out var value)) // { // // 一致したものがあればそれを返す（実際の通信は行わない） // return new UniTask(new ResponseContext(value)); // } // else // { // return next(context, cancellationToken); // } // } // } // //public class LoggingDecorator : IAsyncDecorator // //{ // // public async UniTask SendAsync(RequestContext context, CancellationToken cancellationToken, Func> next) // // { // // var sw = Stopwatch.StartNew(); // // try // // { // // UnityEngine.Debug.Log("Start Network Request:" + context.Path); // // var response = await next(context, cancellationToken); // // UnityEngine.Debug.Log($"Complete Network Request: {context.Path} , Elapsed: {sw.Elapsed}, Size: {response.GetRawData().Length}"); // // return response; // // } // // catch (Exception ex) // // { // // if (ex is OperationCanceledException) // // { // // UnityEngine.Debug.Log("Request Canceled:" + context.Path); // // } // // else if (ex is TimeoutException) // // { // // UnityEngine.Debug.Log("Request Timeout:" + context.Path); // // } // // else if (ex is UnityWebRequestException webex) // // { // // if (webex.IsHttpError) // // { // // UnityEngine.Debug.Log($"Request HttpError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}"); // // } // // else if (webex.IsNetworkError) // // { // // UnityEngine.Debug.Log($"Request NetworkError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}"); // // } // // } // // throw; // // } // // finally // // { // // /* log other */ // // } // // } // //} // public class SetupHeaderDecorator : IAsyncDecorator // { // public async UniTask SendAsync(RequestContext context, CancellationToken cancellationToken, Func> next) // { // context.RequestHeaders["x-app-timestamp"] = context.Timestamp.ToString(); // context.RequestHeaders["x-user-id"] = "132141411"; // どこかから持ってくる // context.RequestHeaders["x-access-token"] = "fafafawfafewaea"; // どこかから持ってくる2 // var respsonse = await next(context, cancellationToken); // var nextToken = respsonse.ResponseHeaders["token"]; // // UserProfile.Token = nextToken; // どこかにセットするということにする // return respsonse; // } // } // public class AppendTokenDecorator : IAsyncDecorator // { // public async UniTask SendAsync(RequestContext context, CancellationToken cancellationToken, Func> next) // { // string token = "token"; // どっかから取ってくるということにする // RETRY: // try // { // context.RequestHeaders["x-access-token"] = token; // return await next(context, cancellationToken); // } // catch (UnityWebRequestException ex) // { // // 例えば700はTokenを再取得してください的な意味だったとする // if (ex.ResponseCode == 700) // { // // 別口でTokenを取得します的な処理 // var newToken = await new NetworkClient(context.BasePath, context.Timeout).PostAsync("/Auth/GetToken", "access_token", cancellationToken); // context.Reset(this); // goto RETRY; // } // goto RETRY; // } // } // } // public class QueueRequestDecorator : IAsyncDecorator // { // readonly Queue<(UniTaskCompletionSource, RequestContext, CancellationToken, Func>)> q = new Queue<(UniTaskCompletionSource, RequestContext, CancellationToken, Func>)>(); // bool running; // public async UniTask SendAsync(RequestContext context, CancellationToken cancellationToken, Func> next) // { // if (q.Count == 0) // { // return await next(context, cancellationToken); // } // else // { // var completionSource = new UniTaskCompletionSource(); // q.Enqueue((completionSource, context, cancellationToken, next)); // if (!running) // { // Run().Forget(); // } // return await completionSource.Task; // } // } // async UniTaskVoid Run() // { // running = true; // try // { // while (q.Count != 0) // { // var (tcs, context, cancellationToken, next) = q.Dequeue(); // try // { // var response = await next(context, cancellationToken); // tcs.TrySetResult(response); // } // catch (Exception ex) // { // tcs.TrySetException(ex); // } // } // } // finally // { // running = false; // } // } // } // public class RequestContext // { // int decoratorIndex; // readonly IAsyncDecorator[] decorators; // Dictionary headers; // public string BasePath { get; } // public string Path { get; } // public object Value { get; } // public TimeSpan Timeout { get; } // public DateTimeOffset Timestamp { get; private set; } // public IDictionary RequestHeaders // { // get // { // if (headers == null) // { // headers = new Dictionary(); // } // return headers; // } // } // public RequestContext(string basePath, string path, object value, TimeSpan timeout, IAsyncDecorator[] filters) // { // this.decoratorIndex = -1; // this.decorators = filters; // this.BasePath = basePath; // this.Path = path; // this.Value = value; // this.Timeout = timeout; // this.Timestamp = DateTimeOffset.UtcNow; // } // internal Dictionary GetRawHeaders() => headers; // internal IAsyncDecorator GetNextDecorator() => decorators[++decoratorIndex]; // public void Reset(IAsyncDecorator currentFilter) // { // decoratorIndex = Array.IndexOf(decorators, currentFilter); // if (headers != null) // { // headers.Clear(); // } // Timestamp = DateTimeOffset.UtcNow; // } // } // public class ResponseContext // { // bool hasValue; // object value; // readonly byte[] bytes; // public long StatusCode { get; } // public Dictionary ResponseHeaders { get; } // public ResponseContext(object value, Dictionary header = null) // { // this.hasValue = true; // this.value = value; // this.StatusCode = 200; // this.ResponseHeaders = (header ?? new Dictionary()); // } // public ResponseContext(byte[] bytes, long statusCode, Dictionary responseHeaders) // { // this.hasValue = false; // this.bytes = bytes; // this.StatusCode = statusCode; // this.ResponseHeaders = responseHeaders; // } // public byte[] GetRawData() => bytes; // public T GetResponseAs() // { // if (hasValue) // { // return (T)value; // } // value = JsonUtility.FromJson(Encoding.UTF8.GetString(bytes)); // hasValue = true; // return (T)value; // } // } // public interface IAsyncDecorator // { // UniTask SendAsync(RequestContext context, CancellationToken cancellationToken, Func> next); // } // public class NetworkClient : IAsyncDecorator // { // readonly Func> next; // readonly IAsyncDecorator[] decorators; // readonly TimeSpan timeout; // readonly IProgress progress; // readonly string basePath; // public NetworkClient(string basePath, TimeSpan timeout, params IAsyncDecorator[] decorators) // : this(basePath, timeout, null, decorators) // { // } // public NetworkClient(string basePath, TimeSpan timeout, IProgress progress, params IAsyncDecorator[] decorators) // { // this.next = InvokeRecursive; // setup delegate // this.basePath = basePath; // this.timeout = timeout; // this.progress = progress; // this.decorators = new IAsyncDecorator[decorators.Length + 1]; // Array.Copy(decorators, this.decorators, decorators.Length); // this.decorators[this.decorators.Length - 1] = this; // } // public async UniTask PostAsync(string path, T value, CancellationToken cancellationToken = default) // { // var request = new RequestContext(basePath, path, value, timeout, decorators); // var response = await InvokeRecursive(request, cancellationToken); // return response.GetResponseAs(); // } // UniTask InvokeRecursive(RequestContext context, CancellationToken cancellationToken) // { // return context.GetNextDecorator().SendAsync(context, cancellationToken, next); // マジカル再帰処理 // } // async UniTask IAsyncDecorator.SendAsync(RequestContext context, CancellationToken cancellationToken, Func> _) // { // // Postしか興味ないからPostにしかしないよ！ // // パフォーマンスを最大限にしたい場合はuploadHandler, downloadHandlerをカスタマイズすること // // JSONでbodyに送るというパラメータで送るという雑設定。 // var data = JsonUtility.ToJson(context.Value); // var formData = new Dictionary { { "body", data } }; // using (var req = UnityWebRequest.Post(basePath + context.Path, formData)) // { // var header = context.GetRawHeaders(); // if (header != null) // { // foreach (var item in header) // { // req.SetRequestHeader(item.Key, item.Value); // } // } // // Timeout処理はCancellationTokenSourceのCancelAfterSlim(UniTask拡張)を使ってサクッと処理 // var linkToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); // linkToken.CancelAfterSlim(timeout); // try // { // // 完了待ちや終了処理はUniTaskの拡張自体に丸投げ // await req.SendWebRequest().ToUniTask(progress: progress, cancellationToken: linkToken.Token); // } // catch (OperationCanceledException) // { // // 元キャンセレーションソースがキャンセルしてなければTimeoutによるものと判定 // if (!cancellationToken.IsCancellationRequested) // { // throw new TimeoutException(); // } // } // finally // { // // Timeoutに引っかからなかった場合にてるのでCancelAfterSlimの裏で回ってるループをこれで終わらせとく // if (!linkToken.IsCancellationRequested) // { // linkToken.Cancel(); // } // } // // UnityWebRequestを先にDisposeしちゃうので先に必要なものを取得しておく（性能的には無駄なのでパフォーマンスを最大限にしたい場合は更に一工夫を） // return new ResponseContext(req.downloadHandler.data, req.responseCode, req.GetResponseHeaders()); // } // } // } //} ================================================ FILE: src/UniTask/Assets/Scenes/MiddlewareSample.cs.meta ================================================ fileFormatVersion: 2 guid: 7fc39a4b35a8db44592cddc0b365942f MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Scenes/SandboxMain.cs ================================================ using Cysharp.Threading.Tasks; using System.Linq; using Cysharp.Threading.Tasks.Linq; using Cysharp.Threading.Tasks.Triggers; using System; using System.Collections; using System.Collections.Generic; using System.Text; using System.Threading; using System.Threading.Tasks; using Unity.Collections; using Unity.Jobs; using UnityEngine; using UnityEngine.LowLevel; using UnityEngine.Networking; using UnityEngine.UI; using UnityEngine.SceneManagement; using UnityEngine.Rendering; using System.IO; using System.Linq.Expressions; using UnityEngine.Events; // using DG.Tweening; public struct MyJob : IJob { public int loopCount; public NativeArray inOut; public int result; public void Execute() { result = 0; for (int i = 0; i < loopCount; i++) { result++; } inOut[0] = result; } } public enum MyEnum { A, B, C } public class SimplePresenter { // View public UnityEngine.UI.InputField Input; // Presenter public SimplePresenter() { //Input.OnValueChangedAsAsyncEnumerable() // .Queue() // .SelectAwait(async x => // { // await UniTask.Delay(TimeSpan.FromSeconds(1)); // return x; // }) // .Select(x=> x.ToUpper()) // .BindTo( } } public static partial class UnityUIComponentExtensions { } public class AsyncMessageBroker : IDisposable { Channel channel; IConnectableUniTaskAsyncEnumerable multicastSource; IDisposable connection; public AsyncMessageBroker() { channel = Channel.CreateSingleConsumerUnbounded(); multicastSource = channel.Reader.ReadAllAsync().Publish(); connection = multicastSource.Connect(); } public void Publish(T value) { channel.Writer.TryWrite(value); } public IUniTaskAsyncEnumerable Subscribe() { return multicastSource; } public void Dispose() { channel.Writer.TryComplete(); connection.Dispose(); } } public class WhenEachTest { public async UniTask Each() { var a = Delay(1, 3000); var b = Delay(2, 1000); var c = Delay(3, 2000); var l = new List(); await foreach (var item in UniTask.WhenEach(a, b, c)) { Debug.Log(item.Result); } } async UniTask Delay(int id, int sleep) { await UniTask.Delay(sleep); return id; } } public class SandboxMain : MonoBehaviour { public Camera mycamera; public Button okButton; public Button cancelButton; CancellationTokenSource cts; public AsyncReactiveProperty RP1; UniTaskCompletionSource ucs; async UniTask FooAsync() { // use F10, will crash. var loop = int.Parse("9"); await UniTask.DelayFrame(loop); Debug.Log("OK"); await UniTask.DelayFrame(loop); Debug.Log("Again"); // var foo = InstantiateAsync(this).ToUniTask(); // var tako = await foo; //UnityAction action; return 10; } public class Model { // State Hp { get; } public Model() { // hp = new AsyncReactiveProperty(); //setHp = Hp.GetSetter(); } void Increment(int value) { // setHp(Hp.Value += value); } } public Text text; public Button button; async UniTask RunStandardDelayAsync() { UnityEngine.Debug.Log("DEB"); await UniTask.DelayFrame(30); UnityEngine.Debug.Log("DEB END"); } async UniTask RunJobAsync() { var job = new MyJob() { loopCount = 999, inOut = new NativeArray(1, Allocator.TempJob) }; try { JobHandle.ScheduleBatchedJobs(); var scheduled = job.Schedule(); UnityEngine.Debug.Log("OK"); await scheduled; // .ConfigureAwait(PlayerLoopTiming.Update); // .WaitAsync(PlayerLoopTiming.Update); UnityEngine.Debug.Log("OK2"); } finally { job.inOut.Dispose(); } } async UniTaskVoid Update2() { UnityEngine.Debug.Log("async linq!"); await UniTaskAsyncEnumerable.Range(1, 10) .Where(x => x % 2 == 0) .Select(x => x * x) .ForEachAsync(x => { UnityEngine.Debug.Log(x); }); UnityEngine.Debug.Log("done"); } private async UniTaskVoid HogeAsync() { // await is not over await UniTaskAsyncEnumerable .TimerFrame(10) .ForEachAwaitAsync(async _ => // .ForEachAsync(_ => { await UniTask.Delay(1000); Debug.Log(Time.time); }); Debug.Log("Done"); } public int MyProperty { get; set; } public class MyClass { public int MyProperty { get; set; } } async Task Test1() { // var r = await TcsAsync("https://bing.com/"); await Task.Yield(); Debug.Log("TASKASYNC"); } //async UniTaskVoid Test2() //{ // try // { // //var cts = new CancellationTokenSource(); // //var r = UniAsync("https://bing.com/", cts.Token); // //cts.Cancel(); // //await r; // Debug.Log("SendWebRequestDone:" + PlayerLoopInfo.CurrentLoopType); // // var foo = await UnityWebRequest.Get("https://bing.com/").SendWebRequest(); // // foo.downloadHandler.text; // // // _ = await UnityWebRequest.Get("https://bing.com/").SendWebRequest().WithCancellation(CancellationToken.None); // Debug.Log("SendWebRequestWithCancellationDone:" + PlayerLoopInfo.CurrentLoopType); // } // catch // { // Debug.Log("Canceled"); // } //} IEnumerator Test3(string url) { var req = UnityWebRequest.Get(url).SendWebRequest(); yield return req; Debug.Log("COROUTINE"); } //static async Task TcsAsync(string url) //{ // var req = await UnityWebRequest.Get(url).SendWebRequest(); // return req; //} //static async UniTask UniAsync(string url, CancellationToken cancellationToken) //{ // var req = await UnityWebRequest.Get(url).SendWebRequest().WithCancellation(cancellationToken); // return req; //} async Task Test() { await Task.Yield(); return 10; } async UniTask Ex() { await UniTask.Yield(); //throw new Exception(); await UniTask.Delay(TimeSpan.FromSeconds(15)); return 0; } IEnumerator CoroutineRun() { UnityEngine.Debug.Log("Before Coroutine yield return null," + Time.frameCount + ", " + PlayerLoopInfo.CurrentLoopType); yield return null; UnityEngine.Debug.Log("After Coroutine yield return null," + Time.frameCount + ", " + PlayerLoopInfo.CurrentLoopType); } IEnumerator CoroutineRun2() { UnityEngine.Debug.Log("Before Coroutine yield return WaitForEndOfFrame," + Time.frameCount); yield return new WaitForEndOfFrame(); UnityEngine.Debug.Log("After Coroutine yield return WaitForEndOfFrame," + Time.frameCount + ", " + PlayerLoopInfo.CurrentLoopType); yield return new WaitForEndOfFrame(); UnityEngine.Debug.Log("Onemore After Coroutine yield return WaitForEndOfFrame," + Time.frameCount + ", " + PlayerLoopInfo.CurrentLoopType); } async UniTaskVoid AsyncRun() { UnityEngine.Debug.Log("Before async Yield(default)," + Time.frameCount); await UniTask.Yield(); UnityEngine.Debug.Log("After async Yield(default)," + Time.frameCount + ", " + PlayerLoopInfo.CurrentLoopType); } async UniTaskVoid AsyncLastUpdate() { UnityEngine.Debug.Log("Before async Yield(LastUpdate)," + Time.frameCount); await UniTask.Yield(PlayerLoopTiming.LastUpdate); UnityEngine.Debug.Log("After async Yield(LastUpdate)," + Time.frameCount); } async UniTaskVoid AsyncLastLast() { UnityEngine.Debug.Log("Before async Yield(LastPostLateUpdate)," + Time.frameCount); await UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate); UnityEngine.Debug.Log("After async Yield(LastPostLateUpdate)," + Time.frameCount); } async UniTaskVoid Yieldding() { await UniTask.Yield(PlayerLoopTiming.PreUpdate); StartCoroutine(CoroutineRun()); } async UniTaskVoid AsyncFixedUpdate() { while (true) { await UniTask.WaitForFixedUpdate(); Debug.Log("Async:" + Time.frameCount + ", " + PlayerLoopInfo.CurrentLoopType); } } IEnumerator CoroutineFixedUpdate() { while (true) { yield return new WaitForFixedUpdate(); Debug.Log("Coroutine:" + Time.frameCount + ", " + PlayerLoopInfo.CurrentLoopType); } } private void FixedUpdate() { // Debug.Log("FixedUpdate:" + Time.frameCount + ", " + PlayerLoopInfo.CurrentLoopType); } async UniTaskVoid DelayFrame3_Pre() { await UniTask.Yield(PlayerLoopTiming.PreUpdate); Debug.Log("Before framecount:" + Time.frameCount); await UniTask.DelayFrame(3); Debug.Log("After framecount:" + Time.frameCount); } async UniTaskVoid DelayFrame3_Post() { await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); Debug.Log("Before framecount:" + Time.frameCount); await UniTask.DelayFrame(3); Debug.Log("After framecount:" + Time.frameCount); } async UniTask TestCoroutine() { await UniTask.Yield(); throw new Exception("foobarbaz"); } async UniTask DelayCheck() { await UniTask.Yield(PlayerLoopTiming.PreUpdate); Debug.Log("before"); var t = UniTask.Delay(TimeSpan.FromSeconds(1), ignoreTimeScale: false); await t; Debug.Log("after"); } //private async UniTaskVoid ExecuteAsync() //{ // var req = UnityWebRequest.Get("https://google.com/"); // var v = await req.SendWebRequest().ToUniTask(); // // req.Dispose(); // Debug.Log($"{v.isDone} {v.isHttpError} {v.isNetworkError}"); // Debug.Log(v.downloadHandler.text); //} private async void Go() { await UniTask.DelayFrame(0); } async UniTask Foo() { await UniTask.DelayFrame(10); throw new Exception("yeah"); } async void Nanika() { await UniTask.Yield(); Debug.Log("Here"); throw new Exception(); } private void Awake() { // PlayerLoopInfo.Inject(); PrepareCamera(); } public IUniTaskAsyncEnumerable MyEveryUpdate() { return UniTaskAsyncEnumerable.Create(async (writer, token) => { var frameCount = 0; await UniTask.Yield(); while (!token.IsCancellationRequested) { await writer.YieldAsync(frameCount++); // instead of `yield return` await UniTask.Yield(); } }); } async void RunStandardTaskAsync() { Debug.Log("Wait 3 seconds"); await Task.Delay(TimeSpan.FromSeconds(3)); Debug.Log("Current SyncContext:" + SynchronizationContext.Current.GetType().FullName); } async UniTask QuitCheck() { try { await UniTask.Delay(TimeSpan.FromMinutes(1), cancellationToken: quitSource.Token); } finally { Debug.Log("End QuitCheck async"); } } CancellationTokenSource quitSource = new CancellationTokenSource(); IEnumerator TestCor() { Debug.Log("start cor"); yield return null; yield return new WaitForEndOfFrame(); Debug.Log("end cor"); } IEnumerator LastYieldCore() { Debug.Log("YieldBegin:" + Time.frameCount); yield return new WaitForEndOfFrame(); Debug.Log("YieldEnd:" + Time.frameCount); } private static async UniTask TestAsync(CancellationToken ct) { Debug.Log("TestAsync Start."); var count = 0; while (!ct.IsCancellationRequested) { try { Debug.Log($"TestAsync try count:{++count}"); var task1 = new WaitUntil(() => UnityEngine.Random.Range(0, 10) == 0).ToUniTask(); var task2 = new WaitUntil(() => UnityEngine.Random.Range(0, 10) == 0).ToUniTask(); var task3 = new WaitUntil(() => UnityEngine.Random.Range(0, 10) == 0).ToUniTask(); await UniTask.WhenAny(task1, task2, task3); } catch (Exception e) { Debug.LogError(e); return; } } Debug.Log("TestAsync Finished."); } async UniTaskVoid Start() { await new WhenEachTest().Each(); // UniTask.Delay(TimeSpan.FromSeconds(1)).TimeoutWithoutException var currentLoop = PlayerLoop.GetDefaultPlayerLoop(); PlayerLoopHelper.Initialize(ref currentLoop, InjectPlayerLoopTimings.Minimum); // minimum is Update | FixedUpdate | LastPostLateUpdate // TestAsync(cts.Token).Forget(); okButton.onClick.AddListener(UniTask.UnityAction(async () => { await UniTask.WaitForEndOfFrame(this); var texture = new Texture2D(Screen.width, Screen.height); texture.ReadPixels(new Rect(0, 0, Screen.width, Screen.height), 0, 0); texture.Apply(); var jpg = texture.EncodeToJPG(); File.WriteAllBytes("testscreencapture.jpg", jpg); Debug.Log("ok?"); //var texture = ScreenCapture.CaptureScreenshotAsTexture(); //if (texture == null) //{ // Debug.Log("fail"); //} //else //{ // var jpg = texture.EncodeToJPG(); // File.WriteAllBytes("testscreencapture.jpg", jpg); // Debug.Log("ok?"); //} })); cancelButton.onClick.AddListener(UniTask.UnityAction(async () => { //clickCancelSource.Cancel(); //RunCheck(PlayerLoopTiming.Initialization).Forget(); //RunCheck(PlayerLoopTiming.LastInitialization).Forget(); //RunCheck(PlayerLoopTiming.EarlyUpdate).Forget(); //RunCheck(PlayerLoopTiming.LastEarlyUpdate).Forget(); //RunCheck(PlayerLoopTiming.FixedUpdate).Forget(); //RunCheck(PlayerLoopTiming.LastFixedUpdate).Forget(); //RunCheck(PlayerLoopTiming.PreUpdate).Forget(); //RunCheck(PlayerLoopTiming.LastPreUpdate).Forget(); //RunCheck(PlayerLoopTiming.Update).Forget(); //RunCheck(PlayerLoopTiming.LastUpdate).Forget(); //RunCheck(PlayerLoopTiming.PreLateUpdate).Forget(); //RunCheck(PlayerLoopTiming.LastPreLateUpdate).Forget(); //RunCheck(PlayerLoopTiming.PostLateUpdate).Forget(); //RunCheck(PlayerLoopTiming.LastPostLateUpdate).Forget(); await UniTask.Yield(); })); await UniTask.Yield(); } async UniTaskVoid RunCheck(PlayerLoopTiming timing) { //await UniTask.Yield(timing); //UnityEngine.Debug.Log("Yield:" + timing); await UniTask.DelayFrame(1, timing); UnityEngine.Debug.Log("Delay:" + timing); } private void Application_logMessageReceived2(string condition, string stackTrace, LogType type) { throw new NotImplementedException(); } private void Application_logMessageReceived1(string condition, string stackTrace, LogType type) { throw new NotImplementedException(); } async UniTaskVoid UpdateUniTask() { while (true) { await UniTask.Yield(); UnityEngine.Debug.Log("UniTaskYield:" + PlayerLoopInfo.CurrentLoopType); } } async UniTaskVoid ReturnToMainThreadTest() { var d = UniTask.ReturnToCurrentSynchronizationContext(); try { UnityEngine.Debug.Log("In MainThread?" + Thread.CurrentThread.ManagedThreadId); UnityEngine.Debug.Log("SyncContext is null?" + (SynchronizationContext.Current == null)); await UniTask.SwitchToThreadPool(); UnityEngine.Debug.Log("In ThreadPool?" + Thread.CurrentThread.ManagedThreadId); UnityEngine.Debug.Log("SyncContext is null?" + (SynchronizationContext.Current == null)); } finally { await d.DisposeAsync(); } UnityEngine.Debug.Log("In ThreadPool?" + Thread.CurrentThread.ManagedThreadId); UnityEngine.Debug.Log("SyncContext is null2" + (SynchronizationContext.Current == null)); } private void Update() { // UnityEngine.Debug.Log("Update:" + PlayerLoopInfo.CurrentLoopType); } IEnumerator Coroutine() { try { while (true) { yield return null; //UnityEngine.Debug.Log("Coroutine null:" + PlayerLoopInfo.CurrentLoopType); } } finally { UnityEngine.Debug.Log("Coroutine Finally"); } } async UniTaskVoid CloseAsync(CancellationToken cancellationToken = default) { while (true) { await UniTask.Yield(PlayerLoopTiming.Update, cancellationToken); } } async UniTaskVoid Running(CancellationToken ct) { Debug.Log("BEGIN"); await UniTask.WaitUntilCanceled(ct); Debug.Log("DONE"); } async UniTaskVoid WaitForChannelAsync(ChannelReader reader, CancellationToken token) { try { //var result1 = await reader.ReadAsync(token); //Debug.Log(result1); await reader.ReadAllAsync().ForEachAsync(x => Debug.Log(x)/*, token*/); Debug.Log("done"); } catch (Exception ex) { Debug.Log("here"); Debug.LogException(ex); } } async UniTaskVoid Go(AsyncUpdateTrigger trigger, int i, CancellationToken ct) { await UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate); UnityEngine.Debug.Log("AWAIT BEFO:" + Time.frameCount); var handler = trigger.GetUpdateAsyncHandler(ct); try { while (!ct.IsCancellationRequested) { await handler.UpdateAsync(); //await handler.UpdateAsync(); Debug.Log("OK:" + i); } } finally { UnityEngine.Debug.Log("AWAIT END:" + Time.frameCount + ": No," + i); } } async UniTaskVoid ClickOnce() { try { await okButton.OnClickAsync(); UnityEngine.Debug.Log("CLICKED ONCE"); } catch (Exception ex) { UnityEngine.Debug.Log(ex.ToString()); } finally { UnityEngine.Debug.Log("END ONCE"); } } async UniTaskVoid ClickForever() { try { using (var handler = okButton.GetAsyncClickEventHandler()) { while (true) { await handler.OnClickAsync(); UnityEngine.Debug.Log("Clicked"); } } } catch (Exception ex) { UnityEngine.Debug.Log(ex.ToString()); } finally { UnityEngine.Debug.Log("END"); } } async UniTask SimpleAwait() { await UniTask.Yield(); await UniTask.Yield(); await UniTask.Yield(); throw new InvalidOperationException("bar!!!"); } IEnumerator SimpleCoroutine() { yield return null; yield return null; yield return null; throw new InvalidOperationException("foo!!!"); } async UniTask TimingDump(PlayerLoopTiming timing) { while (true) { await UniTask.Yield(timing); Debug.Log("PlayerLoopTiming." + timing); } } IEnumerator CoroutineDump(string msg, YieldInstruction waitObj) { while (true) { yield return waitObj; Debug.Log(msg); } } //private void Update() //{ // Debug.Log("Update"); //} //private void LateUpdate() //{ // Debug.Log("LateUpdate"); //} //private void FixedUpdate() //{ // Debug.Log("FixedUpdate"); //} private void Application_logMessageReceived(string condition, string stackTrace, LogType type) { if (text != null) { text.text += "\n" + condition; } } async UniTask OuterAsync(bool b) { UnityEngine.Debug.Log("START OUTER"); await InnerAsync(b); await InnerAsync(b); UnityEngine.Debug.Log("END OUTER"); // throw new InvalidOperationException("NAZO ERROR!?"); // error!? } async UniTask InnerAsync(bool b) { if (b) { UnityEngine.Debug.Log("Start delay:" + Time.frameCount); await UniTask.DelayFrame(60); UnityEngine.Debug.Log("End delay:" + Time.frameCount); await UniTask.DelayFrame(60); UnityEngine.Debug.Log("Onemore end delay:" + Time.frameCount); } else { UnityEngine.Debug.Log("Empty END"); throw new InvalidOperationException("FOOBARBAZ"); } } /* PlayerLoopTiming.Initialization PlayerLoopTiming.LastInitialization PlayerLoopTiming.EarlyUpdate PlayerLoopTiming.LastEarlyUpdate PlayerLoopTiming.PreUpdate PlayerLoopTiming.LastPreUpdate PlayerLoopTiming.Update Update yield null yield WaitForSeconds yield WWW yield StartCoroutine PlayerLoopTiming.LastUpdate PlayerLoopTiming.PreLateUpdate LateUpdate PlayerLoopTiming.LastPreLateUpdate PlayerLoopTiming.PostLateUpdate PlayerLoopTiming.LastPostLateUpdate yield WaitForEndOfFrame // --- Physics Loop PlayerLoopTiming.FixedUpdate FixedUpdate yield WaitForFixedUpdate PlayerLoopTiming.LastFixedUpdate */ private void TaskScheduler_UnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e) { // e.SetObserved(); // or other custom write code. UnityEngine.Debug.LogError("Unobserved:" + e.Exception.ToString()); } // GPU Screenshot Sample void PrepareCamera() { //Debug.Log("Support AsyncGPUReadback:" + SystemInfo.supportsAsyncGPUReadback); //var width = 480; //var height = 240; //var depth = 24; //mycamera.targetTexture = new RenderTexture(width, height, depth, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default) //{ // antiAliasing = 8 //}; //mycamera.enabled = true; //myRenderTexture = new RenderTexture(width, height, depth, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default) //{ // antiAliasing = 8 //}; } RenderTexture myRenderTexture; async UniTask ShootAsync() { var rt = mycamera.targetTexture; var req = await AsyncGPUReadback.Request(rt, 0); Debug.Log("GPU Readback done?:" + req.done); var rawByteArray = req.GetData().ToArray(); var graphicsFormat = rt.graphicsFormat; var width = (uint)rt.width; var height = (uint)rt.height; Debug.Log("BytesSize:" + rawByteArray.Length); var imageBytes = ImageConversion.EncodeArrayToPNG(rawByteArray, graphicsFormat, width, height); File.WriteAllBytes("my_screenshot.png", imageBytes); // test } } public class SyncContextInjecter { [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] public static void Inject() { SynchronizationContext.SetSynchronizationContext(new UniTaskSynchronizationContext()); } } public class PlayerLoopInfo { // [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] static void Init() { var playerLoop = UnityEngine.LowLevel.PlayerLoop.GetDefaultPlayerLoop(); DumpPlayerLoop("Default", playerLoop); } public static void DumpPlayerLoop(string which, UnityEngine.LowLevel.PlayerLoopSystem playerLoop) { var sb = new StringBuilder(); sb.AppendLine($"{which} PlayerLoop List"); foreach (var header in playerLoop.subSystemList) { sb.AppendFormat("------{0}------", header.type.Name); sb.AppendLine(); foreach (var subSystem in header.subSystemList) { sb.AppendFormat("{0}.{1}", header.type.Name, subSystem.type.Name); sb.AppendLine(); if (subSystem.subSystemList != null) { UnityEngine.Debug.LogWarning("More Subsystem:" + subSystem.subSystemList.Length); } } } UnityEngine.Debug.Log(sb.ToString()); } public static Type CurrentLoopType { get; private set; } // [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)] public static void Inject() { var system = PlayerLoop.GetCurrentPlayerLoop(); for (int i = 0; i < system.subSystemList.Length; i++) { var loop = system.subSystemList[i].subSystemList.SelectMany(x => { var t = typeof(WrapLoop<>).MakeGenericType(x.type); var instance = (ILoopRunner)Activator.CreateInstance(t, x.type); return new[] { new PlayerLoopSystem { type = t, updateDelegate = instance.Run }, x }; }).ToArray(); system.subSystemList[i].subSystemList = loop; } PlayerLoop.SetPlayerLoop(system); } interface ILoopRunner { void Run(); } class WrapLoop : ILoopRunner { readonly Type type; public WrapLoop(Type type) { this.type = type; } public void Run() { CurrentLoopType = type; } } } ================================================ FILE: src/UniTask/Assets/Scenes/SandboxMain.cs.meta ================================================ fileFormatVersion: 2 guid: f0bc6c75abb2e0b47a25aa49bfd488ed MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Scenes/SandboxMain.unity ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!29 &1 OcclusionCullingSettings: m_ObjectHideFlags: 0 serializedVersion: 2 m_OcclusionBakeSettings: smallestOccluder: 5 smallestHole: 0.25 backfaceThreshold: 100 m_SceneGUID: 00000000000000000000000000000000 m_OcclusionCullingData: {fileID: 0} --- !u!104 &2 RenderSettings: m_ObjectHideFlags: 0 serializedVersion: 10 m_Fog: 0 m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1} m_FogMode: 3 m_FogDensity: 0.01 m_LinearFogStart: 0 m_LinearFogEnd: 300 m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1} m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1} m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1} m_AmbientIntensity: 1 m_AmbientMode: 3 m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1} m_SkyboxMaterial: {fileID: 0} m_HaloStrength: 0.5 m_FlareStrength: 1 m_FlareFadeSpeed: 3 m_HaloTexture: {fileID: 0} m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0} m_DefaultReflectionMode: 0 m_DefaultReflectionResolution: 128 m_ReflectionBounces: 1 m_ReflectionIntensity: 1 m_CustomReflection: {fileID: 0} m_Sun: {fileID: 0} m_UseRadianceAmbientProbe: 0 --- !u!157 &3 LightmapSettings: m_ObjectHideFlags: 0 serializedVersion: 12 m_GISettings: serializedVersion: 2 m_BounceScale: 1 m_IndirectOutputScale: 1 m_AlbedoBoost: 1 m_EnvironmentLightingMode: 0 m_EnableBakedLightmaps: 0 m_EnableRealtimeLightmaps: 0 m_LightmapEditorSettings: serializedVersion: 12 m_Resolution: 2 m_BakeResolution: 40 m_AtlasSize: 1024 m_AO: 0 m_AOMaxDistance: 1 m_CompAOExponent: 1 m_CompAOExponentDirect: 0 m_ExtractAmbientOcclusion: 0 m_Padding: 2 m_LightmapParameters: {fileID: 0} m_LightmapsBakeMode: 1 m_TextureCompression: 1 m_ReflectionCompression: 2 m_MixedBakeMode: 2 m_BakeBackend: 0 m_PVRSampling: 1 m_PVRDirectSampleCount: 32 m_PVRSampleCount: 500 m_PVRBounces: 2 m_PVREnvironmentSampleCount: 500 m_PVREnvironmentReferencePointCount: 2048 m_PVRFilteringMode: 2 m_PVRDenoiserTypeDirect: 0 m_PVRDenoiserTypeIndirect: 0 m_PVRDenoiserTypeAO: 0 m_PVRFilterTypeDirect: 0 m_PVRFilterTypeIndirect: 0 m_PVRFilterTypeAO: 0 m_PVREnvironmentMIS: 0 m_PVRCulling: 1 m_PVRFilteringGaussRadiusDirect: 1 m_PVRFilteringGaussRadiusIndirect: 5 m_PVRFilteringGaussRadiusAO: 2 m_PVRFilteringAtrousPositionSigmaDirect: 0.5 m_PVRFilteringAtrousPositionSigmaIndirect: 2 m_PVRFilteringAtrousPositionSigmaAO: 1 m_ExportTrainingData: 0 m_TrainingDataDestination: TrainingData m_LightProbeSampleCountMultiplier: 4 m_LightingDataAsset: {fileID: 0} m_LightingSettings: {fileID: 4890085278179872738, guid: 814185d368762ed45a2298d112780689, type: 2} --- !u!196 &4 NavMeshSettings: serializedVersion: 2 m_ObjectHideFlags: 0 m_BuildSettings: serializedVersion: 3 agentTypeID: 0 agentRadius: 0.5 agentHeight: 2 agentSlope: 45 agentClimb: 0.4 ledgeDropHeight: 0 maxJumpAcrossDistance: 0 minRegionArea: 2 manualCellSize: 0 cellSize: 0.16666667 manualTileSize: 0 tileSize: 256 buildHeightMesh: 0 maxJobWorkers: 0 preserveTilesOutsideBounds: 0 debug: m_Flags: 0 m_NavMeshData: {fileID: 0} --- !u!1 &16537670 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 16537671} - component: {fileID: 16537674} - component: {fileID: 16537673} - component: {fileID: 16537672} m_Layer: 0 m_Name: StartButton m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!224 &16537671 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 16537670} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_ConstrainProportionsScale: 0 m_Children: - {fileID: 1584557232} m_Father: {fileID: 1556045508} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0.5, y: 0.5} m_AnchorMax: {x: 0.5, y: 0.5} m_AnchoredPosition: {x: -7, y: 226} m_SizeDelta: {x: 160, y: 30} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &16537672 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 16537670} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3} m_Name: m_EditorClassIdentifier: m_Navigation: m_Mode: 3 m_WrapAround: 0 m_SelectOnUp: {fileID: 0} m_SelectOnDown: {fileID: 0} m_SelectOnLeft: {fileID: 0} m_SelectOnRight: {fileID: 0} m_Transition: 1 m_Colors: m_NormalColor: {r: 1, g: 1, b: 1, a: 1} m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} m_ColorMultiplier: 1 m_FadeDuration: 0.1 m_SpriteState: m_HighlightedSprite: {fileID: 0} m_PressedSprite: {fileID: 0} m_SelectedSprite: {fileID: 0} m_DisabledSprite: {fileID: 0} m_AnimationTriggers: m_NormalTrigger: Normal m_HighlightedTrigger: Highlighted m_PressedTrigger: Pressed m_SelectedTrigger: Selected m_DisabledTrigger: Disabled m_Interactable: 1 m_TargetGraphic: {fileID: 16537673} m_OnClick: m_PersistentCalls: m_Calls: [] --- !u!114 &16537673 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 16537670} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} m_Name: m_EditorClassIdentifier: m_Material: {fileID: 0} m_Color: {r: 1, g: 1, b: 1, a: 1} m_RaycastTarget: 1 m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} m_Maskable: 1 m_OnCullStateChanged: m_PersistentCalls: m_Calls: [] m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0} m_Type: 1 m_PreserveAspect: 0 m_FillCenter: 1 m_FillMethod: 4 m_FillAmount: 1 m_FillClockwise: 1 m_FillOrigin: 0 m_UseSpriteMesh: 0 m_PixelsPerUnitMultiplier: 1 --- !u!222 &16537674 CanvasRenderer: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 16537670} m_CullTransparentMesh: 0 --- !u!1 &518730348 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 518730350} - component: {fileID: 518730349} m_Layer: 0 m_Name: Camera m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!20 &518730349 Camera: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 518730348} m_Enabled: 1 serializedVersion: 2 m_ClearFlags: 1 m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0} m_projectionMatrixMode: 1 m_GateFitMode: 2 m_FOVAxisMode: 0 m_Iso: 200 m_ShutterSpeed: 0.005 m_Aperture: 16 m_FocusDistance: 10 m_FocalLength: 50 m_BladeCount: 5 m_Curvature: {x: 2, y: 11} m_BarrelClipping: 0.25 m_Anamorphism: 0 m_SensorSize: {x: 36, y: 24} m_LensShift: {x: 0, y: 0} m_NormalizedViewPortRect: serializedVersion: 2 x: 0 y: 0 width: 1 height: 1 near clip plane: 0.3 far clip plane: 1000 field of view: 60 orthographic: 0 orthographic size: 5 m_Depth: 0 m_CullingMask: serializedVersion: 2 m_Bits: 4294967295 m_RenderingPath: -1 m_TargetTexture: {fileID: 0} m_TargetDisplay: 0 m_TargetEye: 3 m_HDR: 1 m_AllowMSAA: 1 m_AllowDynamicResolution: 0 m_ForceIntoRT: 0 m_OcclusionCulling: 1 m_StereoConvergence: 10 m_StereoSeparation: 0.022 --- !u!4 &518730350 Transform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 518730348} serializedVersion: 2 m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 488, y: 418, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_ConstrainProportionsScale: 0 m_Children: [] m_Father: {fileID: 0} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} --- !u!1 &519420028 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 519420032} - component: {fileID: 519420031} - component: {fileID: 519420029} - component: {fileID: 519420030} m_Layer: 0 m_Name: Main Camera m_TagString: MainCamera m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!81 &519420029 AudioListener: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 519420028} m_Enabled: 1 --- !u!114 &519420030 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 519420028} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: f0bc6c75abb2e0b47a25aa49bfd488ed, type: 3} m_Name: m_EditorClassIdentifier: mycamera: {fileID: 0} okButton: {fileID: 16537672} cancelButton: {fileID: 628393011} RP1: latestValue: 0 text: {fileID: 2101290655} button: {fileID: 0} --- !u!20 &519420031 Camera: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 519420028} m_Enabled: 1 serializedVersion: 2 m_ClearFlags: 2 m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0} m_projectionMatrixMode: 1 m_GateFitMode: 2 m_FOVAxisMode: 0 m_Iso: 200 m_ShutterSpeed: 0.005 m_Aperture: 16 m_FocusDistance: 10 m_FocalLength: 50 m_BladeCount: 5 m_Curvature: {x: 2, y: 11} m_BarrelClipping: 0.25 m_Anamorphism: 0 m_SensorSize: {x: 36, y: 24} m_LensShift: {x: 0, y: 0} m_NormalizedViewPortRect: serializedVersion: 2 x: 0 y: 0 width: 1 height: 1 near clip plane: 0.3 far clip plane: 1000 field of view: 60 orthographic: 1 orthographic size: 5 m_Depth: -1 m_CullingMask: serializedVersion: 2 m_Bits: 4294967295 m_RenderingPath: -1 m_TargetTexture: {fileID: 0} m_TargetDisplay: 0 m_TargetEye: 0 m_HDR: 1 m_AllowMSAA: 0 m_AllowDynamicResolution: 0 m_ForceIntoRT: 0 m_OcclusionCulling: 0 m_StereoConvergence: 10 m_StereoSeparation: 0.022 --- !u!4 &519420032 Transform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 519420028} serializedVersion: 2 m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: -10} m_LocalScale: {x: 1, y: 1, z: 1} m_ConstrainProportionsScale: 0 m_Children: [] m_Father: {fileID: 0} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} --- !u!1 &628393009 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 628393010} - component: {fileID: 628393013} - component: {fileID: 628393012} - component: {fileID: 628393011} m_Layer: 0 m_Name: CancelButton m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!224 &628393010 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 628393009} m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_ConstrainProportionsScale: 0 m_Children: - {fileID: 865871445} m_Father: {fileID: 1556045508} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0.5, y: 0.5} m_AnchorMax: {x: 0.5, y: 0.5} m_AnchoredPosition: {x: -4.9, y: 179} m_SizeDelta: {x: 160, y: 30} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &628393011 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 628393009} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 4e29b1a8efbd4b44bb3f3716e73f07ff, type: 3} m_Name: m_EditorClassIdentifier: m_Navigation: m_Mode: 3 m_WrapAround: 0 m_SelectOnUp: {fileID: 0} m_SelectOnDown: {fileID: 0} m_SelectOnLeft: {fileID: 0} m_SelectOnRight: {fileID: 0} m_Transition: 1 m_Colors: m_NormalColor: {r: 1, g: 1, b: 1, a: 1} m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1} m_SelectedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1} m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608} m_ColorMultiplier: 1 m_FadeDuration: 0.1 m_SpriteState: m_HighlightedSprite: {fileID: 0} m_PressedSprite: {fileID: 0} m_SelectedSprite: {fileID: 0} m_DisabledSprite: {fileID: 0} m_AnimationTriggers: m_NormalTrigger: Normal m_HighlightedTrigger: Highlighted m_PressedTrigger: Pressed m_SelectedTrigger: Selected m_DisabledTrigger: Disabled m_Interactable: 1 m_TargetGraphic: {fileID: 628393012} m_OnClick: m_PersistentCalls: m_Calls: [] --- !u!114 &628393012 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 628393009} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: fe87c0e1cc204ed48ad3b37840f39efc, type: 3} m_Name: m_EditorClassIdentifier: m_Material: {fileID: 0} m_Color: {r: 1, g: 1, b: 1, a: 1} m_RaycastTarget: 1 m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} m_Maskable: 1 m_OnCullStateChanged: m_PersistentCalls: m_Calls: [] m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0} m_Type: 1 m_PreserveAspect: 0 m_FillCenter: 1 m_FillMethod: 4 m_FillAmount: 1 m_FillClockwise: 1 m_FillOrigin: 0 m_UseSpriteMesh: 0 m_PixelsPerUnitMultiplier: 1 --- !u!222 &628393013 CanvasRenderer: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 628393009} m_CullTransparentMesh: 0 --- !u!1 &865871444 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 865871445} - component: {fileID: 865871447} - component: {fileID: 865871446} m_Layer: 0 m_Name: Text m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!224 &865871445 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 865871444} m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_ConstrainProportionsScale: 0 m_Children: [] m_Father: {fileID: 628393010} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 1, y: 1} m_AnchoredPosition: {x: 0, y: 0} m_SizeDelta: {x: 0, y: 0} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &865871446 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 865871444} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3} m_Name: m_EditorClassIdentifier: m_Material: {fileID: 0} m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} m_RaycastTarget: 1 m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} m_Maskable: 1 m_OnCullStateChanged: m_PersistentCalls: m_Calls: [] m_FontData: m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0} m_FontSize: 14 m_FontStyle: 0 m_BestFit: 0 m_MinSize: 10 m_MaxSize: 40 m_Alignment: 4 m_AlignByGeometry: 0 m_RichText: 1 m_HorizontalOverflow: 0 m_VerticalOverflow: 0 m_LineSpacing: 1 m_Text: Cancel --- !u!222 &865871447 CanvasRenderer: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 865871444} m_CullTransparentMesh: 0 --- !u!1 &872009839 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 872009842} - component: {fileID: 872009841} - component: {fileID: 872009840} m_Layer: 0 m_Name: EventSystem m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!114 &872009840 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 872009839} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 4f231c4fb786f3946a6b90b886c48677, type: 3} m_Name: m_EditorClassIdentifier: m_SendPointerHoverToParent: 1 m_HorizontalAxis: Horizontal m_VerticalAxis: Vertical m_SubmitButton: Submit m_CancelButton: Cancel m_InputActionsPerSecond: 10 m_RepeatDelay: 0.5 m_ForceModuleActive: 0 --- !u!114 &872009841 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 872009839} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 76c392e42b5098c458856cdf6ecaaaa1, type: 3} m_Name: m_EditorClassIdentifier: m_FirstSelected: {fileID: 0} m_sendNavigationEvents: 1 m_DragThreshold: 10 --- !u!4 &872009842 Transform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 872009839} serializedVersion: 2 m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_ConstrainProportionsScale: 0 m_Children: [] m_Father: {fileID: 0} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} --- !u!1 &1556045504 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 1556045508} - component: {fileID: 1556045507} - component: {fileID: 1556045506} - component: {fileID: 1556045505} m_Layer: 0 m_Name: Canvas m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!114 &1556045505 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1556045504} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: dc42784cf147c0c48a680349fa168899, type: 3} m_Name: m_EditorClassIdentifier: m_IgnoreReversedGraphics: 1 m_BlockingObjects: 0 m_BlockingMask: serializedVersion: 2 m_Bits: 4294967295 --- !u!114 &1556045506 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1556045504} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 0cd44c1031e13a943bb63640046fad76, type: 3} m_Name: m_EditorClassIdentifier: m_UiScaleMode: 0 m_ReferencePixelsPerUnit: 100 m_ScaleFactor: 1 m_ReferenceResolution: {x: 800, y: 600} m_ScreenMatchMode: 0 m_MatchWidthOrHeight: 0 m_PhysicalUnit: 3 m_FallbackScreenDPI: 96 m_DefaultSpriteDPI: 96 m_DynamicPixelsPerUnit: 1 m_PresetInfoIsWorld: 0 --- !u!223 &1556045507 Canvas: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1556045504} m_Enabled: 1 serializedVersion: 3 m_RenderMode: 0 m_Camera: {fileID: 0} m_PlaneDistance: 100 m_PixelPerfect: 0 m_ReceivesEvents: 1 m_OverrideSorting: 0 m_OverridePixelPerfect: 0 m_SortingBucketNormalizedSize: 0 m_VertexColorAlwaysGammaSpace: 0 m_AdditionalShaderChannelsFlag: 0 m_UpdateRectTransformForStandalone: 0 m_SortingLayerID: 0 m_SortingOrder: 0 m_TargetDisplay: 0 --- !u!224 &1556045508 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1556045504} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 0, y: 0, z: 0} m_ConstrainProportionsScale: 0 m_Children: - {fileID: 16537671} - {fileID: 628393010} - {fileID: 2101290654} m_Father: {fileID: 0} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 0, y: 0} m_AnchoredPosition: {x: 0, y: 0} m_SizeDelta: {x: 0, y: 0} m_Pivot: {x: 0, y: 0} --- !u!1 &1584557231 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 1584557232} - component: {fileID: 1584557234} - component: {fileID: 1584557233} m_Layer: 0 m_Name: Text m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!224 &1584557232 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1584557231} m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_ConstrainProportionsScale: 0 m_Children: [] m_Father: {fileID: 16537671} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 0} m_AnchorMax: {x: 1, y: 1} m_AnchoredPosition: {x: 0, y: 0} m_SizeDelta: {x: 0, y: 0} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &1584557233 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1584557231} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3} m_Name: m_EditorClassIdentifier: m_Material: {fileID: 0} m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} m_RaycastTarget: 1 m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} m_Maskable: 1 m_OnCullStateChanged: m_PersistentCalls: m_Calls: [] m_FontData: m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0} m_FontSize: 14 m_FontStyle: 0 m_BestFit: 0 m_MinSize: 10 m_MaxSize: 40 m_Alignment: 4 m_AlignByGeometry: 0 m_RichText: 1 m_HorizontalOverflow: 0 m_VerticalOverflow: 0 m_LineSpacing: 1 m_Text: 'Start ' --- !u!222 &1584557234 CanvasRenderer: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1584557231} m_CullTransparentMesh: 0 --- !u!1 &2101290653 GameObject: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} serializedVersion: 6 m_Component: - component: {fileID: 2101290654} - component: {fileID: 2101290656} - component: {fileID: 2101290655} m_Layer: 0 m_Name: Text m_TagString: Untagged m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 m_IsActive: 1 --- !u!224 &2101290654 RectTransform: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 2101290653} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} m_LocalScale: {x: 1, y: 1, z: 1} m_ConstrainProportionsScale: 0 m_Children: [] m_Father: {fileID: 1556045508} m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0.5, y: 0.5} m_AnchorMax: {x: 0.5, y: 0.5} m_AnchoredPosition: {x: 1.5, y: -61.4} m_SizeDelta: {x: 588.7, y: 398.7} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &2101290655 MonoBehaviour: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 2101290653} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 11500000, guid: 5f7201a12d95ffc409449d95f23cf332, type: 3} m_Name: m_EditorClassIdentifier: m_Material: {fileID: 0} m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1} m_RaycastTarget: 1 m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0} m_Maskable: 1 m_OnCullStateChanged: m_PersistentCalls: m_Calls: [] m_FontData: m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0} m_FontSize: 14 m_FontStyle: 0 m_BestFit: 0 m_MinSize: 10 m_MaxSize: 40 m_Alignment: 0 m_AlignByGeometry: 0 m_RichText: 1 m_HorizontalOverflow: 0 m_VerticalOverflow: 0 m_LineSpacing: 1 m_Text: New Text --- !u!222 &2101290656 CanvasRenderer: m_ObjectHideFlags: 0 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 2101290653} m_CullTransparentMesh: 0 --- !u!1660057539 &9223372036854775807 SceneRoots: m_ObjectHideFlags: 0 m_Roots: - {fileID: 519420032} - {fileID: 518730350} - {fileID: 872009842} - {fileID: 1556045508} ================================================ FILE: src/UniTask/Assets/Scenes/SandboxMain.unity.meta ================================================ fileFormatVersion: 2 guid: 2cda990e2423bbf4892e6590ba056729 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Scenes/WaitWhileTest.cs ================================================ using Cysharp.Threading.Tasks; using System; using System.Collections; using System.Collections.Generic; using System.Threading; using UnityEngine; // https://github.com/Cysharp/UniTask/issues/617 public class WaitWhileTest : MonoBehaviour { private const float c_CallInterval = 0.3f; private float m_JustBeforeCallTime; private TaskObj m_TestObj; // Start is called before the first frame update void Start() { m_JustBeforeCallTime = Time.unscaledTime; m_TestObj = new TaskObj(); // m_TestObj.Test(CancellationToken.None).Forget(); } // Update is called once per frame void Update() { if (Time.unscaledTime - m_JustBeforeCallTime > c_CallInterval) { m_JustBeforeCallTime = Time.unscaledTime; m_TestObj.Test(CancellationToken.None).Forget(); } } } public class TaskObj { private CancellationTokenSource m_CancelTokenSource; private const float c_FinishElapsedTime = 0.1f; private float m_StartTime; public async UniTask Test(CancellationToken token) { try { CancelAndDisposeTokenSource(); m_CancelTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token); m_StartTime = Time.unscaledTime; await UniTask.WaitWhile(IsContinued, cancellationToken: m_CancelTokenSource.Token, cancelImmediately: true); Debug.Log("Task Finished"); } catch (OperationCanceledException) { Debug.LogWarning("Task Canceled"); } finally { CancelAndDisposeTokenSource(); } } private void CancelAndDisposeTokenSource() { m_CancelTokenSource?.Cancel(); m_CancelTokenSource?.Dispose(); m_CancelTokenSource = null; } private bool IsContinued() { return Time.unscaledTime - m_StartTime > c_FinishElapsedTime; } } ================================================ FILE: src/UniTask/Assets/Scenes/WaitWhileTest.cs.meta ================================================ fileFormatVersion: 2 guid: a478e5f6126dc184ca902adfb35401b4 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Scenes.meta ================================================ fileFormatVersion: 2 guid: 3e4672a57ce755a44805bc58b4ddea29 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/StreamingAssets/test.txt ================================================ MyTEST ================================================ FILE: src/UniTask/Assets/StreamingAssets/test.txt.meta ================================================ fileFormatVersion: 2 guid: 7fc83f79aef22a2449d5e9ca4964b2e0 DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/StreamingAssets.meta ================================================ fileFormatVersion: 2 guid: 7bb6ff9f1f0d0cd4da5ba7623f10dd6b folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/TempAsm/FooMonoBehaviour.cs ================================================ using Cysharp.Threading.Tasks; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.Networking; public class FooMonoBehaviour : MonoBehaviour { // Start is called before the first frame update void Start() { } //private async UniTask Download(UnityWebRequest req, string filePath) //{ // _ = req.SendWebRequest(); // // var aaa = await foo; // // Debug.Log(aaa); // await UniTask.Yield(); // //File.WriteAllText(filePath, req.downloadHandler.text ?? string.Empty); //} } ================================================ FILE: src/UniTask/Assets/TempAsm/FooMonoBehaviour.cs.meta ================================================ fileFormatVersion: 2 guid: de703bd72a8720b47b7c3d993786aaae MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/TempAsm/TempAsm.asmdef ================================================ { "name": "TempAsm", "references": [ "UniTask", "" ], "includePlatforms": [], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": false, "precompiledReferences": [], "autoReferenced": true, "defineConstraints": [], "versionDefines": [], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/TempAsm/TempAsm.asmdef.meta ================================================ fileFormatVersion: 2 guid: d076e9cb44bf59e41ab73add08e510cf AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/TempAsm.meta ================================================ fileFormatVersion: 2 guid: 56fb2352cb532934f82d1590ce377e5c folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/AsyncOperationTest.cs ================================================ using System.Collections; using System.Threading; using Cysharp.Threading.Tasks; using FluentAssertions; using NUnit.Framework; using UnityEngine; using UnityEngine.Networking; using UnityEngine.TestTools; #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member namespace Cysharp.Threading.TasksTests { public class AsyncOperationTest { [UnityTest] public IEnumerator ResourcesLoad_Completed() => UniTask.ToCoroutine(async () => { var asyncOperation = Resources.LoadAsync("sample_texture"); await asyncOperation.ToUniTask(); asyncOperation.isDone.Should().BeTrue(); asyncOperation.asset.GetType().Should().Be(typeof(Texture2D)); }); [UnityTest] public IEnumerator ResourcesLoad_CancelOnPlayerLoop() => UniTask.ToCoroutine(async () => { var cts = new CancellationTokenSource(); var task = Resources.LoadAsync("sample_texture").ToUniTask(cancellationToken: cts.Token, cancelImmediately: false); cts.Cancel(); task.Status.Should().Be(UniTaskStatus.Pending); await UniTask.NextFrame(); task.Status.Should().Be(UniTaskStatus.Canceled); }); [Test] public void ResourcesLoad_CancelImmediately() { { var cts = new CancellationTokenSource(); var task = Resources.LoadAsync("sample_texture").ToUniTask(cancellationToken: cts.Token, cancelImmediately: true); cts.Cancel(); task.Status.Should().Be(UniTaskStatus.Canceled); } } #if ENABLE_UNITYWEBREQUEST && (!UNITY_2019_1_OR_NEWER || UNITASK_WEBREQUEST_SUPPORT) [UnityTest] public IEnumerator UnityWebRequest_Completed() => UniTask.ToCoroutine(async () => { var filePath = System.IO.Path.Combine(Application.dataPath, "Tests", "Resources", "sample_texture.png"); var asyncOperation = UnityWebRequest.Get($"file://{filePath}").SendWebRequest(); await asyncOperation.ToUniTask(); asyncOperation.isDone.Should().BeTrue(); asyncOperation.webRequest.result.Should().Be(UnityWebRequest.Result.Success); }); [UnityTest] public IEnumerator UnityWebRequest_CancelOnPlayerLoop() => UniTask.ToCoroutine(async () => { var cts = new CancellationTokenSource(); var filePath = System.IO.Path.Combine(Application.dataPath, "Tests", "Resources", "sample_texture.png"); var task = UnityWebRequest.Get($"file://{filePath}").SendWebRequest().ToUniTask(cancellationToken: cts.Token); cts.Cancel(); task.Status.Should().Be(UniTaskStatus.Pending); await UniTask.NextFrame(); task.Status.Should().Be(UniTaskStatus.Canceled); }); [Test] public void UnityWebRequest_CancelImmediately() { var cts = new CancellationTokenSource(); cts.Cancel(); var filePath = System.IO.Path.Combine(Application.dataPath, "Tests", "Resources", "sample_texture.png"); var task = UnityWebRequest.Get($"file://{filePath}").SendWebRequest().ToUniTask(cancellationToken: cts.Token, cancelImmediately: true); task.Status.Should().Be(UniTaskStatus.Canceled); } #endif } } #endif ================================================ FILE: src/UniTask/Assets/Tests/AsyncOperationTest.cs.meta ================================================ fileFormatVersion: 2 guid: 295d574a16494d6aa4d02fcb32179e39 timeCreated: 1698887128 ================================================ FILE: src/UniTask/Assets/Tests/AsyncTest.cs ================================================ #if !(UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2) #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using UnityEngine; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using UnityEngine.UI; using UnityEngine.Scripting; using Cysharp.Threading.Tasks; using UnityEngine.SceneManagement; #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) using System.Threading.Tasks; #endif using UnityEngine.Networking; #if !UNITY_2019_3_OR_NEWER using UnityEngine.Experimental.LowLevel; #else using UnityEngine.LowLevel; #endif #if !UNITY_WSA using Unity.Jobs; #endif using Unity.Collections; using System.Threading; using NUnit.Framework; using UnityEngine.TestTools; using FluentAssertions; namespace Cysharp.Threading.TasksTests { public class AsyncTest { #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) #if !UNITY_WSA public struct MyJob : IJob { public int loopCount; public NativeArray inOut; public int result; public void Execute() { result = 0; for (int i = 0; i < loopCount; i++) { result++; } inOut[0] = result; } } #if !UNITY_WEBGL [UnityTest] public IEnumerator DelayAnd() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); var time = Time.realtimeSinceStartup; Time.timeScale = 0.5f; try { await UniTask.Delay(TimeSpan.FromSeconds(3)); var elapsed = Time.realtimeSinceStartup - time; ((int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)).Should().Be(6); } finally { Time.timeScale = 1.0f; } }); #endif [UnityTest] public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () => { var time = Time.realtimeSinceStartup; Time.timeScale = 0.5f; try { await UniTask.Delay(TimeSpan.FromSeconds(3), ignoreTimeScale: true); var elapsed = Time.realtimeSinceStartup - time; ((int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)).Should().Be(3); } finally { Time.timeScale = 1.0f; } }); [UnityTest] public IEnumerator WhenAll() => UniTask.ToCoroutine(async () => { var a = UniTask.FromResult(999); var b = UniTask.Yield(PlayerLoopTiming.Update, CancellationToken.None).AsAsyncUnitUniTask(); var c = UniTask.DelayFrame(99).AsAsyncUnitUniTask(); var (a2, b2, c2) = await UniTask.WhenAll(a, b, c); a2.Should().Be(999); b2.Should().Be(AsyncUnit.Default); c2.Should().Be(AsyncUnit.Default); }); [UnityTest] public IEnumerator WhenAny() => UniTask.ToCoroutine(async () => { var a = UniTask.FromResult(999); var b = UniTask.Yield(PlayerLoopTiming.Update, CancellationToken.None).AsAsyncUnitUniTask(); var c = UniTask.DelayFrame(99).AsAsyncUnitUniTask(); var (win, a2, b2, c2) = await UniTask.WhenAny(a, b, c); win.Should().Be(0); a2.Should().Be(999); }); [UnityTest] public IEnumerator BothEnumeratorCheck() => UniTask.ToCoroutine(async () => { await ToaruCoroutineEnumerator(); // wait 5 frame:) }); //[UnityTest] //public IEnumerator JobSystem() => UniTask.ToCoroutine(async () => //{ // var job = new MyJob() { loopCount = 999, inOut = new NativeArray(1, Allocator.TempJob) }; // JobHandle.ScheduleBatchedJobs(); // await job.Schedule(); // job.inOut[0].Should().Be(999); // job.inOut.Dispose(); //}); class MyMyClass { public int MyProperty { get; set; } } class MyBooleanClass { public bool MyProperty { get; set; } } [UnityTest] public IEnumerator WaitUntil() => UniTask.ToCoroutine(async () => { bool t = false; UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(() => t = true).Forget(); var startFrame = Time.frameCount; await UniTask.WaitUntil(() => t, PlayerLoopTiming.EarlyUpdate); var diff = Time.frameCount - startFrame; diff.Should().Be(11); }); [UnityTest] public IEnumerator WaitUntilWithState() => UniTask.ToCoroutine(async () => { var v = new MyBooleanClass { MyProperty = false }; UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(() => v.MyProperty = true).Forget(); var startFrame = Time.frameCount; await UniTask.WaitUntil(v, static v => v.MyProperty, PlayerLoopTiming.EarlyUpdate); var diff = Time.frameCount - startFrame; diff.Should().Be(11); }); [UnityTest] public IEnumerator WaitWhile() => UniTask.ToCoroutine(async () => { bool t = true; UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(() => t = false).Forget(); var startFrame = Time.frameCount; await UniTask.WaitWhile(() => t, PlayerLoopTiming.EarlyUpdate); var diff = Time.frameCount - startFrame; diff.Should().Be(11); }); [UnityTest] public IEnumerator WaitWhileWithState() => UniTask.ToCoroutine(async () => { var v = new MyBooleanClass { MyProperty = true }; UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(() => v.MyProperty = false).Forget(); var startFrame = Time.frameCount; await UniTask.WaitWhile(v, static v => v.MyProperty, PlayerLoopTiming.EarlyUpdate); var diff = Time.frameCount - startFrame; diff.Should().Be(11); }); [UnityTest] public IEnumerator WaitUntilValueChanged() => UniTask.ToCoroutine(async () => { var v = new MyMyClass { MyProperty = 99 }; UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(() => v.MyProperty = 1000).Forget(); var startFrame = Time.frameCount; await UniTask.WaitUntilValueChanged(v, x => x.MyProperty, PlayerLoopTiming.EarlyUpdate); var diff = Time.frameCount - startFrame; diff.Should().Be(11); }); #if !UNITY_WEBGL [UnityTest] public IEnumerator SwitchTo() => UniTask.ToCoroutine(async () => { await UniTask.Yield(); var currentThreadId = Thread.CurrentThread.ManagedThreadId; await UniTask.SwitchToThreadPool(); //await UniTask.SwitchToThreadPool(); //await UniTask.SwitchToThreadPool(); var switchedThreadId = Thread.CurrentThread.ManagedThreadId; currentThreadId.Should().NotBe(switchedThreadId); await UniTask.Yield(); var switchedThreadId2 = Thread.CurrentThread.ManagedThreadId; currentThreadId.Should().Be(switchedThreadId2); }); #endif //[UnityTest] //public IEnumerator ObservableConversion() => UniTask.ToCoroutine(async () => //{ // var v = await Observable.Range(1, 10).ToUniTask(); // v.Is(10); // v = await Observable.Range(1, 10).ToUniTask(useFirstValue: true); // v.Is(1); // v = await UniTask.DelayFrame(10).ToObservable().ToTask(); // v.Is(10); // v = await UniTask.FromResult(99).ToObservable(); // v.Is(99); //}); //[UnityTest] //public IEnumerator AwaitableReactiveProperty() => UniTask.ToCoroutine(async () => //{ // var rp1 = new ReactiveProperty(99); // UniTask.DelayFrame(100).ContinueWith(x => rp1.Value = x).Forget(); // await rp1; // rp1.Value.Is(100); // // var delay2 = UniTask.DelayFrame(10); // // var (a, b ) = await UniTask.WhenAll(rp1.WaitUntilValueChangedAsync(), delay2); //}); //[UnityTest] //public IEnumerator AwaitableReactiveCommand() => UniTask.ToCoroutine(async () => //{ // var rc = new ReactiveCommand(); // UniTask.DelayFrame(100).ContinueWith(x => rc.Execute(x)).Forget(); // var v = await rc; // v.Is(100); //}); [UnityTest] public IEnumerator ExceptionlessCancellation() => UniTask.ToCoroutine(async () => { var cts = new CancellationTokenSource(); UniTask.DelayFrame(10).ContinueWith(() => cts.Cancel()).Forget(); var first = Time.frameCount; var canceled = await UniTask.DelayFrame(100, cancellationToken: cts.Token).SuppressCancellationThrow(); var r = (Time.frameCount - first); (9 < r && r < 11).Should().BeTrue(); canceled.Should().Be(true); }); [UnityTest] public IEnumerator ExceptionCancellation() => UniTask.ToCoroutine(async () => { var cts = new CancellationTokenSource(); UniTask.DelayFrame(10).ContinueWith(() => cts.Cancel()).Forget(); bool occur = false; try { await UniTask.DelayFrame(100, cancellationToken: cts.Token); } catch (OperationCanceledException) { occur = true; } occur.Should().BeTrue(); }); IEnumerator ToaruCoroutineEnumerator() { yield return null; yield return null; yield return null; yield return null; yield return null; } //[UnityTest] //public IEnumerator ExceptionUnobserved1() => UniTask.ToCoroutine(async () => //{ // bool calledEx = false; // Action action = exx => // { // calledEx = true; // exx.Message.Should().Be("MyException"); // }; // UniTaskScheduler.UnobservedTaskException += action; // var ex = InException1(); // ex = default(UniTask); // await UniTask.DelayFrame(3); // GC.Collect(); // GC.WaitForPendingFinalizers(); // GC.Collect(); // await UniTask.DelayFrame(1); // calledEx.Should().BeTrue(); // UniTaskScheduler.UnobservedTaskException -= action; //}); [UnityTest] public IEnumerator ExceptionUnobserved2() => UniTask.ToCoroutine(async () => { bool calledEx = false; Action action = exx => { calledEx = true; exx.Message.Should().Be("MyException"); }; UniTaskScheduler.UnobservedTaskException += action; var ex = InException2(); ex = default(UniTask); await UniTask.DelayFrame(3); GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); await UniTask.DelayFrame(1); calledEx.Should().BeTrue(); UniTaskScheduler.UnobservedTaskException -= action; }); // can not run on RuntimeUnitTestToolkit so ignore... // [UnityTest] // public IEnumerator ThrowExceptionUnawaited() => UniTask.ToCoroutine(async () => // { // LogAssert.Expect(LogType.Exception, "Exception: MyException"); //#pragma warning disable 1998 // async UniTask Throw() => throw new Exception("MyException"); //#pragma warning restore 1998 //#pragma warning disable 4014 // Throw(); //#pragma warning restore 4014 // await UniTask.DelayFrame(3); // GC.Collect(); // GC.WaitForPendingFinalizers(); // GC.Collect(); // await UniTask.DelayFrame(1); // }); async UniTask InException1() { await UniTask.Yield(); throw new Exception("MyException"); } async UniTask InException2() { await UniTask.Yield(); throw new Exception("MyException"); } [UnityTest] public IEnumerator NextFrame1() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.LastUpdate); var frame = Time.frameCount; await UniTask.NextFrame(); Time.frameCount.Should().Be(frame + 1); }); [UnityTest] public IEnumerator NextFrame2() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.PreUpdate); var frame = Time.frameCount; await UniTask.NextFrame(); Time.frameCount.Should().Be(frame + 1); }); [UnityTest] public IEnumerator NestedEnumerator() => UniTask.ToCoroutine(async () => { var time = Time.realtimeSinceStartup; await ParentCoroutineEnumerator(); var elapsed = Time.realtimeSinceStartup - time; ((int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)).Should().Be(3); }); IEnumerator ParentCoroutineEnumerator() { yield return ChildCoroutineEnumerator(); } IEnumerator ChildCoroutineEnumerator() { yield return new WaitForSeconds(3); } [UnityTest] public IEnumerator ToObservable() => UniTask.ToCoroutine(async () => { var completedTaskObserver = new ToObservableObserver(); completedTaskObserver.OnNextCalled.Should().BeFalse(); completedTaskObserver.OnCompletedCalled.Should().BeFalse(); completedTaskObserver.OnErrorCalled.Should().BeFalse(); UniTask.CompletedTask.ToObservable().Subscribe(completedTaskObserver); completedTaskObserver.OnNextCalled.Should().BeTrue(); completedTaskObserver.OnCompletedCalled.Should().BeTrue(); completedTaskObserver.OnErrorCalled.Should().BeFalse(); var delayFrameTaskObserver = new ToObservableObserver(); UniTask.DelayFrame(1).ToObservable().Subscribe(delayFrameTaskObserver); delayFrameTaskObserver.OnNextCalled.Should().BeFalse(); delayFrameTaskObserver.OnCompletedCalled.Should().BeFalse(); delayFrameTaskObserver.OnErrorCalled.Should().BeFalse(); await UniTask.DelayFrame(1); delayFrameTaskObserver.OnNextCalled.Should().BeTrue(); delayFrameTaskObserver.OnCompletedCalled.Should().BeTrue(); delayFrameTaskObserver.OnErrorCalled.Should().BeFalse(); }); class ToObservableObserver : IObserver { public bool OnNextCalled { get; private set; } public bool OnCompletedCalled { get; private set; } public bool OnErrorCalled { get; private set; } public void OnNext(T value) => OnNextCalled = true; public void OnCompleted() => OnCompletedCalled = true; public void OnError(Exception error) => OnErrorCalled = true; } #endif #endif } } #endif ================================================ FILE: src/UniTask/Assets/Tests/AsyncTest.cs.meta ================================================ fileFormatVersion: 2 guid: 5e9960810a8f0634cb4aea38c563d947 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/CachelikeTest.cs ================================================ using Cysharp.Threading.Tasks; using Cysharp.Threading.Tasks.Linq; using FluentAssertions; using NUnit.Framework; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using UnityEngine; using UnityEngine.TestTools; namespace Cysharp.Threading.TasksTests { public class Cachelike { [UnityTest] public IEnumerator Check() => UniTask.ToCoroutine(async () => { { var v = await CachedCheck("foo", 10); v.Should().Be(10); var v2 = await CachedCheck("bar", 20); v2.Should().Be(20); var v3 = await CachedCheck("baz", 30); v3.Should().Be(30); } { var v = await CachedCheck("foo", 10); v.Should().Be(10); var v2 = await CachedCheck("bar", 20); v2.Should().Be(20); var v3 = await CachedCheck("baz", 30); v3.Should().Be(30); } { var v = CachedCheck("foo", 10); var v2 = CachedCheck("bar", 20); var v3 = CachedCheck("baz", 30); (await v).Should().Be(10); (await v2).Should().Be(20); (await v3).Should().Be(30); } { var v = CachedCheck("foo", 10, true); var v2 = CachedCheck("bar", 20, true); var v3 = CachedCheck("baz", 30, true); (await v).Should().Be(10); (await v2).Should().Be(20); (await v3).Should().Be(30); } }); static Dictionary cacheDict = new Dictionary(); async UniTask CachedCheck(string cache, int value, bool yield = false) { if (!cacheDict.ContainsKey(cache)) { await UniTask.Yield(); } if (yield) { await UniTask.Yield(); } if (cacheDict.TryGetValue(cache, out var v)) { return v; } cacheDict.Add(cache, value); return value; } } } ================================================ FILE: src/UniTask/Assets/Tests/CachelikeTest.cs.meta ================================================ fileFormatVersion: 2 guid: 416e0e77b4408b0498792eb218ed2870 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/CoroutineToUniTaskTest.cs ================================================ #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using UnityEngine; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using UnityEngine.UI; using UnityEngine.Scripting; using Cysharp.Threading.Tasks; using Unity.Collections; using System.Threading; using NUnit.Framework; using UnityEngine.TestTools; using FluentAssertions; namespace Cysharp.Threading.TasksTests { public class CoroutineToUniTaskTest { [UnityTest] public IEnumerator EarlyUpdate() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.EarlyUpdate); var l = new List<(int, int)>(); var currentFrame = Time.frameCount; var t = Worker(l).ToUniTask(); l.Count.Should().Be(1); l[0].Should().Be((0, currentFrame)); await t; l[1].Should().Be((1, Time.frameCount)); l[1].Item2.Should().NotBe(currentFrame); }); [UnityTest] public IEnumerator LateUpdate() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); var l = new List<(int, int)>(); var currentFrame = Time.frameCount; var t = Worker(l).ToUniTask(); l.Count.Should().Be(1); l[0].Should().Be((0, currentFrame)); await t; l[1].Should().Be((1, Time.frameCount)); l[1].Item2.Should().NotBe(currentFrame); }); //[UnityTest] //public IEnumerator TestCoroutine() //{ // yield return UniTask.Yield(PlayerLoopTiming.EarlyUpdate).ToUniTask().ToCoroutine(); // var nanika = (UnityEngine.MonoBehaviour)GameObject.FindObjectOfType(typeof(UnityEngine.MonoBehaviour)); // var l = new List<(int, int)>(); // var currentFrame = Time.frameCount; // var t = nanika.StartCoroutine(Worker(l)); // l.Count.Should().Be(1); // l[0].Should().Be((0, currentFrame)); // yield return t; // l[1].Should().Be((1, Time.frameCount)); // l[1].Item2.Should().NotBe(currentFrame); //} //[UnityTest] //public IEnumerator TestCoroutine2() //{ // yield return UniTask.Yield(PlayerLoopTiming.PostLateUpdate).ToUniTask().ToCoroutine(); // var nanika = (UnityEngine.MonoBehaviour)GameObject.FindObjectOfType(typeof(UnityEngine.MonoBehaviour)); // var l = new List<(int, int)>(); // var currentFrame = Time.frameCount; // var t = nanika.StartCoroutine(Worker(l)); // l.Count.Should().Be(1); // l[0].Should().Be((0, currentFrame)); // yield return t; // l[1].Should().Be((1, Time.frameCount)); // l[1].Item2.Should().NotBe(currentFrame); //} [UnityTest] public IEnumerator ImmediateRunTest() => UniTask.ToCoroutine(async () => { var l = new List(); var x1 = Immediate(l); var x2 = Immediate(l); var x3 = DelayOne(l); var t1 = x1.ToUniTask(); CollectionAssert.AreEqual(l, new[] { 1, 2, 3 }); await t1; var t2 = x2.ToUniTask(); CollectionAssert.AreEqual(l, new[] { 1, 2, 3, 1, 2, 3 }); var t3 = x3.ToUniTask(); CollectionAssert.AreEqual(l, new[] { 1, 2, 3, 1, 2, 3, 10 }); await UniTask.WhenAll(t2, t3); CollectionAssert.AreEqual(l, new[] { 1, 2, 3, 1, 2, 3, 10, 20, 30 }); }); IEnumerator Immediate(List l) { l.Add(1); l.Add(2); l.Add(3); yield break; } IEnumerator DelayOne(List l) { l.Add(10); yield return null; l.Add(20); l.Add(30); } #if !UNITY_WEBGL [UnityTest] public IEnumerator WaitForSecondsTest() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); Time.timeScale = 0.5f; try { var now = DateTimeOffset.UtcNow; await WaitFor(); var elapsed = DateTimeOffset.UtcNow - now; (5.8f <= elapsed.TotalSeconds && elapsed.TotalSeconds <= 6.2f).Should().BeTrue(); } finally { Time.timeScale = 1.0f; } }); IEnumerator WaitFor() { yield return new WaitForSeconds(3.0f); } #endif IEnumerator Worker(List<(int, int)> l) { l.Add((0, Time.frameCount)); yield return null; l.Add((1, Time.frameCount)); } public async UniTask Foo() { var tasks = new List(); var t = Bar(); tasks.Add(t); t = Bar(); tasks.Add(t); await UniTask.WhenAll(tasks); } public async UniTask Bar() { await UniTask.Yield(); return default(T); } } } #endif ================================================ FILE: src/UniTask/Assets/Tests/CoroutineToUniTaskTest.cs.meta ================================================ fileFormatVersion: 2 guid: 43ffb719370515746932af3732ce073e MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/DelayTest.cs ================================================ #pragma warning disable CS0618 using Cysharp.Threading.Tasks; using Cysharp.Threading.Tasks.Linq; using FluentAssertions; using NUnit.Framework; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using UnityEngine; using UnityEngine.TestTools; namespace Cysharp.Threading.TasksTests { public class DelayTest { [UnityTest] public IEnumerator DelayFrame() => UniTask.ToCoroutine(async () => { for (int i = 1; i < 5; i++) { await UniTask.Yield(PlayerLoopTiming.PreUpdate); var frameCount = Time.frameCount; await UniTask.DelayFrame(i); Time.frameCount.Should().Be(frameCount + i); } for (int i = 1; i < 5; i++) { await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); var frameCount = Time.frameCount; await UniTask.DelayFrame(i); Time.frameCount.Should().Be(frameCount + i); } }); [UnityTest] public IEnumerator DelayFrameZero() => UniTask.ToCoroutine(async () => { { await UniTask.Yield(PlayerLoopTiming.PreUpdate); var frameCount = Time.frameCount; await UniTask.DelayFrame(0); Time.frameCount.Should().Be(frameCount); // same frame } { await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); var frameCount = Time.frameCount; await UniTask.DelayFrame(0); Time.frameCount.Should().Be(frameCount + 1); // next frame } }); [UnityTest] public IEnumerator TimerFramePre() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.PreUpdate); var initialFrame = Time.frameCount; var xs = await UniTaskAsyncEnumerable.TimerFrame(2, 3).Take(5).Select(_ => Time.frameCount).ToArrayAsync(); xs[0].Should().Be(initialFrame + 2); xs[1].Should().Be(initialFrame + 2 + (3 * 1)); xs[2].Should().Be(initialFrame + 2 + (3 * 2)); xs[3].Should().Be(initialFrame + 2 + (3 * 3)); xs[4].Should().Be(initialFrame + 2 + (3 * 4)); }); [UnityTest] public IEnumerator TimerFramePost() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); var initialFrame = Time.frameCount; var xs = await UniTaskAsyncEnumerable.TimerFrame(2, 3).Take(5).Select(_ => Time.frameCount).ToArrayAsync(); xs[0].Should().Be(initialFrame + 2); xs[1].Should().Be(initialFrame + 2 + (3 * 1)); xs[2].Should().Be(initialFrame + 2 + (3 * 2)); xs[3].Should().Be(initialFrame + 2 + (3 * 3)); xs[4].Should().Be(initialFrame + 2 + (3 * 4)); }); [UnityTest] public IEnumerator TimerFrameTest() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.PreUpdate); var initialFrame = Time.frameCount; var xs = await UniTaskAsyncEnumerable.TimerFrame(0, 0).Take(5).Select(_ => Time.frameCount).ToArrayAsync(); xs[0].Should().Be(initialFrame); xs[1].Should().Be(initialFrame + 1); xs[2].Should().Be(initialFrame + 2); xs[3].Should().Be(initialFrame + 3); xs[4].Should().Be(initialFrame + 4); }); [UnityTest] public IEnumerator TimerFrameSinglePre() => UniTask.ToCoroutine(async () => { { await UniTask.Yield(PlayerLoopTiming.PreUpdate); var initialFrame = Time.frameCount; var xs = await UniTaskAsyncEnumerable.TimerFrame(0).Select(_ => Time.frameCount).ToArrayAsync(); xs[0].Should().Be(initialFrame); } { await UniTask.Yield(PlayerLoopTiming.PreUpdate); var initialFrame = Time.frameCount; var xs = await UniTaskAsyncEnumerable.TimerFrame(1).Select(_ => { var t = Time.frameCount; return t; }).ToArrayAsync(); xs[0].Should().Be(initialFrame + 1); } { await UniTask.Yield(PlayerLoopTiming.PreUpdate); var initialFrame = Time.frameCount; var xs = await UniTaskAsyncEnumerable.TimerFrame(2).Select(_ => Time.frameCount).ToArrayAsync(); xs[0].Should().Be(initialFrame + 2); } }); [UnityTest] public IEnumerator TimerFrameSinglePost() => UniTask.ToCoroutine(async () => { { //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); //var initialFrame = Time.frameCount; //var xs = await UniTaskAsyncEnumerable.TimerFrame(0).Select(_ => Time.frameCount).ToArrayAsync(); //xs[0].Should().Be(initialFrame); } { //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); var initialFrame = Time.frameCount; var xs = await UniTaskAsyncEnumerable.TimerFrame(1).Select(_ => Time.frameCount).ToArrayAsync(); xs[0].Should().Be(initialFrame + 1); } { //await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); var initialFrame = Time.frameCount; var xs = await UniTaskAsyncEnumerable.TimerFrame(2).Select(_ => Time.frameCount).ToArrayAsync(); xs[0].Should().Be(initialFrame + 2); } }); [UnityTest] public IEnumerator Timer() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.PreUpdate); { var initialSeconds = Time.realtimeSinceStartup; var xs = await UniTaskAsyncEnumerable.Timer(TimeSpan.FromSeconds(2)).Select(_ => Time.realtimeSinceStartup).ToArrayAsync(); Mathf.Approximately(initialSeconds, xs[0]).Should().BeFalse(); Debug.Log("Init:" + initialSeconds); Debug.Log("After:" + xs[0]); } }); #if !UNITY_WEBGL [UnityTest] public IEnumerator DelayInThreadPool() => UniTask.ToCoroutine(async () => { await UniTask.Run(async () => { await UniTask.Delay(TimeSpan.FromSeconds(2)); }); }); #endif [UnityTest] public IEnumerator DelayRealtime() => UniTask.ToCoroutine(async () => { var now = DateTimeOffset.UtcNow; await UniTask.Delay(TimeSpan.FromSeconds(2), DelayType.Realtime); var elapsed = DateTimeOffset.UtcNow - now; var okay1 = TimeSpan.FromSeconds(1.80) <= elapsed; var okay2 = elapsed <= TimeSpan.FromSeconds(2.20); okay1.Should().Be(true); okay2.Should().Be(true); }); [UnityTest] public IEnumerator LoopTest() => UniTask.ToCoroutine(async () => { for (int i = 0; i < 20; ++i) { UniTask.DelayFrame(100).Forget(); await UniTask.DelayFrame(1); } }); } } ================================================ FILE: src/UniTask/Assets/Tests/DelayTest.cs.meta ================================================ fileFormatVersion: 2 guid: 1376b93d9e1083a4a9b4081e08f3a7b7 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Editor/AsyncTestEditor.cs ================================================ //#if !(UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2) //#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member //using UnityEngine; //using System; //using System.Collections; //using System.Collections.Generic; //using System.Linq; //using System.Text; //using UnityEngine.UI; //using UnityEngine.Scripting; //using Cysharp.Threading.Tasks; //using UnityEngine.SceneManagement; //#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) //using System.Threading.Tasks; //#endif //using UnityEngine.Networking; //#if !UNITY_2019_3_OR_NEWER //using UnityEngine.Experimental.LowLevel; //#else //using UnityEngine.LowLevel; //#endif //#if !UNITY_WSA //using Unity.Jobs; //#endif //using Unity.Collections; //using System.Threading; //using NUnit.Framework; //using UnityEngine.TestTools; //using FluentAssertions; //namespace Cysharp.Threading.TasksTests //{ // public class AsyncTest // { //#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) //#if !UNITY_WSA // public struct MyJob : IJob // { // public int loopCount; // public NativeArray inOut; // public int result; // public void Execute() // { // result = 0; // for (int i = 0; i < loopCount; i++) // { // result++; // } // inOut[0] = result; // } // } // [UnityTest] // public IEnumerator DelayAnd() => UniTask.ToCoroutine(async () => // { // await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); // var time = Time.realtimeSinceStartup; // Time.timeScale = 0.5f; // try // { // await UniTask.Delay(TimeSpan.FromSeconds(3)); // var elapsed = Time.realtimeSinceStartup - time; // ((int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)).Should().Be(6); // } // finally // { // Time.timeScale = 1.0f; // } // }); // [UnityTest] // public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () => // { // var time = Time.realtimeSinceStartup; // Time.timeScale = 0.5f; // try // { // await UniTask.Delay(TimeSpan.FromSeconds(3), ignoreTimeScale: true); // var elapsed = Time.realtimeSinceStartup - time; // ((int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)).Should().Be(3); // } // finally // { // Time.timeScale = 1.0f; // } // }); // [UnityTest] // public IEnumerator WhenAll() => UniTask.ToCoroutine(async () => // { // var a = UniTask.FromResult(999); // var b = UniTask.Yield(PlayerLoopTiming.Update, CancellationToken.None).AsAsyncUnitUniTask(); // var c = UniTask.DelayFrame(99).AsAsyncUnitUniTask(); // var (a2, b2, c2) = await UniTask.WhenAll(a, b, c); // a2.Should().Be(999); // b2.Should().Be(AsyncUnit.Default); // c2.Should().Be(AsyncUnit.Default); // }); // [UnityTest] // public IEnumerator WhenAny() => UniTask.ToCoroutine(async () => // { // var a = UniTask.FromResult(999); // var b = UniTask.Yield(PlayerLoopTiming.Update, CancellationToken.None).AsAsyncUnitUniTask(); // var c = UniTask.DelayFrame(99).AsAsyncUnitUniTask(); // var (win, a2, b2, c2) = await UniTask.WhenAny(a, b, c); // win.Should().Be(0); // a2.Should().Be(999); // }); // [UnityTest] // public IEnumerator BothEnumeratorCheck() => UniTask.ToCoroutine(async () => // { // await ToaruCoroutineEnumerator(); // wait 5 frame:) // }); // [UnityTest] // public IEnumerator JobSystem() => UniTask.ToCoroutine(async () => // { // var job = new MyJob() { loopCount = 999, inOut = new NativeArray(1, Allocator.TempJob) }; // JobHandle.ScheduleBatchedJobs(); // await job.Schedule(); // job.inOut[0].Should().Be(999); // job.inOut.Dispose(); // }); // class MyMyClass // { // public int MyProperty { get; set; } // } // [UnityTest] // public IEnumerator WaitUntil() => UniTask.ToCoroutine(async () => // { // bool t = false; // await UniTask.Yield(PlayerLoopTiming.PostLateUpdate); // UniTask.DelayFrame(10,PlayerLoopTiming.PostLateUpdate).ContinueWith(() => t = true).Forget(); // var startFrame = Time.frameCount; // await UniTask.WaitUntil(() => t, PlayerLoopTiming.EarlyUpdate); // var diff = Time.frameCount - startFrame; // diff.Should().Be(11); // }); // [UnityTest] // public IEnumerator WaitWhile() => UniTask.ToCoroutine(async () => // { // bool t = true; // UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(() => t = false).Forget(); // var startFrame = Time.frameCount; // await UniTask.WaitWhile(() => t, PlayerLoopTiming.EarlyUpdate); // var diff = Time.frameCount - startFrame; // diff.Should().Be(11); // }); // [UnityTest] // public IEnumerator WaitUntilValueChanged() => UniTask.ToCoroutine(async () => // { // var v = new MyMyClass { MyProperty = 99 }; // UniTask.DelayFrame(10, PlayerLoopTiming.PostLateUpdate).ContinueWith(() => v.MyProperty = 1000).Forget(); // var startFrame = Time.frameCount; // await UniTask.WaitUntilValueChanged(v, x => x.MyProperty, PlayerLoopTiming.EarlyUpdate); // var diff = Time.frameCount - startFrame; // diff.Should().Be(11); // }); // [UnityTest] // public IEnumerator SwitchTo() => UniTask.ToCoroutine(async () => // { // await UniTask.Yield(); // var currentThreadId = Thread.CurrentThread.ManagedThreadId; // await UniTask.SwitchToThreadPool(); // //await UniTask.SwitchToThreadPool(); // //await UniTask.SwitchToThreadPool(); // var switchedThreadId = Thread.CurrentThread.ManagedThreadId; // currentThreadId.Should().NotBe(switchedThreadId); // await UniTask.Yield(); // var switchedThreadId2 = Thread.CurrentThread.ManagedThreadId; // currentThreadId.Should().Be(switchedThreadId2); // }); // //[UnityTest] // //public IEnumerator ObservableConversion() => UniTask.ToCoroutine(async () => // //{ // // var v = await Observable.Range(1, 10).ToUniTask(); // // v.Is(10); // // v = await Observable.Range(1, 10).ToUniTask(useFirstValue: true); // // v.Is(1); // // v = await UniTask.DelayFrame(10).ToObservable().ToTask(); // // v.Is(10); // // v = await UniTask.FromResult(99).ToObservable(); // // v.Is(99); // //}); // //[UnityTest] // //public IEnumerator AwaitableReactiveProperty() => UniTask.ToCoroutine(async () => // //{ // // var rp1 = new ReactiveProperty(99); // // UniTask.DelayFrame(100).ContinueWith(x => rp1.Value = x).Forget(); // // await rp1; // // rp1.Value.Is(100); // // // var delay2 = UniTask.DelayFrame(10); // // // var (a, b ) = await UniTask.WhenAll(rp1.WaitUntilValueChangedAsync(), delay2); // //}); // //[UnityTest] // //public IEnumerator AwaitableReactiveCommand() => UniTask.ToCoroutine(async () => // //{ // // var rc = new ReactiveCommand(); // // UniTask.DelayFrame(100).ContinueWith(x => rc.Execute(x)).Forget(); // // var v = await rc; // // v.Is(100); // //}); // [UnityTest] // public IEnumerator ExceptionlessCancellation() => UniTask.ToCoroutine(async () => // { // var cts = new CancellationTokenSource(); // UniTask.DelayFrame(10).ContinueWith(() => cts.Cancel()).Forget(); // var first = Time.frameCount; // var canceled = await UniTask.DelayFrame(100, cancellationToken: cts.Token).SuppressCancellationThrow(); // (Time.frameCount - first).Should().Be(11); // 10 frame canceled // canceled.Should().Be(true); // }); // [UnityTest] // public IEnumerator ExceptionCancellation() => UniTask.ToCoroutine(async () => // { // var cts = new CancellationTokenSource(); // UniTask.DelayFrame(10).ContinueWith(() => cts.Cancel()).Forget(); // bool occur = false; // try // { // await UniTask.DelayFrame(100, cancellationToken: cts.Token); // } // catch (OperationCanceledException) // { // occur = true; // } // occur.Should().BeTrue(); // }); // IEnumerator ToaruCoroutineEnumerator() // { // yield return null; // yield return null; // yield return null; // yield return null; // yield return null; // } // [UnityTest] // public IEnumerator ExceptionUnobserved1() => UniTask.ToCoroutine(async () => // { // bool calledEx = false; // Action action = exx => // { // calledEx = true; // exx.Message.Should().Be("MyException"); // }; // UniTaskScheduler.UnobservedTaskException += action; // var ex = InException1(); // ex = default(UniTask); // await UniTask.DelayFrame(3); // GC.Collect(); // GC.WaitForPendingFinalizers(); // GC.Collect(); // await UniTask.DelayFrame(1); // calledEx.Should().BeTrue(); // UniTaskScheduler.UnobservedTaskException -= action; // }); // [UnityTest] // public IEnumerator ExceptionUnobserved2() => UniTask.ToCoroutine(async () => // { // bool calledEx = false; // Action action = exx => // { // calledEx = true; // exx.Message.Should().Be("MyException"); // }; // UniTaskScheduler.UnobservedTaskException += action; // var ex = InException2(); // ex = default(UniTask); // await UniTask.DelayFrame(3); // GC.Collect(); // GC.WaitForPendingFinalizers(); // GC.Collect(); // await UniTask.DelayFrame(1); // calledEx.Should().BeTrue(); // UniTaskScheduler.UnobservedTaskException -= action; // }); // async UniTask InException1() // { // await UniTask.Yield(); // throw new Exception("MyException"); // } // async UniTask InException2() // { // await UniTask.Yield(); // throw new Exception("MyException"); // } // [UnityTest] // public IEnumerator NestedEnumerator() => UniTask.ToCoroutine(async () => // { // var time = Time.realtimeSinceStartup; // await ParentCoroutineEnumerator(); // var elapsed = Time.realtimeSinceStartup - time; // ((int)Math.Round(TimeSpan.FromSeconds(elapsed).TotalSeconds, MidpointRounding.ToEven)).Should().Be(3); // }); // IEnumerator ParentCoroutineEnumerator() // { // yield return ChildCoroutineEnumerator(); // } // IEnumerator ChildCoroutineEnumerator() // { // yield return new WaitForSeconds(3); // } //#endif //#endif // } //} //#endif ================================================ FILE: src/UniTask/Assets/Tests/Editor/AsyncTestEditor.cs.meta ================================================ fileFormatVersion: 2 guid: 851899ba3337ac24a8331cb18fabe771 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Editor/RunTestEditor.cs ================================================ //#if !(UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2) //#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member //using UnityEngine; //using System; //using System.Collections; //using System.Collections.Generic; //using System.Linq; //using System.Text; //using UnityEngine.UI; //using UnityEngine.Scripting; //using Cysharp.Threading.Tasks; //using UnityEngine.SceneManagement; //#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) //using System.Threading.Tasks; //#endif //using UnityEngine.Networking; //#if !UNITY_2019_3_OR_NEWER //using UnityEngine.Experimental.LowLevel; //#else //using UnityEngine.LowLevel; //#endif //#if !UNITY_WSA //using Unity.Jobs; //#endif //using Unity.Collections; //using System.Threading; //using NUnit.Framework; //using UnityEngine.TestTools; //using FluentAssertions; //namespace Cysharp.Threading.TasksTests //{ // public class RunTest // { //#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) //#if !UNITY_WSA // //[UnityTest] // //public IEnumerator RunThread() => UniTask.ToCoroutine(async () => // //{ // // var main = Thread.CurrentThread.ManagedThreadId; // // var v = await UniTask.Run(() => { return System.Threading.Thread.CurrentThread.ManagedThreadId; }, false); // // UnityEngine.Debug.Log("Ret Value is:" + v); // // UnityEngine.Debug.Log("Run Here and id:" + System.Threading.Thread.CurrentThread.ManagedThreadId); // // //v.Should().Be(3); // // main.Should().NotBe(Thread.CurrentThread.ManagedThreadId); // //}); // [UnityTest] // public IEnumerator RunThreadConfigure() => UniTask.ToCoroutine(async () => // { // var main = Thread.CurrentThread.ManagedThreadId; // var v = await UniTask.Run(() => 3, true); // v.Should().Be(3); // main.Should().Be(Thread.CurrentThread.ManagedThreadId); // }); // //[UnityTest] // //public IEnumerator RunThreadException() => UniTask.ToCoroutine(async () => // //{ // // var main = Thread.CurrentThread.ManagedThreadId; // // try // // { // // await UniTask.Run(() => throw new Exception(), false); // // } // // catch // // { // // main.Should().NotBe(Thread.CurrentThread.ManagedThreadId); // // } // //}); // [UnityTest] // public IEnumerator RunThreadExceptionConfigure() => UniTask.ToCoroutine(async () => // { // var main = Thread.CurrentThread.ManagedThreadId; // try // { // await UniTask.Run(() => throw new Exception(), true); // } // catch // { // main.Should().Be(Thread.CurrentThread.ManagedThreadId); // } // }); //#endif //#endif // } //} //#endif ================================================ FILE: src/UniTask/Assets/Tests/Editor/RunTestEditor.cs.meta ================================================ fileFormatVersion: 2 guid: 76d078e5d960ac2429ce67a930c29ade MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Editor/UniTask.Tests.Editor.asmdef ================================================ { "name": "UniTask.Tests.Editor", "references": [ "UnityEngine.TestRunner", "UnityEditor.TestRunner", "UniTask.Tests", "UniTask", "Unity.ResourceManager", "DOTween.Modules" ], "includePlatforms": [ "Editor" ], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": true, "precompiledReferences": [ "nunit.framework.dll", "DOTween.dll" ], "autoReferenced": false, "defineConstraints": [ "UNITY_INCLUDE_TESTS" ], "versionDefines": [], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/Tests/Editor/UniTask.Tests.Editor.asmdef.meta ================================================ fileFormatVersion: 2 guid: c2431de67d1d97a48afcaf18f333a0b4 AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Editor/WhenAnyTestEditor.cs ================================================ //#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) //#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member //using UnityEngine; //using System; //using System.Collections; //using System.Collections.Generic; //using System.Linq; //using System.Text; //using UnityEngine.UI; //using UnityEngine.Scripting; //using Cysharp.Threading.Tasks; //using Unity.Collections; //using System.Threading; //using NUnit.Framework; //using UnityEngine.TestTools; //using FluentAssertions; //namespace Cysharp.Threading.TasksTests //{ // public class WhenAnyTest // { // [UnityTest] // public IEnumerator WhenAnyCanceled() => UniTask.ToCoroutine(async () => // { // var cts = new CancellationTokenSource(); // var successDelayTask = UniTask.Delay(TimeSpan.FromSeconds(1)); // var cancelTask = UniTask.Delay(TimeSpan.FromSeconds(1), cancellationToken: cts.Token); // cts.CancelAfterSlim(200); // try // { // var r = await UniTask.WhenAny(new[] { successDelayTask, cancelTask }); // } // catch (Exception ex) // { // ex.Should().BeAssignableTo(); // } // }); // } //} //#endif ================================================ FILE: src/UniTask/Assets/Tests/Editor/WhenAnyTestEditor.cs.meta ================================================ fileFormatVersion: 2 guid: b5addd9aa1a794441af032a71208b495 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Editor.meta ================================================ fileFormatVersion: 2 guid: 649f696fcc0c3104a8de82a2550d248c folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/GenericsWhenAllAny.cs ================================================ #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using UnityEngine; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using UnityEngine.UI; using UnityEngine.Scripting; using Cysharp.Threading.Tasks; using Unity.Collections; using System.Threading; using NUnit.Framework; using UnityEngine.TestTools; using FluentAssertions; namespace Cysharp.Threading.TasksTests { public class GenericsWhenAllAny { [UnityTest] public IEnumerator WhenAllT15() => UniTask.ToCoroutine(async () => { var t01 = Tes(); var t02 = Tes(); var t03 = Tes(); var t04 = Tes(); var t05 = Tes(); var t06 = Tes(); var t07 = Tes(); var t08 = Tes(); var t09 = Tes(); var t10 = Tes(); var t11 = Tes(); var t12 = Tes(); var t13 = Tes(); var t14 = Tes(); var t15 = Tes(); await UniTask.WhenAll(t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, t13, t14, t15); }); [UnityTest] public IEnumerator WhenAllT01_Generics1() => UniTask.ToCoroutine(async () => { var t01 = Tes>(); await UniTask.WhenAll(t01); }); [UnityTest] public IEnumerator WhenAllT02_Generics1() => UniTask.ToCoroutine(async () => { var t01 = Tes>(); var t02 = Tes>(); await UniTask.WhenAll(t01, t02); }); [UnityTest] public IEnumerator WhenAllT03_Generics1() => UniTask.ToCoroutine(async () => { var t01 = Tes>(); var t02 = Tes>(); var t03 = Tes>(); await UniTask.WhenAll(t01, t02, t03); }); [UnityTest] public IEnumerator WhenAllT04_Generics1() => UniTask.ToCoroutine(async () => { var t01 = Tes>(); var t02 = Tes>(); var t03 = Tes>(); var t04 = Tes>(); await UniTask.WhenAll(t01, t02, t03, t04); }); // will fail. //[UnityTest] //public IEnumerator WhenAllT05_Generics1() => UniTask.ToCoroutine(async () => //{ // var t01 = Tes>(); // var t02 = Tes>(); // var t03 = Tes>(); // var t04 = Tes>(); // var t05 = Tes>(); // await UniTask.WhenAll(t01, t02, t03, t04, t05); //}); //[UnityTest] //public IEnumerator WhenAllT06_Generics1() => UniTask.ToCoroutine(async () => //{ // var t01 = Tes>(); // var t02 = Tes>(); // var t03 = Tes>(); // var t04 = Tes>(); // var t05 = Tes>(); // var t06 = Tes>(); // await UniTask.WhenAll(t01, t02, t03, t04, t05, t06); //}); //[UnityTest] //public IEnumerator WhenAllT07_Generics1() => UniTask.ToCoroutine(async () => //{ // var t01 = Tes>(); // var t02 = Tes>(); // var t03 = Tes>(); // var t04 = Tes>(); // var t05 = Tes>(); // var t06 = Tes>(); // var t07 = Tes>(); // await UniTask.WhenAll(t01, t02, t03, t04, t05, t06, t07); //}); //[UnityTest] //public IEnumerator WhenAllT15_Generics1() => UniTask.ToCoroutine(async () => //{ // var t01 = Tes>(); // var t02 = Tes>(); // var t03 = Tes>(); // var t04 = Tes>(); // var t05 = Tes>(); // var t06 = Tes>(); // var t07 = Tes>(); // var t08 = Tes>(); // var t09 = Tes>(); // var t10 = Tes>(); // var t11 = Tes>(); // var t12 = Tes>(); // var t13 = Tes>(); // var t14 = Tes>(); // var t15 = Tes>(); // await UniTask.WhenAll(t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, t13, t14, t15); //}); async UniTask Tes() { await UniTask.Yield(); return default; } } public class MyGenerics { } public class MyGenerics2 { } } #endif ================================================ FILE: src/UniTask/Assets/Tests/GenericsWhenAllAny.cs.meta ================================================ fileFormatVersion: 2 guid: 6ce87069a3c0ebb47b26dca280a07756 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/PlayerLoopTimerTest.cs ================================================ using Cysharp.Threading.Tasks; using FluentAssertions; using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using UnityEngine.TestTools; namespace Cysharp.Threading.TasksTests { public class PlayerLoopTimerTest { void Between(TimeSpan l, TimeSpan data, TimeSpan r) { NUnit.Framework.Assert.AreEqual(l < data, true, "{0} < {1} failed.", l, data); NUnit.Framework.Assert.AreEqual(data < r, true, "{0} < {1} failed.", data, r); } [UnityTest] public IEnumerator StandardTicks() => UniTask.ToCoroutine(async () => { foreach (var delay in new[] { DelayType.DeltaTime, DelayType.Realtime, DelayType.UnscaledDeltaTime }) { var raisedTimeout = new UniTaskCompletionSource(); PlayerLoopTimer.StartNew(TimeSpan.FromSeconds(1), false, delay, PlayerLoopTiming.Update, CancellationToken.None, _ => { raisedTimeout.TrySetResult(); }, null); var sw = Stopwatch.StartNew(); await raisedTimeout.Task; sw.Stop(); Between(TimeSpan.FromSeconds(0.9), sw.Elapsed, TimeSpan.FromSeconds(1.1)); } }); [UnityTest] public IEnumerator Periodic() => UniTask.ToCoroutine(async () => { var raisedTime = new List(); var count = 0; var complete = new UniTaskCompletionSource(); PlayerLoopTimer timer = null; timer = PlayerLoopTimer.StartNew(TimeSpan.FromSeconds(1), true, DelayType.DeltaTime, PlayerLoopTiming.Update, CancellationToken.None, _ => { raisedTime.Add(DateTime.UtcNow); count++; if (count == 3) { complete.TrySetResult(); timer.Dispose(); } }, null); var start = DateTime.UtcNow; await complete.Task; Between(TimeSpan.FromSeconds(0.9), raisedTime[0] - start, TimeSpan.FromSeconds(1.1)); Between(TimeSpan.FromSeconds(1.9), raisedTime[1] - start, TimeSpan.FromSeconds(2.1)); Between(TimeSpan.FromSeconds(2.9), raisedTime[2] - start, TimeSpan.FromSeconds(3.1)); }); [UnityTest] public IEnumerator CancelAfterSlimTest() => UniTask.ToCoroutine(async () => { var cts = new CancellationTokenSource(); var complete = new UniTaskCompletionSource(); cts.Token.RegisterWithoutCaptureExecutionContext(() => { complete.TrySetResult(); }); cts.CancelAfterSlim(TimeSpan.FromSeconds(1)); var sw = Stopwatch.StartNew(); await complete.Task; Between(TimeSpan.FromSeconds(0.9), sw.Elapsed, TimeSpan.FromSeconds(1.1)); }); [UnityTest] public IEnumerator CancelAfterSlimCancelTest() => UniTask.ToCoroutine(async () => { var cts = new CancellationTokenSource(); var complete = new UniTaskCompletionSource(); cts.Token.RegisterWithoutCaptureExecutionContext(() => { complete.TrySetResult(); }); var d = cts.CancelAfterSlim(TimeSpan.FromSeconds(1)); var sw = Stopwatch.StartNew(); await UniTask.Delay(TimeSpan.FromMilliseconds(100)); d.Dispose(); await UniTask.Delay(TimeSpan.FromSeconds(2)); complete.Task.Status.Should().Be(UniTaskStatus.Pending); }); [UnityTest] public IEnumerator TimeoutController() => UniTask.ToCoroutine(async () => { var controller = new TimeoutController(); var token = controller.Timeout(TimeSpan.FromSeconds(1)); var complete = new UniTaskCompletionSource(); token.RegisterWithoutCaptureExecutionContext(() => { complete.TrySetResult(); }); var sw = Stopwatch.StartNew(); await complete.Task; Between(TimeSpan.FromSeconds(0.9), sw.Elapsed, TimeSpan.FromSeconds(1.1)); controller.IsTimeout().Should().BeTrue(); }); [UnityTest] public IEnumerator TimeoutReuse() => UniTask.ToCoroutine(async () => { var controller = new TimeoutController(DelayType.DeltaTime); var token = controller.Timeout(TimeSpan.FromSeconds(2)); var complete = new UniTaskCompletionSource(); token.RegisterWithoutCaptureExecutionContext(() => { complete.TrySetResult(); // reuse, used same token? }); await UniTask.Delay(TimeSpan.FromMilliseconds(100)); controller.Reset(); controller.IsTimeout().Should().BeFalse(); var sw = Stopwatch.StartNew(); controller.Timeout(TimeSpan.FromSeconds(5)); await complete.Task; UnityEngine.Debug.Log(UnityEngine.Time.timeScale); Between(TimeSpan.FromSeconds(4.9), sw.Elapsed, TimeSpan.FromSeconds(5.1)); controller.IsTimeout().Should().BeTrue(); }); [UnityTest] public IEnumerator LinkedTokenTest() => UniTask.ToCoroutine(async () => { var cts = new CancellationTokenSource(); var controller = new TimeoutController(cts); var token = controller.Timeout(TimeSpan.FromSeconds(2)); await UniTask.DelayFrame(3); cts.Cancel(); token.IsCancellationRequested.Should().BeTrue(); controller.Dispose(); }); } } ================================================ FILE: src/UniTask/Assets/Tests/PlayerLoopTimerTest.cs.meta ================================================ fileFormatVersion: 2 guid: c0c49de697f829f44aa8709b4d1eff3e MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Preserve.cs ================================================ using Cysharp.Threading.Tasks; using FluentAssertions; using NUnit.Framework; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using UnityEngine; using UnityEngine.TestTools; namespace Cysharp.Threading.TasksTests { public class Preserve { public Preserve() { // TaskPool.SetMaxPoolSize(0); } [UnityTest] public IEnumerator AwaitTwice() => UniTask.ToCoroutine(async () => { var delay = UniTask.DelayFrame(5); await delay; try { await delay; Assert.Fail("should throw exception."); } catch (InvalidOperationException) { } }); [UnityTest] public IEnumerator PreserveAllowTwice() => UniTask.ToCoroutine(async () => { await UniTask.Yield(PlayerLoopTiming.Update); var delay = UniTask.DelayFrame(5, PlayerLoopTiming.PostLateUpdate).Preserve(); var before = UnityEngine.Time.frameCount; // 0 await delay; var afterOne = UnityEngine.Time.frameCount; // 5 await delay; var afterTwo = UnityEngine.Time.frameCount; // 5 (afterOne - before).Should().Be(5); afterOne.Should().Be(afterTwo); }); } } ================================================ FILE: src/UniTask/Assets/Tests/Preserve.cs.meta ================================================ fileFormatVersion: 2 guid: 418f4974867e1294b81020613a0b1032 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Resources/sample_texture.png.meta ================================================ fileFormatVersion: 2 guid: 535006a83baed4ebda99d24a909a2efe TextureImporter: internalIDToNameTable: - first: 213: -2664112245596591751 second: sample_texture_0 - first: 213: -4606777057269188692 second: sample_texture_1 - first: 213: 1950921086533113773 second: sample_texture_2 externalObjects: {} serializedVersion: 13 mipmaps: mipMapMode: 0 enableMipMap: 0 sRGBTexture: 1 linearTexture: 0 fadeOut: 0 borderMipMap: 0 mipMapsPreserveCoverage: 0 alphaTestReferenceValue: 0.5 mipMapFadeDistanceStart: 1 mipMapFadeDistanceEnd: 3 bumpmap: convertToNormalMap: 0 externalNormalMap: 0 heightScale: 0.25 normalMapFilter: 0 flipGreenChannel: 0 isReadable: 0 streamingMipmaps: 0 streamingMipmapsPriority: 0 vTOnly: 0 ignoreMipmapLimit: 0 grayScaleToAlpha: 0 generateCubemap: 6 cubemapConvolution: 0 seamlessCubemap: 0 textureFormat: 1 maxTextureSize: 2048 textureSettings: serializedVersion: 2 filterMode: 1 aniso: 1 mipBias: 0 wrapU: 1 wrapV: 1 wrapW: 1 nPOTScale: 0 lightmap: 0 compressionQuality: 50 spriteMode: 2 spriteExtrude: 1 spriteMeshType: 1 alignment: 0 spritePivot: {x: 0.5, y: 0.5} spritePixelsToUnits: 100 spriteBorder: {x: 0, y: 0, z: 0, w: 0} spriteGenerateFallbackPhysicsShape: 1 alphaUsage: 1 alphaIsTransparency: 1 spriteTessellationDetail: -1 textureType: 8 textureShape: 1 singleChannelComponent: 0 flipbookRows: 1 flipbookColumns: 1 maxTextureSizeSet: 0 compressionQualitySet: 0 textureFormatSet: 0 ignorePngGamma: 0 applyGammaDecoding: 0 swizzle: 50462976 cookieLightType: 0 platformSettings: - serializedVersion: 3 buildTarget: DefaultTexturePlatform maxTextureSize: 2048 resizeAlgorithm: 0 textureFormat: -1 textureCompression: 1 compressionQuality: 50 crunchedCompression: 0 allowsAlphaSplitting: 0 overridden: 0 ignorePlatformSupport: 0 androidETC2FallbackOverride: 0 forceMaximumCompressionQuality_BC6H_BC7: 0 - serializedVersion: 3 buildTarget: WebGL maxTextureSize: 2048 resizeAlgorithm: 0 textureFormat: -1 textureCompression: 1 compressionQuality: 50 crunchedCompression: 0 allowsAlphaSplitting: 0 overridden: 0 ignorePlatformSupport: 0 androidETC2FallbackOverride: 0 forceMaximumCompressionQuality_BC6H_BC7: 0 - serializedVersion: 3 buildTarget: Standalone maxTextureSize: 2048 resizeAlgorithm: 0 textureFormat: -1 textureCompression: 1 compressionQuality: 50 crunchedCompression: 0 allowsAlphaSplitting: 0 overridden: 0 ignorePlatformSupport: 0 androidETC2FallbackOverride: 0 forceMaximumCompressionQuality_BC6H_BC7: 0 - serializedVersion: 3 buildTarget: iPhone maxTextureSize: 2048 resizeAlgorithm: 0 textureFormat: -1 textureCompression: 1 compressionQuality: 50 crunchedCompression: 0 allowsAlphaSplitting: 0 overridden: 0 ignorePlatformSupport: 0 androidETC2FallbackOverride: 0 forceMaximumCompressionQuality_BC6H_BC7: 0 spriteSheet: serializedVersion: 2 sprites: - serializedVersion: 2 name: sample_texture_0 rect: serializedVersion: 2 x: 0 y: 76 width: 243 height: 251 alignment: 0 pivot: {x: 0, y: 0} border: {x: 0, y: 0, z: 0, w: 0} outline: [] physicsShape: [] tessellationDetail: -1 bones: [] spriteID: 9796277170c270bd0800000000000000 internalID: -2664112245596591751 vertices: [] indices: edges: [] weights: [] - serializedVersion: 2 name: sample_texture_1 rect: serializedVersion: 2 x: 227 y: 0 width: 190 height: 231 alignment: 0 pivot: {x: 0, y: 0} border: {x: 0, y: 0, z: 0, w: 0} outline: [] physicsShape: [] tessellationDetail: -1 bones: [] spriteID: ca7fc069ca07110c0800000000000000 internalID: -4606777057269188692 vertices: [] indices: edges: [] weights: [] - serializedVersion: 2 name: sample_texture_2 rect: serializedVersion: 2 x: 398 y: 87 width: 202 height: 188 alignment: 0 pivot: {x: 0, y: 0} border: {x: 0, y: 0, z: 0, w: 0} outline: [] physicsShape: [] tessellationDetail: -1 bones: [] spriteID: da710ab4460131b10800000000000000 internalID: 1950921086533113773 vertices: [] indices: edges: [] weights: [] outline: [] physicsShape: [] bones: [] spriteID: internalID: 0 vertices: [] indices: edges: [] weights: [] secondaryTextures: [] nameFileIdTable: sample_texture_0: -2664112245596591751 sample_texture_1: -4606777057269188692 sample_texture_2: 1950921086533113773 mipmapLimitGroupName: pSDRemoveMatte: 0 userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Resources.meta ================================================ fileFormatVersion: 2 guid: 8d82913edf6ac48aca30f66ae9ba42d6 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/RunTest.cs ================================================ #pragma warning disable CS0618 #if !(UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2) #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using UnityEngine; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using UnityEngine.UI; using UnityEngine.Scripting; using Cysharp.Threading.Tasks; using UnityEngine.SceneManagement; #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) using System.Threading.Tasks; #endif using UnityEngine.Networking; #if !UNITY_2019_3_OR_NEWER using UnityEngine.Experimental.LowLevel; #else using UnityEngine.LowLevel; #endif #if !UNITY_WSA using Unity.Jobs; #endif using Unity.Collections; using System.Threading; using NUnit.Framework; using UnityEngine.TestTools; using FluentAssertions; namespace Cysharp.Threading.TasksTests { public class RunTest { #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) #if !UNITY_WSA #if !UNITY_WEBGL //[UnityTest] //public IEnumerator RunThread() => UniTask.ToCoroutine(async () => //{ // var main = Thread.CurrentThread.ManagedThreadId; // var v = await UniTask.Run(() => { return System.Threading.Thread.CurrentThread.ManagedThreadId; }, false); // UnityEngine.Debug.Log("Ret Value is:" + v); // UnityEngine.Debug.Log("Run Here and id:" + System.Threading.Thread.CurrentThread.ManagedThreadId); // //v.Should().Be(3); // main.Should().NotBe(Thread.CurrentThread.ManagedThreadId); //}); [UnityTest] public IEnumerator RunThreadConfigure() => UniTask.ToCoroutine(async () => { var main = Thread.CurrentThread.ManagedThreadId; var v = await UniTask.Run(() => 3, true); v.Should().Be(3); main.Should().Be(Thread.CurrentThread.ManagedThreadId); }); //[UnityTest] //public IEnumerator RunThreadException() => UniTask.ToCoroutine(async () => //{ // var main = Thread.CurrentThread.ManagedThreadId; // try // { // await UniTask.Run(() => throw new Exception(), false); // } // catch // { // main.Should().NotBe(Thread.CurrentThread.ManagedThreadId); // } //}); [UnityTest] public IEnumerator RunThreadExceptionConfigure() => UniTask.ToCoroutine(async () => { var main = Thread.CurrentThread.ManagedThreadId; try { #pragma warning disable CS1998 await UniTask.Run(async () => throw new Exception(), true); #pragma warning restore CS1998 } catch { main.Should().Be(Thread.CurrentThread.ManagedThreadId); } }); #endif #endif #endif } } #endif ================================================ FILE: src/UniTask/Assets/Tests/RunTest.cs.meta ================================================ fileFormatVersion: 2 guid: 3510f39953ed3074cb2e0f04d3a3f807 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/Shims.cs ================================================ using NUnit.Framework; using System; namespace Xunit { public class FactAttribute : TestAttribute { } } // Shims of FluentAssertions namespace FluentAssertions { public static class FluentAssertionsExtensions { public static Int Should(this int value) { return new Int(value); } public static Bool Should(this bool value) { return new Bool(value); } public static ExceptionAssertion Should(this Exception value) { return new ExceptionAssertion(value); } public static Generic Should(this T value) { return new Generic(value); } public class Generic { readonly T actual; public Generic(T value) { actual = value; } public void Be(T expected) { Assert.AreEqual(expected, actual); } public void NotBe(T expected) { Assert.AreNotEqual(expected, actual); } public void BeNull() { Assert.IsNull(actual); } public void NotBeNull() { Assert.IsNotNull(actual); } } public class Bool { readonly bool actual; public Bool(bool value) { actual = value; } public void Be(bool expected) { Assert.AreEqual(expected, actual); } public void NotBe(bool expected) { Assert.AreNotEqual(expected, actual); } public void BeTrue() { Assert.AreEqual(true, actual); } public void BeFalse() { Assert.AreEqual(false, actual); } } public class Int { readonly int actual; public Int(int value) { actual = value; } public void Be(int expected) { Assert.AreEqual(expected, actual); } public void NotBe(int expected) { Assert.AreNotEqual(expected, actual); } public void BeCloseTo(int expected, int delta) { if (expected - delta <= actual && actual <= expected + delta) { // OK. } else { Assert.Fail($"Fail BeCloseTo, actual {actual} but expected:{expected} +- {delta}"); } } } public class ExceptionAssertion { readonly Exception actual; public ExceptionAssertion(Exception actual) { this.actual = actual; } public void BeAssignableTo() { typeof(T).IsAssignableFrom(actual.GetType()); } } } } ================================================ FILE: src/UniTask/Assets/Tests/Shims.cs.meta ================================================ fileFormatVersion: 2 guid: f76a88025d2f76a4bae09aaa268da103 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/UniTask.Tests.asmdef ================================================ { "name": "UniTask.Tests", "references": [ "UnityEngine.TestRunner", "UnityEditor.TestRunner", "UniTask", "Unity.ResourceManager", "DOTween.Modules", "UniTask.Linq" ], "includePlatforms": [], "excludePlatforms": [], "allowUnsafeCode": false, "overrideReferences": true, "precompiledReferences": [ "nunit.framework.dll", "DOTween.dll" ], "autoReferenced": false, "defineConstraints": [ "UNITY_INCLUDE_TESTS" ], "versionDefines": [], "noEngineReferences": false } ================================================ FILE: src/UniTask/Assets/Tests/UniTask.Tests.asmdef.meta ================================================ fileFormatVersion: 2 guid: 9fbc684c31ac15b42809d42b62f6eb5f AssemblyDefinitionImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests/WhenAnyTest.cs ================================================ #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6)) #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member using UnityEngine; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using UnityEngine.UI; using UnityEngine.Scripting; using Cysharp.Threading.Tasks; using Unity.Collections; using System.Threading; using NUnit.Framework; using UnityEngine.TestTools; using FluentAssertions; namespace Cysharp.Threading.TasksTests { public class WhenAnyTest { [UnityTest] public IEnumerator WhenAnyCanceled() => UniTask.ToCoroutine(async () => { var cts = new CancellationTokenSource(); var successDelayTask = UniTask.Delay(TimeSpan.FromSeconds(1)); var cancelTask = UniTask.Delay(TimeSpan.FromSeconds(1), cancellationToken: cts.Token); cts.CancelAfterSlim(200); try { var r = await UniTask.WhenAny(new[] { successDelayTask, cancelTask }); } catch (Exception ex) { ex.Should().BeAssignableTo(); } }); } } #endif ================================================ FILE: src/UniTask/Assets/Tests/WhenAnyTest.cs.meta ================================================ fileFormatVersion: 2 guid: 0a07d2ea8baf390408279a29510f4953 MonoImporter: externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 icon: {instanceID: 0} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Assets/Tests.meta ================================================ fileFormatVersion: 2 guid: b831a4cf04cbe4b48ae74498484ec8c1 folderAsset: yes DefaultImporter: externalObjects: {} userData: assetBundleName: assetBundleVariant: ================================================ FILE: src/UniTask/Packages/manifest.json ================================================ { "dependencies": { "com.cysharp.runtimeunittesttoolkit": "https://github.com/Cysharp/RuntimeUnitTestToolkit.git?path=RuntimeUnitTestToolkit/Assets/RuntimeUnitTestToolkit#2.6.0", "com.unity.collab-proxy": "2.4.3", "com.unity.ide.rider": "3.0.31", "com.unity.ide.visualstudio": "2.0.22", "com.unity.ide.vscode": "1.2.5", "com.unity.test-framework": "1.1.33", "com.unity.textmeshpro": "3.0.6", "com.unity.timeline": "1.7.6", "com.unity.toolchain.win-x86_64-linux-x86_64": "2.0.9", "com.unity.ugui": "1.0.0", "com.unity.modules.ai": "1.0.0", "com.unity.modules.androidjni": "1.0.0", "com.unity.modules.animation": "1.0.0", "com.unity.modules.assetbundle": "1.0.0", "com.unity.modules.audio": "1.0.0", "com.unity.modules.cloth": "1.0.0", "com.unity.modules.director": "1.0.0", "com.unity.modules.imageconversion": "1.0.0", "com.unity.modules.imgui": "1.0.0", "com.unity.modules.jsonserialize": "1.0.0", "com.unity.modules.particlesystem": "1.0.0", "com.unity.modules.physics": "1.0.0", "com.unity.modules.physics2d": "1.0.0", "com.unity.modules.screencapture": "1.0.0", "com.unity.modules.terrain": "1.0.0", "com.unity.modules.terrainphysics": "1.0.0", "com.unity.modules.tilemap": "1.0.0", "com.unity.modules.ui": "1.0.0", "com.unity.modules.uielements": "1.0.0", "com.unity.modules.umbra": "1.0.0", "com.unity.modules.unityanalytics": "1.0.0", "com.unity.modules.unitywebrequest": "1.0.0", "com.unity.modules.unitywebrequestassetbundle": "1.0.0", "com.unity.modules.unitywebrequestaudio": "1.0.0", "com.unity.modules.unitywebrequesttexture": "1.0.0", "com.unity.modules.unitywebrequestwww": "1.0.0", "com.unity.modules.vehicles": "1.0.0", "com.unity.modules.video": "1.0.0", "com.unity.modules.vr": "1.0.0", "com.unity.modules.wind": "1.0.0", "com.unity.modules.xr": "1.0.0" } } ================================================ FILE: src/UniTask/Packages/packages-lock.json ================================================ { "dependencies": { "com.cysharp.runtimeunittesttoolkit": { "version": "https://github.com/Cysharp/RuntimeUnitTestToolkit.git?path=RuntimeUnitTestToolkit/Assets/RuntimeUnitTestToolkit#2.6.0", "depth": 0, "source": "git", "dependencies": {}, "hash": "4e3dbfaa9c40b5cfdcb71a1d4e8bca0d45ca1055" }, "com.unity.collab-proxy": { "version": "2.4.3", "depth": 0, "source": "registry", "dependencies": {}, "url": "https://packages.unity.com" }, "com.unity.ext.nunit": { "version": "1.0.6", "depth": 1, "source": "registry", "dependencies": {}, "url": "https://packages.unity.com" }, "com.unity.ide.rider": { "version": "3.0.31", "depth": 0, "source": "registry", "dependencies": { "com.unity.ext.nunit": "1.0.6" }, "url": "https://packages.unity.com" }, "com.unity.ide.visualstudio": { "version": "2.0.22", "depth": 0, "source": "registry", "dependencies": { "com.unity.test-framework": "1.1.9" }, "url": "https://packages.unity.com" }, "com.unity.ide.vscode": { "version": "1.2.5", "depth": 0, "source": "registry", "dependencies": {}, "url": "https://packages.unity.com" }, "com.unity.sysroot": { "version": "2.0.10", "depth": 1, "source": "registry", "dependencies": {}, "url": "https://packages.unity.com" }, "com.unity.sysroot.linux-x86_64": { "version": "2.0.9", "depth": 1, "source": "registry", "dependencies": { "com.unity.sysroot": "2.0.10" }, "url": "https://packages.unity.com" }, "com.unity.test-framework": { "version": "1.1.33", "depth": 0, "source": "registry", "dependencies": { "com.unity.ext.nunit": "1.0.6", "com.unity.modules.imgui": "1.0.0", "com.unity.modules.jsonserialize": "1.0.0" }, "url": "https://packages.unity.com" }, "com.unity.textmeshpro": { "version": "3.0.6", "depth": 0, "source": "registry", "dependencies": { "com.unity.ugui": "1.0.0" }, "url": "https://packages.unity.com" }, "com.unity.timeline": { "version": "1.7.6", "depth": 0, "source": "registry", "dependencies": { "com.unity.modules.director": "1.0.0", "com.unity.modules.animation": "1.0.0", "com.unity.modules.audio": "1.0.0", "com.unity.modules.particlesystem": "1.0.0" }, "url": "https://packages.unity.com" }, "com.unity.toolchain.win-x86_64-linux-x86_64": { "version": "2.0.9", "depth": 0, "source": "registry", "dependencies": { "com.unity.sysroot": "2.0.10", "com.unity.sysroot.linux-x86_64": "2.0.9" }, "url": "https://packages.unity.com" }, "com.unity.ugui": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.ui": "1.0.0", "com.unity.modules.imgui": "1.0.0" } }, "com.unity.modules.ai": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.androidjni": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.animation": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.assetbundle": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.audio": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.cloth": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.physics": "1.0.0" } }, "com.unity.modules.director": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.audio": "1.0.0", "com.unity.modules.animation": "1.0.0" } }, "com.unity.modules.imageconversion": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.imgui": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.jsonserialize": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.particlesystem": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.physics": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.physics2d": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.screencapture": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.imageconversion": "1.0.0" } }, "com.unity.modules.subsystems": { "version": "1.0.0", "depth": 1, "source": "builtin", "dependencies": { "com.unity.modules.jsonserialize": "1.0.0" } }, "com.unity.modules.terrain": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.terrainphysics": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.physics": "1.0.0", "com.unity.modules.terrain": "1.0.0" } }, "com.unity.modules.tilemap": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.physics2d": "1.0.0" } }, "com.unity.modules.ui": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.uielements": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.ui": "1.0.0", "com.unity.modules.imgui": "1.0.0", "com.unity.modules.jsonserialize": "1.0.0" } }, "com.unity.modules.umbra": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.unityanalytics": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.unitywebrequest": "1.0.0", "com.unity.modules.jsonserialize": "1.0.0" } }, "com.unity.modules.unitywebrequest": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.unitywebrequestassetbundle": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.assetbundle": "1.0.0", "com.unity.modules.unitywebrequest": "1.0.0" } }, "com.unity.modules.unitywebrequestaudio": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.unitywebrequest": "1.0.0", "com.unity.modules.audio": "1.0.0" } }, "com.unity.modules.unitywebrequesttexture": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.unitywebrequest": "1.0.0", "com.unity.modules.imageconversion": "1.0.0" } }, "com.unity.modules.unitywebrequestwww": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.unitywebrequest": "1.0.0", "com.unity.modules.unitywebrequestassetbundle": "1.0.0", "com.unity.modules.unitywebrequestaudio": "1.0.0", "com.unity.modules.audio": "1.0.0", "com.unity.modules.assetbundle": "1.0.0", "com.unity.modules.imageconversion": "1.0.0" } }, "com.unity.modules.vehicles": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.physics": "1.0.0" } }, "com.unity.modules.video": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.audio": "1.0.0", "com.unity.modules.ui": "1.0.0", "com.unity.modules.unitywebrequest": "1.0.0" } }, "com.unity.modules.vr": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.jsonserialize": "1.0.0", "com.unity.modules.physics": "1.0.0", "com.unity.modules.xr": "1.0.0" } }, "com.unity.modules.wind": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": {} }, "com.unity.modules.xr": { "version": "1.0.0", "depth": 0, "source": "builtin", "dependencies": { "com.unity.modules.physics": "1.0.0", "com.unity.modules.jsonserialize": "1.0.0", "com.unity.modules.subsystems": "1.0.0" } } } } ================================================ FILE: src/UniTask/ProjectSettings/AudioManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!11 &1 AudioManager: m_ObjectHideFlags: 0 m_Volume: 1 Rolloff Scale: 1 Doppler Factor: 1 Default Speaker Mode: 2 m_SampleRate: 0 m_DSPBufferSize: 1024 m_VirtualVoiceCount: 512 m_RealVoiceCount: 32 m_SpatializerPlugin: m_AmbisonicDecoderPlugin: m_DisableAudio: 0 m_VirtualizeEffects: 1 ================================================ FILE: src/UniTask/ProjectSettings/ClusterInputManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!236 &1 ClusterInputManager: m_ObjectHideFlags: 0 m_Inputs: [] ================================================ FILE: src/UniTask/ProjectSettings/DynamicsManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!55 &1 PhysicsManager: m_ObjectHideFlags: 0 serializedVersion: 7 m_Gravity: {x: 0, y: -9.81, z: 0} m_DefaultMaterial: {fileID: 0} m_BounceThreshold: 2 m_SleepThreshold: 0.005 m_DefaultContactOffset: 0.01 m_DefaultSolverIterations: 6 m_DefaultSolverVelocityIterations: 1 m_QueriesHitBackfaces: 0 m_QueriesHitTriggers: 1 m_EnableAdaptiveForce: 0 m_ClothInterCollisionDistance: 0 m_ClothInterCollisionStiffness: 0 m_ContactsGeneration: 1 m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff m_AutoSimulation: 1 m_AutoSyncTransforms: 0 m_ReuseCollisionCallbacks: 1 m_ClothInterCollisionSettingsToggle: 0 m_ContactPairsMode: 0 m_BroadphaseType: 0 m_WorldBounds: m_Center: {x: 0, y: 0, z: 0} m_Extent: {x: 250, y: 250, z: 250} m_WorldSubdivisions: 8 ================================================ FILE: src/UniTask/ProjectSettings/EditorBuildSettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!1045 &1 EditorBuildSettings: m_ObjectHideFlags: 0 serializedVersion: 2 m_Scenes: - enabled: 1 path: Assets/Scenes/SandboxMain.unity guid: 2cda990e2423bbf4892e6590ba056729 - enabled: 1 path: Assets/Scenes/ExceptionExamples.unity guid: b5fed17e3ece238439bc796d8747df5d m_configObjects: {} ================================================ FILE: src/UniTask/ProjectSettings/EditorSettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!159 &1 EditorSettings: m_ObjectHideFlags: 0 serializedVersion: 9 m_ExternalVersionControlSupport: Visible Meta Files m_SerializationMode: 2 m_LineEndingsForNewScripts: 2 m_DefaultBehaviorMode: 1 m_PrefabRegularEnvironment: {fileID: 0} m_PrefabUIEnvironment: {fileID: 0} m_SpritePackerMode: 4 m_SpritePackerPaddingPower: 1 m_EtcTextureCompressorBehavior: 1 m_EtcTextureFastCompressor: 1 m_EtcTextureNormalCompressor: 2 m_EtcTextureBestCompressor: 4 m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmref m_ProjectGenerationRootNamespace: m_CollabEditorSettings: inProgressEnabled: 1 m_EnableTextureStreamingInEditMode: 1 m_EnableTextureStreamingInPlayMode: 1 m_AsyncShaderCompilation: 1 m_EnterPlayModeOptionsEnabled: 0 m_EnterPlayModeOptions: 3 m_ShowLightmapResolutionOverlay: 1 m_UseLegacyProbeSampleCount: 1 m_AssetPipelineMode: 1 m_CacheServerMode: 0 m_CacheServerEndpoint: m_CacheServerNamespacePrefix: default m_CacheServerEnableDownload: 1 m_CacheServerEnableUpload: 1 ================================================ FILE: src/UniTask/ProjectSettings/GraphicsSettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!30 &1 GraphicsSettings: m_ObjectHideFlags: 0 serializedVersion: 12 m_Deferred: m_Mode: 1 m_Shader: {fileID: 69, guid: 0000000000000000f000000000000000, type: 0} m_DeferredReflections: m_Mode: 1 m_Shader: {fileID: 74, guid: 0000000000000000f000000000000000, type: 0} m_ScreenSpaceShadows: m_Mode: 1 m_Shader: {fileID: 64, guid: 0000000000000000f000000000000000, type: 0} m_LegacyDeferred: m_Mode: 1 m_Shader: {fileID: 63, guid: 0000000000000000f000000000000000, type: 0} m_DepthNormals: m_Mode: 1 m_Shader: {fileID: 62, guid: 0000000000000000f000000000000000, type: 0} m_MotionVectors: m_Mode: 1 m_Shader: {fileID: 75, guid: 0000000000000000f000000000000000, type: 0} m_LightHalo: m_Mode: 1 m_Shader: {fileID: 105, guid: 0000000000000000f000000000000000, type: 0} m_LensFlare: m_Mode: 1 m_Shader: {fileID: 102, guid: 0000000000000000f000000000000000, type: 0} m_AlwaysIncludedShaders: - {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0} - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0} - {fileID: 16000, guid: 0000000000000000f000000000000000, type: 0} - {fileID: 16001, guid: 0000000000000000f000000000000000, type: 0} - {fileID: 17000, guid: 0000000000000000f000000000000000, type: 0} m_PreloadedShaders: [] m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0} m_CustomRenderPipeline: {fileID: 0} m_TransparencySortMode: 0 m_TransparencySortAxis: {x: 0, y: 0, z: 1} m_DefaultRenderingPath: 1 m_DefaultMobileRenderingPath: 1 m_TierSettings: [] m_LightmapStripping: 0 m_FogStripping: 0 m_InstancingStripping: 0 m_LightmapKeepPlain: 1 m_LightmapKeepDirCombined: 1 m_LightmapKeepDynamicPlain: 1 m_LightmapKeepDynamicDirCombined: 1 m_LightmapKeepShadowMask: 1 m_LightmapKeepSubtractive: 1 m_FogKeepLinear: 1 m_FogKeepExp: 1 m_FogKeepExp2: 1 m_AlbedoSwatchInfos: [] m_LightsUseLinearIntensity: 0 m_LightsUseColorTemperature: 0 ================================================ FILE: src/UniTask/ProjectSettings/InputManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!13 &1 InputManager: m_ObjectHideFlags: 0 serializedVersion: 2 m_Axes: - serializedVersion: 3 m_Name: Horizontal descriptiveName: descriptiveNegativeName: negativeButton: left positiveButton: right altNegativeButton: a altPositiveButton: d gravity: 3 dead: 0.001 sensitivity: 3 snap: 1 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Vertical descriptiveName: descriptiveNegativeName: negativeButton: down positiveButton: up altNegativeButton: s altPositiveButton: w gravity: 3 dead: 0.001 sensitivity: 3 snap: 1 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Fire1 descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: left ctrl altNegativeButton: altPositiveButton: mouse 0 gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Fire2 descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: left alt altNegativeButton: altPositiveButton: mouse 1 gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Fire3 descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: left shift altNegativeButton: altPositiveButton: mouse 2 gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Jump descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: space altNegativeButton: altPositiveButton: gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Mouse X descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: altNegativeButton: altPositiveButton: gravity: 0 dead: 0 sensitivity: 0.1 snap: 0 invert: 0 type: 1 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Mouse Y descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: altNegativeButton: altPositiveButton: gravity: 0 dead: 0 sensitivity: 0.1 snap: 0 invert: 0 type: 1 axis: 1 joyNum: 0 - serializedVersion: 3 m_Name: Mouse ScrollWheel descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: altNegativeButton: altPositiveButton: gravity: 0 dead: 0 sensitivity: 0.1 snap: 0 invert: 0 type: 1 axis: 2 joyNum: 0 - serializedVersion: 3 m_Name: Horizontal descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: altNegativeButton: altPositiveButton: gravity: 0 dead: 0.19 sensitivity: 1 snap: 0 invert: 0 type: 2 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Vertical descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: altNegativeButton: altPositiveButton: gravity: 0 dead: 0.19 sensitivity: 1 snap: 0 invert: 1 type: 2 axis: 1 joyNum: 0 - serializedVersion: 3 m_Name: Fire1 descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: joystick button 0 altNegativeButton: altPositiveButton: gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Fire2 descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: joystick button 1 altNegativeButton: altPositiveButton: gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Fire3 descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: joystick button 2 altNegativeButton: altPositiveButton: gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Jump descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: joystick button 3 altNegativeButton: altPositiveButton: gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Submit descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: return altNegativeButton: altPositiveButton: joystick button 0 gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Submit descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: enter altNegativeButton: altPositiveButton: space gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 - serializedVersion: 3 m_Name: Cancel descriptiveName: descriptiveNegativeName: negativeButton: positiveButton: escape altNegativeButton: altPositiveButton: joystick button 1 gravity: 1000 dead: 0.001 sensitivity: 1000 snap: 0 invert: 0 type: 0 axis: 0 joyNum: 0 ================================================ FILE: src/UniTask/ProjectSettings/MemorySettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!387306366 &1 MemorySettings: m_ObjectHideFlags: 0 m_EditorMemorySettings: m_MainAllocatorBlockSize: -1 m_ThreadAllocatorBlockSize: -1 m_MainGfxBlockSize: -1 m_ThreadGfxBlockSize: -1 m_CacheBlockSize: -1 m_TypetreeBlockSize: -1 m_ProfilerBlockSize: -1 m_ProfilerEditorBlockSize: -1 m_BucketAllocatorGranularity: -1 m_BucketAllocatorBucketsCount: -1 m_BucketAllocatorBlockSize: -1 m_BucketAllocatorBlockCount: -1 m_ProfilerBucketAllocatorGranularity: -1 m_ProfilerBucketAllocatorBucketsCount: -1 m_ProfilerBucketAllocatorBlockSize: -1 m_ProfilerBucketAllocatorBlockCount: -1 m_TempAllocatorSizeMain: -1 m_JobTempAllocatorBlockSize: -1 m_BackgroundJobTempAllocatorBlockSize: -1 m_JobTempAllocatorReducedBlockSize: -1 m_TempAllocatorSizeGIBakingWorker: -1 m_TempAllocatorSizeNavMeshWorker: -1 m_TempAllocatorSizeAudioWorker: -1 m_TempAllocatorSizeCloudWorker: -1 m_TempAllocatorSizeGfx: -1 m_TempAllocatorSizeJobWorker: -1 m_TempAllocatorSizeBackgroundWorker: -1 m_TempAllocatorSizePreloadManager: -1 m_PlatformMemorySettings: {} ================================================ FILE: src/UniTask/ProjectSettings/NavMeshAreas.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!126 &1 NavMeshProjectSettings: m_ObjectHideFlags: 0 serializedVersion: 2 areas: - name: Walkable cost: 1 - name: Not Walkable cost: 1 - name: Jump cost: 2 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 - name: cost: 1 m_LastAgentTypeID: -887442657 m_Settings: - serializedVersion: 2 agentTypeID: 0 agentRadius: 0.5 agentHeight: 2 agentSlope: 45 agentClimb: 0.75 ledgeDropHeight: 0 maxJumpAcrossDistance: 0 minRegionArea: 2 manualCellSize: 0 cellSize: 0.16666667 manualTileSize: 0 tileSize: 256 accuratePlacement: 0 debug: m_Flags: 0 m_SettingNames: - Humanoid ================================================ FILE: src/UniTask/ProjectSettings/NetworkManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!149 &1 NetworkManager: m_ObjectHideFlags: 0 m_DebugLevel: 0 m_Sendrate: 15 m_AssetToPrefab: {} ================================================ FILE: src/UniTask/ProjectSettings/PackageManagerSettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!114 &1 MonoBehaviour: m_ObjectHideFlags: 61 m_CorrespondingSourceObject: {fileID: 0} m_PrefabInstance: {fileID: 0} m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 0} m_Enabled: 1 m_EditorHideFlags: 0 m_Script: {fileID: 13964, guid: 0000000000000000e000000000000000, type: 0} m_Name: m_EditorClassIdentifier: m_EnablePreviewPackages: 0 m_EnablePackageDependencies: 0 m_AdvancedSettingsExpanded: 1 m_ScopedRegistriesSettingsExpanded: 1 oneTimeWarningShown: 0 m_Registries: - m_Id: main m_Name: m_Url: https://packages.unity.com m_Scopes: [] m_IsDefault: 1 m_Capabilities: 7 m_UserSelectedRegistryName: m_UserAddingNewScopedRegistry: 0 m_RegistryInfoDraft: m_ErrorMessage: m_Original: m_Id: m_Name: m_Url: m_Scopes: [] m_IsDefault: 0 m_Capabilities: 0 m_Modified: 0 m_Name: m_Url: m_Scopes: - m_SelectedScopeIndex: 0 ================================================ FILE: src/UniTask/ProjectSettings/Physics2DSettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!19 &1 Physics2DSettings: m_ObjectHideFlags: 0 serializedVersion: 4 m_Gravity: {x: 0, y: -9.81} m_DefaultMaterial: {fileID: 0} m_VelocityIterations: 8 m_PositionIterations: 3 m_VelocityThreshold: 1 m_MaxLinearCorrection: 0.2 m_MaxAngularCorrection: 8 m_MaxTranslationSpeed: 100 m_MaxRotationSpeed: 360 m_BaumgarteScale: 0.2 m_BaumgarteTimeOfImpactScale: 0.75 m_TimeToSleep: 0.5 m_LinearSleepTolerance: 0.01 m_AngularSleepTolerance: 2 m_DefaultContactOffset: 0.01 m_JobOptions: serializedVersion: 2 useMultithreading: 0 useConsistencySorting: 0 m_InterpolationPosesPerJob: 100 m_NewContactsPerJob: 30 m_CollideContactsPerJob: 100 m_ClearFlagsPerJob: 200 m_ClearBodyForcesPerJob: 200 m_SyncDiscreteFixturesPerJob: 50 m_SyncContinuousFixturesPerJob: 50 m_FindNearestContactsPerJob: 100 m_UpdateTriggerContactsPerJob: 100 m_IslandSolverCostThreshold: 100 m_IslandSolverBodyCostScale: 1 m_IslandSolverContactCostScale: 10 m_IslandSolverJointCostScale: 10 m_IslandSolverBodiesPerJob: 50 m_IslandSolverContactsPerJob: 50 m_AutoSimulation: 1 m_QueriesHitTriggers: 1 m_QueriesStartInColliders: 1 m_CallbacksOnDisable: 1 m_ReuseCollisionCallbacks: 0 m_AutoSyncTransforms: 0 m_AlwaysShowColliders: 0 m_ShowColliderSleep: 1 m_ShowColliderContacts: 0 m_ShowColliderAABB: 0 m_ContactArrowScale: 0.2 m_ColliderAwakeColor: {r: 0.5686275, g: 0.95686275, b: 0.54509807, a: 0.7529412} m_ColliderAsleepColor: {r: 0.5686275, g: 0.95686275, b: 0.54509807, a: 0.36078432} m_ColliderContactColor: {r: 1, g: 0, b: 1, a: 0.6862745} m_ColliderAABBColor: {r: 1, g: 1, b: 0, a: 0.2509804} m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ================================================ FILE: src/UniTask/ProjectSettings/PresetManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!1386491679 &1 PresetManager: m_ObjectHideFlags: 0 m_DefaultList: [] ================================================ FILE: src/UniTask/ProjectSettings/ProjectSettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!129 &1 PlayerSettings: m_ObjectHideFlags: 0 serializedVersion: 26 productGUID: 904cd7a3163037f42a9204c0e2f2b7bd AndroidProfiler: 0 AndroidFilterTouchesWhenObscured: 0 AndroidEnableSustainedPerformanceMode: 0 defaultScreenOrientation: 4 targetDevice: 2 useOnDemandResources: 0 accelerometerFrequency: 60 companyName: DefaultCompany productName: UniTask defaultCursor: {fileID: 0} cursorHotspot: {x: 0, y: 0} m_SplashScreenBackgroundColor: {r: 0.13725491, g: 0.12156863, b: 0.1254902, a: 1} m_ShowUnitySplashScreen: 1 m_ShowUnitySplashLogo: 1 m_SplashScreenOverlayOpacity: 1 m_SplashScreenAnimation: 1 m_SplashScreenLogoStyle: 1 m_SplashScreenDrawMode: 0 m_SplashScreenBackgroundAnimationZoom: 1 m_SplashScreenLogoAnimationZoom: 1 m_SplashScreenBackgroundLandscapeAspect: 1 m_SplashScreenBackgroundPortraitAspect: 1 m_SplashScreenBackgroundLandscapeUvs: serializedVersion: 2 x: 0 y: 0 width: 1 height: 1 m_SplashScreenBackgroundPortraitUvs: serializedVersion: 2 x: 0 y: 0 width: 1 height: 1 m_SplashScreenLogos: [] m_VirtualRealitySplashScreen: {fileID: 0} m_HolographicTrackingLossScreen: {fileID: 0} defaultScreenWidth: 1024 defaultScreenHeight: 768 defaultScreenWidthWeb: 960 defaultScreenHeightWeb: 600 m_StereoRenderingPath: 0 m_ActiveColorSpace: 0 unsupportedMSAAFallback: 0 m_SpriteBatchVertexThreshold: 300 m_MTRendering: 1 mipStripping: 0 numberOfMipsStripped: 0 numberOfMipsStrippedPerMipmapLimitGroup: {} m_StackTraceTypes: 010000000100000001000000010000000100000001000000 iosShowActivityIndicatorOnLoading: -1 androidShowActivityIndicatorOnLoading: -1 iosUseCustomAppBackgroundBehavior: 0 allowedAutorotateToPortrait: 1 allowedAutorotateToPortraitUpsideDown: 1 allowedAutorotateToLandscapeRight: 1 allowedAutorotateToLandscapeLeft: 1 useOSAutorotation: 1 use32BitDisplayBuffer: 1 preserveFramebufferAlpha: 0 disableDepthAndStencilBuffers: 0 androidStartInFullscreen: 1 androidRenderOutsideSafeArea: 1 androidUseSwappy: 0 androidBlitType: 0 androidResizableWindow: 0 androidDefaultWindowWidth: 1920 androidDefaultWindowHeight: 1080 androidMinimumWindowWidth: 400 androidMinimumWindowHeight: 300 androidFullscreenMode: 1 androidAutoRotationBehavior: 1 defaultIsNativeResolution: 1 macRetinaSupport: 1 runInBackground: 1 captureSingleScreen: 0 muteOtherAudioSources: 0 Prepare IOS For Recording: 0 Force IOS Speakers When Recording: 0 deferSystemGesturesMode: 0 hideHomeButton: 0 submitAnalytics: 1 usePlayerLog: 1 dedicatedServerOptimizations: 0 bakeCollisionMeshes: 0 forceSingleInstance: 0 useFlipModelSwapchain: 1 resizableWindow: 1 useMacAppStoreValidation: 0 macAppStoreCategory: public.app-category.games gpuSkinning: 0 xboxPIXTextureCapture: 0 xboxEnableAvatar: 0 xboxEnableKinect: 0 xboxEnableKinectAutoTracking: 0 xboxEnableFitness: 0 visibleInBackground: 1 allowFullscreenSwitch: 1 fullscreenMode: 3 xboxSpeechDB: 0 xboxEnableHeadOrientation: 0 xboxEnableGuest: 0 xboxEnablePIXSampling: 0 metalFramebufferOnly: 0 xboxOneResolution: 0 xboxOneSResolution: 0 xboxOneXResolution: 3 xboxOneMonoLoggingLevel: 0 xboxOneLoggingLevel: 1 xboxOneDisableEsram: 0 xboxOneEnableTypeOptimization: 0 xboxOnePresentImmediateThreshold: 0 switchQueueCommandMemory: 0 switchQueueControlMemory: 16384 switchQueueComputeMemory: 262144 switchNVNShaderPoolsGranularity: 33554432 switchNVNDefaultPoolsGranularity: 16777216 switchNVNOtherPoolsGranularity: 16777216 switchGpuScratchPoolGranularity: 2097152 switchAllowGpuScratchShrinking: 0 switchNVNMaxPublicTextureIDCount: 0 switchNVNMaxPublicSamplerIDCount: 0 switchNVNGraphicsFirmwareMemory: 32 switchMaxWorkerMultiple: 8 stadiaPresentMode: 0 stadiaTargetFramerate: 0 vulkanNumSwapchainBuffers: 3 vulkanEnableSetSRGBWrite: 0 vulkanEnablePreTransform: 0 vulkanEnableLateAcquireNextImage: 0 vulkanEnableCommandBufferRecycling: 1 loadStoreDebugModeEnabled: 0 visionOSBundleVersion: 1.0 tvOSBundleVersion: 1.0 bundleVersion: 0.1 preloadedAssets: [] metroInputSource: 0 wsaTransparentSwapchain: 0 m_HolographicPauseOnTrackingLoss: 1 xboxOneDisableKinectGpuReservation: 1 xboxOneEnable7thCore: 1 vrSettings: enable360StereoCapture: 0 isWsaHolographicRemotingEnabled: 0 enableFrameTimingStats: 0 enableOpenGLProfilerGPURecorders: 1 allowHDRDisplaySupport: 0 useHDRDisplay: 0 hdrBitDepth: 0 m_ColorGamuts: 00000000 targetPixelDensity: 30 resolutionScalingMode: 0 resetResolutionOnWindowResize: 0 androidSupportedAspectRatio: 1 androidMaxAspectRatio: 2.1 applicationIdentifier: Standalone: com.DefaultCompany.UniTask buildNumber: Standalone: 0 VisionOS: 0 iPhone: 0 tvOS: 0 overrideDefaultApplicationIdentifier: 0 AndroidBundleVersionCode: 1 AndroidMinSdkVersion: 22 AndroidTargetSdkVersion: 0 AndroidPreferredInstallLocation: 1 aotOptions: stripEngineCode: 1 iPhoneStrippingLevel: 0 iPhoneScriptCallOptimization: 0 ForceInternetPermission: 0 ForceSDCardPermission: 0 CreateWallpaper: 0 APKExpansionFiles: 0 keepLoadedShadersAlive: 0 StripUnusedMeshComponents: 1 strictShaderVariantMatching: 0 VertexChannelCompressionMask: 4054 iPhoneSdkVersion: 988 iOSTargetOSVersionString: 12.0 tvOSSdkVersion: 0 tvOSRequireExtendedGameController: 0 tvOSTargetOSVersionString: 12.0 VisionOSSdkVersion: 0 VisionOSTargetOSVersionString: 1.0 uIPrerenderedIcon: 0 uIRequiresPersistentWiFi: 0 uIRequiresFullScreen: 1 uIStatusBarHidden: 1 uIExitOnSuspend: 0 uIStatusBarStyle: 0 appleTVSplashScreen: {fileID: 0} appleTVSplashScreen2x: {fileID: 0} tvOSSmallIconLayers: [] tvOSSmallIconLayers2x: [] tvOSLargeIconLayers: [] tvOSLargeIconLayers2x: [] tvOSTopShelfImageLayers: [] tvOSTopShelfImageLayers2x: [] tvOSTopShelfImageWideLayers: [] tvOSTopShelfImageWideLayers2x: [] iOSLaunchScreenType: 0 iOSLaunchScreenPortrait: {fileID: 0} iOSLaunchScreenLandscape: {fileID: 0} iOSLaunchScreenBackgroundColor: serializedVersion: 2 rgba: 0 iOSLaunchScreenFillPct: 100 iOSLaunchScreenSize: 100 iOSLaunchScreenCustomXibPath: iOSLaunchScreeniPadType: 0 iOSLaunchScreeniPadImage: {fileID: 0} iOSLaunchScreeniPadBackgroundColor: serializedVersion: 2 rgba: 0 iOSLaunchScreeniPadFillPct: 100 iOSLaunchScreeniPadSize: 100 iOSLaunchScreeniPadCustomXibPath: iOSLaunchScreenCustomStoryboardPath: iOSLaunchScreeniPadCustomStoryboardPath: iOSDeviceRequirements: [] iOSURLSchemes: [] macOSURLSchemes: [] iOSBackgroundModes: 0 iOSMetalForceHardShadows: 0 metalEditorSupport: 1 metalAPIValidation: 1 metalCompileShaderBinary: 0 iOSRenderExtraFrameOnPause: 0 iosCopyPluginsCodeInsteadOfSymlink: 0 appleDeveloperTeamID: iOSManualSigningProvisioningProfileID: tvOSManualSigningProvisioningProfileID: VisionOSManualSigningProvisioningProfileID: iOSManualSigningProvisioningProfileType: 0 tvOSManualSigningProvisioningProfileType: 0 VisionOSManualSigningProvisioningProfileType: 0 appleEnableAutomaticSigning: 0 iOSRequireARKit: 0 iOSAutomaticallyDetectAndAddCapabilities: 1 appleEnableProMotion: 0 shaderPrecisionModel: 0 clonedFromGUID: 5f34be1353de5cf4398729fda238591b templatePackageId: com.unity.template.2d@3.1.0 templateDefaultScene: Assets/Scenes/SampleScene.unity useCustomMainManifest: 0 useCustomLauncherManifest: 0 useCustomMainGradleTemplate: 0 useCustomLauncherGradleManifest: 0 useCustomBaseGradleTemplate: 0 useCustomGradlePropertiesTemplate: 0 useCustomGradleSettingsTemplate: 0 useCustomProguardFile: 0 AndroidTargetArchitectures: 1 AndroidTargetDevices: 0 AndroidSplashScreenScale: 0 androidSplashScreen: {fileID: 0} AndroidKeystoreName: '{inproject}: ' AndroidKeyaliasName: AndroidEnableArmv9SecurityFeatures: 0 AndroidBuildApkPerCpuArchitecture: 0 AndroidTVCompatibility: 0 AndroidIsGame: 1 AndroidEnableTango: 0 androidEnableBanner: 1 androidUseLowAccuracyLocation: 0 androidUseCustomKeystore: 0 m_AndroidBanners: - width: 320 height: 180 banner: {fileID: 0} androidGamepadSupportLevel: 0 chromeosInputEmulation: 1 AndroidMinifyRelease: 0 AndroidMinifyDebug: 0 AndroidValidateAppBundleSize: 1 AndroidAppBundleSizeToValidate: 100 m_BuildTargetIcons: [] m_BuildTargetPlatformIcons: [] m_BuildTargetBatching: [] m_BuildTargetShaderSettings: [] m_BuildTargetGraphicsJobs: - m_BuildTarget: MacStandaloneSupport m_GraphicsJobs: 0 - m_BuildTarget: Switch m_GraphicsJobs: 0 - m_BuildTarget: MetroSupport m_GraphicsJobs: 0 - m_BuildTarget: AppleTVSupport m_GraphicsJobs: 0 - m_BuildTarget: BJMSupport m_GraphicsJobs: 0 - m_BuildTarget: LinuxStandaloneSupport m_GraphicsJobs: 0 - m_BuildTarget: PS4Player m_GraphicsJobs: 0 - m_BuildTarget: iOSSupport m_GraphicsJobs: 0 - m_BuildTarget: WindowsStandaloneSupport m_GraphicsJobs: 0 - m_BuildTarget: XboxOnePlayer m_GraphicsJobs: 0 - m_BuildTarget: LuminSupport m_GraphicsJobs: 0 - m_BuildTarget: AndroidPlayer m_GraphicsJobs: 0 - m_BuildTarget: WebGLSupport m_GraphicsJobs: 0 m_BuildTargetGraphicsJobMode: - m_BuildTarget: PS4Player m_GraphicsJobMode: 0 - m_BuildTarget: XboxOnePlayer m_GraphicsJobMode: 0 m_BuildTargetGraphicsAPIs: - m_BuildTarget: AndroidPlayer m_APIs: 150000000b000000 m_Automatic: 1 - m_BuildTarget: iOSSupport m_APIs: 10000000 m_Automatic: 1 m_BuildTargetVRSettings: [] m_DefaultShaderChunkSizeInMB: 16 m_DefaultShaderChunkCount: 0 openGLRequireES31: 0 openGLRequireES31AEP: 0 openGLRequireES32: 0 m_TemplateCustomTags: {} mobileMTRendering: Android: 1 iPhone: 1 tvOS: 1 m_BuildTargetGroupLightmapEncodingQuality: [] m_BuildTargetGroupHDRCubemapEncodingQuality: [] m_BuildTargetGroupLightmapSettings: [] m_BuildTargetGroupLoadStoreDebugModeSettings: [] m_BuildTargetNormalMapEncoding: [] m_BuildTargetDefaultTextureCompressionFormat: [] playModeTestRunnerEnabled: 0 runPlayModeTestAsEditModeTest: 0 actionOnDotNetUnhandledException: 1 enableInternalProfiler: 0 logObjCUncaughtExceptions: 1 enableCrashReportAPI: 0 cameraUsageDescription: locationUsageDescription: microphoneUsageDescription: bluetoothUsageDescription: macOSTargetOSVersion: 10.13.0 switchNMETAOverride: switchNetLibKey: switchSocketMemoryPoolSize: 6144 switchSocketAllocatorPoolSize: 128 switchSocketConcurrencyLimit: 14 switchScreenResolutionBehavior: 2 switchUseCPUProfiler: 0 switchEnableFileSystemTrace: 0 switchLTOSetting: 0 switchApplicationID: 0x01004b9000490000 switchNSODependencies: switchCompilerFlags: switchTitleNames_0: switchTitleNames_1: switchTitleNames_2: switchTitleNames_3: switchTitleNames_4: switchTitleNames_5: switchTitleNames_6: switchTitleNames_7: switchTitleNames_8: switchTitleNames_9: switchTitleNames_10: switchTitleNames_11: switchTitleNames_12: switchTitleNames_13: switchTitleNames_14: switchTitleNames_15: switchPublisherNames_0: switchPublisherNames_1: switchPublisherNames_2: switchPublisherNames_3: switchPublisherNames_4: switchPublisherNames_5: switchPublisherNames_6: switchPublisherNames_7: switchPublisherNames_8: switchPublisherNames_9: switchPublisherNames_10: switchPublisherNames_11: switchPublisherNames_12: switchPublisherNames_13: switchPublisherNames_14: switchPublisherNames_15: switchIcons_0: {fileID: 0} switchIcons_1: {fileID: 0} switchIcons_2: {fileID: 0} switchIcons_3: {fileID: 0} switchIcons_4: {fileID: 0} switchIcons_5: {fileID: 0} switchIcons_6: {fileID: 0} switchIcons_7: {fileID: 0} switchIcons_8: {fileID: 0} switchIcons_9: {fileID: 0} switchIcons_10: {fileID: 0} switchIcons_11: {fileID: 0} switchIcons_12: {fileID: 0} switchIcons_13: {fileID: 0} switchIcons_14: {fileID: 0} switchIcons_15: {fileID: 0} switchSmallIcons_0: {fileID: 0} switchSmallIcons_1: {fileID: 0} switchSmallIcons_2: {fileID: 0} switchSmallIcons_3: {fileID: 0} switchSmallIcons_4: {fileID: 0} switchSmallIcons_5: {fileID: 0} switchSmallIcons_6: {fileID: 0} switchSmallIcons_7: {fileID: 0} switchSmallIcons_8: {fileID: 0} switchSmallIcons_9: {fileID: 0} switchSmallIcons_10: {fileID: 0} switchSmallIcons_11: {fileID: 0} switchSmallIcons_12: {fileID: 0} switchSmallIcons_13: {fileID: 0} switchSmallIcons_14: {fileID: 0} switchSmallIcons_15: {fileID: 0} switchManualHTML: switchAccessibleURLs: switchLegalInformation: switchMainThreadStackSize: 1048576 switchPresenceGroupId: switchLogoHandling: 0 switchReleaseVersion: 0 switchDisplayVersion: 1.0.0 switchStartupUserAccount: 0 switchSupportedLanguagesMask: 0 switchLogoType: 0 switchApplicationErrorCodeCategory: switchUserAccountSaveDataSize: 0 switchUserAccountSaveDataJournalSize: 0 switchApplicationAttribute: 0 switchCardSpecSize: -1 switchCardSpecClock: -1 switchRatingsMask: 0 switchRatingsInt_0: 0 switchRatingsInt_1: 0 switchRatingsInt_2: 0 switchRatingsInt_3: 0 switchRatingsInt_4: 0 switchRatingsInt_5: 0 switchRatingsInt_6: 0 switchRatingsInt_7: 0 switchRatingsInt_8: 0 switchRatingsInt_9: 0 switchRatingsInt_10: 0 switchRatingsInt_11: 0 switchRatingsInt_12: 0 switchLocalCommunicationIds_0: switchLocalCommunicationIds_1: switchLocalCommunicationIds_2: switchLocalCommunicationIds_3: switchLocalCommunicationIds_4: switchLocalCommunicationIds_5: switchLocalCommunicationIds_6: switchLocalCommunicationIds_7: switchParentalControl: 0 switchAllowsScreenshot: 1 switchAllowsVideoCapturing: 1 switchAllowsRuntimeAddOnContentInstall: 0 switchDataLossConfirmation: 0 switchUserAccountLockEnabled: 0 switchSystemResourceMemory: 16777216 switchSupportedNpadStyles: 3 switchNativeFsCacheSize: 32 switchIsHoldTypeHorizontal: 0 switchSupportedNpadCount: 8 switchEnableTouchScreen: 1 switchSocketConfigEnabled: 0 switchTcpInitialSendBufferSize: 32 switchTcpInitialReceiveBufferSize: 64 switchTcpAutoSendBufferSizeMax: 256 switchTcpAutoReceiveBufferSizeMax: 256 switchUdpSendBufferSize: 9 switchUdpReceiveBufferSize: 42 switchSocketBufferEfficiency: 4 switchSocketInitializeEnabled: 1 switchNetworkInterfaceManagerInitializeEnabled: 1 switchUseNewStyleFilepaths: 0 switchUseLegacyFmodPriorities: 0 switchUseMicroSleepForYield: 1 switchEnableRamDiskSupport: 0 switchMicroSleepForYieldTime: 25 switchRamDiskSpaceSize: 12 ps4NPAgeRating: 12 ps4NPTitleSecret: ps4NPTrophyPackPath: ps4ParentalLevel: 11 ps4ContentID: ED1633-NPXX51362_00-0000000000000000 ps4Category: 0 ps4MasterVersion: 01.00 ps4AppVersion: 01.00 ps4AppType: 0 ps4ParamSfxPath: ps4VideoOutPixelFormat: 0 ps4VideoOutInitialWidth: 1920 ps4VideoOutBaseModeInitialWidth: 1920 ps4VideoOutReprojectionRate: 60 ps4PronunciationXMLPath: ps4PronunciationSIGPath: ps4BackgroundImagePath: ps4StartupImagePath: ps4StartupImagesFolder: ps4IconImagesFolder: ps4SaveDataImagePath: ps4SdkOverride: ps4BGMPath: ps4ShareFilePath: ps4ShareOverlayImagePath: ps4PrivacyGuardImagePath: ps4ExtraSceSysFile: ps4NPtitleDatPath: ps4RemotePlayKeyAssignment: -1 ps4RemotePlayKeyMappingDir: ps4PlayTogetherPlayerCount: 0 ps4EnterButtonAssignment: 1 ps4ApplicationParam1: 0 ps4ApplicationParam2: 0 ps4ApplicationParam3: 0 ps4ApplicationParam4: 0 ps4DownloadDataSize: 0 ps4GarlicHeapSize: 2048 ps4ProGarlicHeapSize: 2560 playerPrefsMaxSize: 32768 ps4Passcode: frAQBc8Wsa1xVPfvJcrgRYwTiizs2trQ ps4pnSessions: 1 ps4pnPresence: 1 ps4pnFriends: 1 ps4pnGameCustomData: 1 playerPrefsSupport: 0 enableApplicationExit: 0 resetTempFolder: 1 restrictedAudioUsageRights: 0 ps4UseResolutionFallback: 0 ps4ReprojectionSupport: 0 ps4UseAudio3dBackend: 0 ps4UseLowGarlicFragmentationMode: 1 ps4SocialScreenEnabled: 0 ps4ScriptOptimizationLevel: 0 ps4Audio3dVirtualSpeakerCount: 14 ps4attribCpuUsage: 0 ps4PatchPkgPath: ps4PatchLatestPkgPath: ps4PatchChangeinfoPath: ps4PatchDayOne: 0 ps4attribUserManagement: 0 ps4attribMoveSupport: 0 ps4attrib3DSupport: 0 ps4attribShareSupport: 0 ps4attribExclusiveVR: 0 ps4disableAutoHideSplash: 0 ps4videoRecordingFeaturesUsed: 0 ps4contentSearchFeaturesUsed: 0 ps4CompatibilityPS5: 0 ps4AllowPS5Detection: 0 ps4GPU800MHz: 1 ps4attribEyeToEyeDistanceSettingVR: 0 ps4IncludedModules: [] ps4attribVROutputEnabled: 0 monoEnv: splashScreenBackgroundSourceLandscape: {fileID: 0} splashScreenBackgroundSourcePortrait: {fileID: 0} blurSplashScreenBackground: 1 spritePackerPolicy: webGLMemorySize: 16 webGLExceptionSupport: 1 webGLNameFilesAsHashes: 0 webGLShowDiagnostics: 0 webGLDataCaching: 1 webGLDebugSymbols: 0 webGLEmscriptenArgs: webGLModulesDirectory: webGLTemplate: APPLICATION:Default webGLAnalyzeBuildSize: 0 webGLUseEmbeddedResources: 0 webGLCompressionFormat: 1 webGLWasmArithmeticExceptions: 0 webGLLinkerTarget: 1 webGLThreadsSupport: 0 webGLDecompressionFallback: 0 webGLInitialMemorySize: 32 webGLMaximumMemorySize: 2048 webGLMemoryGrowthMode: 2 webGLMemoryLinearGrowthStep: 16 webGLMemoryGeometricGrowthStep: 0.2 webGLMemoryGeometricGrowthCap: 96 webGLPowerPreference: 2 scriptingDefineSymbols: {} additionalCompilerArguments: {} platformArchitecture: {} scriptingBackend: Android: 1 Server: 1 Standalone: 1 il2cppCompilerConfiguration: {} il2cppCodeGeneration: {} managedStrippingLevel: Android: 1 EmbeddedLinux: 1 GameCoreScarlett: 1 GameCoreXboxOne: 1 Nintendo Switch: 1 PS4: 1 PS5: 1 QNX: 1 Stadia: 1 Standalone: 1 VisionOS: 1 WebGL: 1 Windows Store Apps: 1 XboxOne: 1 iPhone: 1 tvOS: 1 incrementalIl2cppBuild: {} suppressCommonWarnings: 1 allowUnsafeCode: 0 useDeterministicCompilation: 1 additionalIl2CppArgs: scriptingRuntimeVersion: 1 gcIncremental: 0 gcWBarrierValidation: 0 apiCompatibilityLevelPerPlatform: Standalone: 6 m_RenderingPath: 1 m_MobileRenderingPath: 1 metroPackageName: Template_2D metroPackageVersion: metroCertificatePath: metroCertificatePassword: metroCertificateSubject: metroCertificateIssuer: metroCertificateNotAfter: 0000000000000000 metroApplicationDescription: Template_2D wsaImages: {} metroTileShortName: metroTileShowName: 0 metroMediumTileShowName: 0 metroLargeTileShowName: 0 metroWideTileShowName: 0 metroSupportStreamingInstall: 0 metroLastRequiredScene: 0 metroDefaultTileSize: 1 metroTileForegroundText: 2 metroTileBackgroundColor: {r: 0.13333334, g: 0.17254902, b: 0.21568628, a: 0} metroSplashScreenBackgroundColor: {r: 0.12941177, g: 0.17254902, b: 0.21568628, a: 1} metroSplashScreenUseBackgroundColor: 0 syncCapabilities: 0 platformCapabilities: {} metroTargetDeviceFamilies: {} metroFTAName: metroFTAFileTypes: [] metroProtocolName: vcxProjDefaultLanguage: XboxOneProductId: XboxOneUpdateKey: XboxOneSandboxId: XboxOneContentId: XboxOneTitleId: XboxOneSCId: XboxOneGameOsOverridePath: XboxOnePackagingOverridePath: XboxOneAppManifestOverridePath: XboxOneVersion: 1.0.0.0 XboxOnePackageEncryption: 0 XboxOnePackageUpdateGranularity: 2 XboxOneDescription: XboxOneLanguage: - enus XboxOneCapability: [] XboxOneGameRating: {} XboxOneIsContentPackage: 0 XboxOneEnhancedXboxCompatibilityMode: 0 XboxOneEnableGPUVariability: 1 XboxOneSockets: {} XboxOneSplashScreen: {fileID: 0} XboxOneAllowedProductIds: [] XboxOnePersistentLocalStorageSize: 0 XboxOneXTitleMemory: 8 XboxOneOverrideIdentityName: XboxOneOverrideIdentityPublisher: vrEditorSettings: {} cloudServicesEnabled: UNet: 1 luminIcon: m_Name: m_ModelFolderPath: m_PortalFolderPath: luminCert: m_CertPath: m_SignPackage: 1 luminIsChannelApp: 0 luminVersion: m_VersionCode: 1 m_VersionName: hmiPlayerDataPath: hmiForceSRGBBlit: 1 embeddedLinuxEnableGamepadInput: 1 hmiLogStartupTiming: 0 hmiCpuConfiguration: apiCompatibilityLevel: 6 activeInputHandler: 0 windowsGamepadBackendHint: 0 cloudProjectId: framebufferDepthMemorylessMode: 0 qualitySettingsNames: [] projectName: organizationId: cloudEnabled: 0 legacyClampBlendShapeWeights: 1 hmiLoadingImage: {fileID: 0} platformRequiresReadableAssets: 0 virtualTexturingSupportEnabled: 0 insecureHttpOption: 0 ================================================ FILE: src/UniTask/ProjectSettings/ProjectVersion.txt ================================================ m_EditorVersion: 2022.3.39f1 m_EditorVersionWithRevision: 2022.3.39f1 (4e1b0f82c39a) ================================================ FILE: src/UniTask/ProjectSettings/QualitySettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!47 &1 QualitySettings: m_ObjectHideFlags: 0 serializedVersion: 5 m_CurrentQuality: 3 m_QualitySettings: - serializedVersion: 2 name: Very Low pixelLightCount: 0 shadows: 0 shadowResolution: 0 shadowProjection: 1 shadowCascades: 1 shadowDistance: 15 shadowNearPlaneOffset: 3 shadowCascade2Split: 0.33333334 shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667} shadowmaskMode: 0 blendWeights: 1 textureQuality: 1 anisotropicTextures: 0 antiAliasing: 0 softParticles: 0 softVegetation: 0 realtimeReflectionProbes: 0 billboardsFaceCameraPosition: 0 vSyncCount: 0 lodBias: 0.3 maximumLODLevel: 0 particleRaycastBudget: 4 asyncUploadTimeSlice: 2 asyncUploadBufferSize: 16 resolutionScalingFixedDPIFactor: 1 excludedTargetPlatforms: [] - serializedVersion: 2 name: Low pixelLightCount: 0 shadows: 0 shadowResolution: 0 shadowProjection: 1 shadowCascades: 1 shadowDistance: 20 shadowNearPlaneOffset: 3 shadowCascade2Split: 0.33333334 shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667} shadowmaskMode: 0 blendWeights: 2 textureQuality: 0 anisotropicTextures: 0 antiAliasing: 0 softParticles: 0 softVegetation: 0 realtimeReflectionProbes: 0 billboardsFaceCameraPosition: 0 vSyncCount: 0 lodBias: 0.4 maximumLODLevel: 0 particleRaycastBudget: 16 asyncUploadTimeSlice: 2 asyncUploadBufferSize: 16 resolutionScalingFixedDPIFactor: 1 excludedTargetPlatforms: [] - serializedVersion: 2 name: Medium pixelLightCount: 1 shadows: 0 shadowResolution: 0 shadowProjection: 1 shadowCascades: 1 shadowDistance: 20 shadowNearPlaneOffset: 3 shadowCascade2Split: 0.33333334 shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667} shadowmaskMode: 0 blendWeights: 2 textureQuality: 0 anisotropicTextures: 0 antiAliasing: 0 softParticles: 0 softVegetation: 0 realtimeReflectionProbes: 0 billboardsFaceCameraPosition: 0 vSyncCount: 1 lodBias: 0.7 maximumLODLevel: 0 particleRaycastBudget: 64 asyncUploadTimeSlice: 2 asyncUploadBufferSize: 16 resolutionScalingFixedDPIFactor: 1 excludedTargetPlatforms: [] - serializedVersion: 2 name: High pixelLightCount: 2 shadows: 0 shadowResolution: 1 shadowProjection: 1 shadowCascades: 2 shadowDistance: 40 shadowNearPlaneOffset: 3 shadowCascade2Split: 0.33333334 shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667} shadowmaskMode: 1 blendWeights: 2 textureQuality: 0 anisotropicTextures: 0 antiAliasing: 0 softParticles: 0 softVegetation: 1 realtimeReflectionProbes: 0 billboardsFaceCameraPosition: 0 vSyncCount: 1 lodBias: 1 maximumLODLevel: 0 particleRaycastBudget: 256 asyncUploadTimeSlice: 2 asyncUploadBufferSize: 16 resolutionScalingFixedDPIFactor: 1 excludedTargetPlatforms: [] - serializedVersion: 2 name: Very High pixelLightCount: 3 shadows: 0 shadowResolution: 2 shadowProjection: 1 shadowCascades: 2 shadowDistance: 70 shadowNearPlaneOffset: 3 shadowCascade2Split: 0.33333334 shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667} shadowmaskMode: 1 blendWeights: 4 textureQuality: 0 anisotropicTextures: 0 antiAliasing: 0 softParticles: 0 softVegetation: 1 realtimeReflectionProbes: 0 billboardsFaceCameraPosition: 0 vSyncCount: 1 lodBias: 1.5 maximumLODLevel: 0 particleRaycastBudget: 1024 asyncUploadTimeSlice: 2 asyncUploadBufferSize: 16 resolutionScalingFixedDPIFactor: 1 excludedTargetPlatforms: [] - serializedVersion: 2 name: Ultra pixelLightCount: 4 shadows: 0 shadowResolution: 0 shadowProjection: 1 shadowCascades: 4 shadowDistance: 150 shadowNearPlaneOffset: 3 shadowCascade2Split: 0.33333334 shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667} shadowmaskMode: 1 blendWeights: 4 textureQuality: 0 anisotropicTextures: 0 antiAliasing: 0 softParticles: 0 softVegetation: 1 realtimeReflectionProbes: 0 billboardsFaceCameraPosition: 0 vSyncCount: 1 lodBias: 2 maximumLODLevel: 0 particleRaycastBudget: 4096 asyncUploadTimeSlice: 2 asyncUploadBufferSize: 16 resolutionScalingFixedDPIFactor: 1 excludedTargetPlatforms: [] m_PerPlatformDefaultQuality: Android: 2 Nintendo 3DS: 5 Nintendo Switch: 5 PS4: 5 PSM: 5 PSP2: 2 Standalone: 5 Tizen: 2 WebGL: 3 WiiU: 5 Windows Store Apps: 5 XboxOne: 5 iPhone: 2 tvOS: 2 ================================================ FILE: src/UniTask/ProjectSettings/SceneTemplateSettings.json ================================================ { "templatePinStates": [], "dependencyTypeInfos": [ { "userAdded": false, "type": "UnityEngine.AnimationClip", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEditor.Animations.AnimatorController", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.AnimatorOverrideController", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEditor.Audio.AudioMixerController", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.ComputeShader", "defaultInstantiationMode": 1 }, { "userAdded": false, "type": "UnityEngine.Cubemap", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.GameObject", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEditor.LightingDataAsset", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.LightingSettings", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.Material", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEditor.MonoScript", "defaultInstantiationMode": 1 }, { "userAdded": false, "type": "UnityEngine.PhysicMaterial", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.PhysicsMaterial2D", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.Rendering.PostProcessing.PostProcessProfile", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.Rendering.PostProcessing.PostProcessResources", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.Rendering.VolumeProfile", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEditor.SceneAsset", "defaultInstantiationMode": 1 }, { "userAdded": false, "type": "UnityEngine.Shader", "defaultInstantiationMode": 1 }, { "userAdded": false, "type": "UnityEngine.ShaderVariantCollection", "defaultInstantiationMode": 1 }, { "userAdded": false, "type": "UnityEngine.Texture", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.Texture2D", "defaultInstantiationMode": 0 }, { "userAdded": false, "type": "UnityEngine.Timeline.TimelineAsset", "defaultInstantiationMode": 0 } ], "defaultDependencyTypeInfo": { "userAdded": false, "type": "", "defaultInstantiationMode": 1 }, "newSceneOverride": 0 } ================================================ FILE: src/UniTask/ProjectSettings/TagManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!78 &1 TagManager: serializedVersion: 2 tags: [] layers: - Default - TransparentFX - Ignore Raycast - - Water - UI - - - - - - - - - - - - - - - - - - - - - - - - - - m_SortingLayers: - name: Default uniqueID: 0 locked: 0 ================================================ FILE: src/UniTask/ProjectSettings/TimeManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!5 &1 TimeManager: m_ObjectHideFlags: 0 Fixed Timestep: 0.02 Maximum Allowed Timestep: 0.1 m_TimeScale: 1 Maximum Particle Timestep: 0.03 ================================================ FILE: src/UniTask/ProjectSettings/UnityConnectSettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!310 &1 UnityConnectSettings: m_ObjectHideFlags: 0 serializedVersion: 1 m_Enabled: 0 m_TestMode: 0 m_EventOldUrl: https://api.uca.cloud.unity3d.com/v1/events m_EventUrl: https://cdp.cloud.unity3d.com/v1/events m_ConfigUrl: https://config.uca.cloud.unity3d.com m_DashboardUrl: https://dashboard.unity3d.com m_TestInitMode: 0 CrashReportingSettings: m_EventUrl: https://perf-events.cloud.unity3d.com m_Enabled: 0 m_LogBufferSize: 10 m_CaptureEditorExceptions: 1 UnityPurchasingSettings: m_Enabled: 0 m_TestMode: 0 UnityAnalyticsSettings: m_Enabled: 0 m_TestMode: 0 m_InitializeOnStartup: 1 m_PackageRequiringCoreStatsPresent: 0 UnityAdsSettings: m_Enabled: 0 m_InitializeOnStartup: 1 m_TestMode: 0 m_IosGameId: m_AndroidGameId: m_GameIds: {} m_GameId: PerformanceReportingSettings: m_Enabled: 0 ================================================ FILE: src/UniTask/ProjectSettings/VFXManager.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!937362698 &1 VFXManager: m_ObjectHideFlags: 0 m_IndirectShader: {fileID: 0} m_RenderPipeSettingsPath: ================================================ FILE: src/UniTask/ProjectSettings/VersionControlSettings.asset ================================================ %YAML 1.1 %TAG !u! tag:unity3d.com,2011: --- !u!890905787 &1 VersionControlSettings: m_ObjectHideFlags: 0 m_Mode: Visible Meta Files m_CollabEditorSettings: inProgressEnabled: 1 ================================================ FILE: src/UniTask/ProjectSettings/XRSettings.asset ================================================ { "m_SettingKeys": [ "VR Device Disabled", "VR Device User Alert" ], "m_SettingValues": [ "False", "False" ] } ================================================ FILE: src/UniTask.Analyzer/Properties/launchSettings.json ================================================ { "profiles": { "UniTask.Analyzer": { "commandName": "DebugRoslynComponent", "targetProject": "..\\UniTask.NetCoreSandbox\\UniTask.NetCoreSandbox.csproj" } } } ================================================ FILE: src/UniTask.Analyzer/UniTask.Analyzer.csproj ================================================ library netstandard2.0 latest enable true $(TargetsForTfmSpecificContentInPackage);PackBuildOutputs false false true true runtime; build; native; contentfiles; analyzers all ================================================ FILE: src/UniTask.Analyzer/UniTaskAnalyzer.cs ================================================ #pragma warning disable RS2008 using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.Diagnostics; using Microsoft.CodeAnalysis.Operations; using System.Collections.Immutable; using System.Threading; namespace UniTask.Analyzer { [DiagnosticAnalyzer(LanguageNames.CSharp)] public class UniTaskAnalyzer : DiagnosticAnalyzer { private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor( id: "UNITASK001", title: "UniTaskAnalyzer001: Must pass CancellationToken", messageFormat: "Must pass CancellationToken", category: "Usage", defaultSeverity: DiagnosticSeverity.Error, isEnabledByDefault: true, description: "Pass CancellationToken or CancellationToken.None."); public override ImmutableArray SupportedDiagnostics { get { return ImmutableArray.Create(Rule); } } public override void Initialize(AnalysisContext context) { context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.EnableConcurrentExecution(); context.RegisterOperationAction(AnalyzeOperation, OperationKind.Invocation); } private static void AnalyzeOperation(OperationAnalysisContext context) { var token = context.Compilation.GetTypeByMetadataName(typeof(CancellationToken).FullName); if (token == null) return; if (context.Operation is IInvocationOperation invocation) { foreach (var arg in invocation.Arguments) { if (arg.ArgumentKind == ArgumentKind.DefaultValue) { if (SymbolEqualityComparer.Default.Equals(arg.Parameter.Type, token)) { var diagnostic = Diagnostic.Create(Rule, arg.Syntax.GetLocation()); context.ReportDiagnostic(diagnostic); } } } } } } } ================================================ FILE: src/UniTask.NetCore/NetCore/AsyncEnumerableExtensions.cs ================================================ #if !NETSTANDARD2_0 #pragma warning disable 0649 using System; using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; using System.Threading.Tasks.Sources; namespace Cysharp.Threading.Tasks { public static class AsyncEnumerableExtensions { public static IUniTaskAsyncEnumerable AsUniTaskAsyncEnumerable(this IAsyncEnumerable source) { return new AsyncEnumerableToUniTaskAsyncEnumerable(source); } public static IAsyncEnumerable AsAsyncEnumerable(this IUniTaskAsyncEnumerable source) { return new UniTaskAsyncEnumerableToAsyncEnumerable(source); } sealed class AsyncEnumerableToUniTaskAsyncEnumerable : IUniTaskAsyncEnumerable { readonly IAsyncEnumerable source; public AsyncEnumerableToUniTaskAsyncEnumerable(IAsyncEnumerable source) { this.source = source; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new Enumerator(source.GetAsyncEnumerator(cancellationToken)); } sealed class Enumerator : IUniTaskAsyncEnumerator { readonly IAsyncEnumerator enumerator; public Enumerator(IAsyncEnumerator enumerator) { this.enumerator = enumerator; } public T Current => enumerator.Current; public async UniTask DisposeAsync() { await enumerator.DisposeAsync(); } public async UniTask MoveNextAsync() { return await enumerator.MoveNextAsync(); } } } sealed class UniTaskAsyncEnumerableToAsyncEnumerable : IAsyncEnumerable { readonly IUniTaskAsyncEnumerable source; public UniTaskAsyncEnumerableToAsyncEnumerable(IUniTaskAsyncEnumerable source) { this.source = source; } public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new Enumerator(source.GetAsyncEnumerator(cancellationToken)); } sealed class Enumerator : IAsyncEnumerator { readonly IUniTaskAsyncEnumerator enumerator; public Enumerator(IUniTaskAsyncEnumerator enumerator) { this.enumerator = enumerator; } public T Current => enumerator.Current; public ValueTask DisposeAsync() { return enumerator.DisposeAsync(); } public ValueTask MoveNextAsync() { return enumerator.MoveNextAsync(); } } } } } #endif ================================================ FILE: src/UniTask.NetCore/NetCore/UniTask.Delay.cs ================================================ //using Cysharp.Threading.Tasks.Internal; //using System; //using System.Collections.Concurrent; //using System.Runtime.CompilerServices; //using System.Threading; //namespace Cysharp.Threading.Tasks //{ // public partial struct UniTask // { // public static UniTask Delay() // { // return default; // } // sealed class DelayPromise : IUniTaskSource // { // public void GetResult(short token) // { // throw new NotImplementedException(); // } // public UniTaskStatus GetStatus(short token) // { // throw new NotImplementedException(); // } // public void OnCompleted(Action continuation, object state, short token) // { // throw new NotImplementedException(); // } // public UniTaskStatus UnsafeGetStatus() // { // throw new NotImplementedException(); // } // } // } //} ================================================ FILE: src/UniTask.NetCore/NetCore/UniTask.Run.cs ================================================ using System; using System.Threading; namespace Cysharp.Threading.Tasks { public partial struct UniTask { /// Run action on the threadPool and return to current SynchronizationContext if configureAwait = true. 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(); } } /// Run action on the threadPool and return to current SynchronizationContext if configureAwait = true. public static async UniTask Run(Action 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); } } /// Run action on the threadPool and return to current SynchronizationContext if configureAwait = true. public static async UniTask Run(Func 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(); } } /// Run action on the threadPool and return to current SynchronizationContext if configureAwait = true. public static async UniTask Run(Func 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); } } } } ================================================ FILE: src/UniTask.NetCore/NetCore/UniTask.Yield.cs ================================================ using Cysharp.Threading.Tasks.Internal; using System; using System.Collections.Concurrent; using System.Runtime.CompilerServices; using System.Threading; namespace Cysharp.Threading.Tasks { public partial struct UniTask { public static UniTask.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 { #if NETCOREAPP3_1 ThreadPool.UnsafeQueueUserWorkItem(ThreadPoolWorkItem.Create(continuation), false); #else ThreadPool.UnsafeQueueUserWorkItem(WaitCallbackDelegate, continuation); #endif } } static void Continuation(object state) { ((Action)state).Invoke(); } } #if NETCOREAPP3_1 sealed class ThreadPoolWorkItem : IThreadPoolWorkItem, ITaskPoolNode { static TaskPool pool; ThreadPoolWorkItem nextNode; public ref ThreadPoolWorkItem NextNode => ref nextNode; static ThreadPoolWorkItem() { TaskPool.RegisterSizeGetter(typeof(ThreadPoolWorkItem), () => pool.Size); } Action continuation; [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ThreadPoolWorkItem Create(Action continuation) { if (!pool.TryPop(out var item)) { item = new ThreadPoolWorkItem(); } item.continuation = continuation; return item; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Execute() { var call = continuation; continuation = null; if (call != null) { pool.TryPush(this); call.Invoke(); } } } #endif } } } ================================================ FILE: src/UniTask.NetCore/UniTask.NetCore.csproj ================================================  net6.0;net7.0;netstandard2.1;netstandard2.0 UniTask 8.0 Cysharp.Threading.Tasks UNITASK_NETCORE true $(NoWarn);CS1591 true UniTask Provides an efficient async/await integration to Unity and .NET Core. ================================================ FILE: src/UniTask.NetCoreSandbox/Program.cs ================================================ #pragma warning disable CS1998 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 Program { static async Task Main(string[] args) { var cts = new CancellationTokenSource(); // OK. await FooAsync(10, cts.Token); // NG(Compiler Error) // await FooAsync(10); } static async UniTask FooAsync(int x, CancellationToken cancellationToken = default) { await UniTask.Yield(); } } } ================================================ FILE: src/UniTask.NetCoreSandbox/UniTask.NetCoreSandbox.csproj ================================================ Exe net7.0 NetCoreSandbox false Analyzer ================================================ FILE: src/UniTask.NetCoreTests/AsyncLazyTest.cs ================================================ using Cysharp.Threading.Tasks; using FluentAssertions; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Channels; using Cysharp.Threading.Tasks.Linq; using System.Threading.Tasks; using Xunit; namespace NetCoreTests { public class AsyncLazyTest { [Fact] public async Task LazyLazy() { { var l = UniTask.Lazy(() => After()); var a = AwaitAwait(l.Task); var b = AwaitAwait(l.Task); var c = AwaitAwait(l.Task); await a; await b; await c; } { var l = UniTask.Lazy(() => AfterException()); var a = AwaitAwait(l.Task); var b = AwaitAwait(l.Task); var c = AwaitAwait(l.Task); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); } } [Fact] public async Task LazyImmediate() { { var l = UniTask.Lazy(() => UniTask.FromResult(1).AsUniTask()); var a = AwaitAwait(l.Task); var b = AwaitAwait(l.Task); var c = AwaitAwait(l.Task); await a; await b; await c; } { var l = UniTask.Lazy(() => UniTask.FromException(new TaskTestException())); var a = AwaitAwait(l.Task); var b = AwaitAwait(l.Task); var c = AwaitAwait(l.Task); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); } } static async UniTask AwaitAwait(UniTask t) { await t; } async UniTask After() { await UniTask.Yield(); Thread.Sleep(TimeSpan.FromSeconds(1)); await UniTask.Yield(); await UniTask.Yield(); } async UniTask AfterException() { await UniTask.Yield(); Thread.Sleep(TimeSpan.FromSeconds(1)); await UniTask.Yield(); throw new TaskTestException(); } } public class AsyncLazyTest2 { [Fact] public async Task LazyLazy() { { var l = UniTask.Lazy(() => After()); var a = AwaitAwait(l.Task); var b = AwaitAwait(l.Task); var c = AwaitAwait(l.Task); var a2 = await a; var b2 = await b; var c2 = await c; (a2, b2, c2).Should().Be((10, 10, 10)); } { var l = UniTask.Lazy(() => AfterException()); var a = AwaitAwait(l.Task); var b = AwaitAwait(l.Task); var c = AwaitAwait(l.Task); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); } } [Fact] public async Task LazyImmediate() { { var l = UniTask.Lazy(() => UniTask.FromResult(1)); var a = AwaitAwait(l.Task); var b = AwaitAwait(l.Task); var c = AwaitAwait(l.Task); var a2 = await a; var b2 = await b; var c2 = await c; (a2, b2, c2).Should().Be((1, 1, 1)); } { var l = UniTask.Lazy(() => UniTask.FromException(new TaskTestException())); var a = AwaitAwait(l.Task); var b = AwaitAwait(l.Task); var c = AwaitAwait(l.Task); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); } } static async UniTask AwaitAwait(UniTask t) { return await t; } async UniTask After() { await UniTask.Yield(); Thread.Sleep(TimeSpan.FromSeconds(1)); await UniTask.Yield(); await UniTask.Yield(); return 10; } async UniTask AfterException() { await UniTask.Yield(); Thread.Sleep(TimeSpan.FromSeconds(1)); await UniTask.Yield(); throw new TaskTestException(); } } } ================================================ FILE: src/UniTask.NetCoreTests/AsyncReactivePropertyTest.cs ================================================ 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(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().Equal(new[] { 99, 100, 100, 100, 131 }); } [Fact] public async Task WithoutCurrent() { var rp = new AsyncReactiveProperty(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().Equal(new[] { 100, 100, 100, 131, 191 }); } //[Fact] //public async Task StateIteration() //{ // var rp = new ReadOnlyAsyncReactiveProperty(99); // var setter = rp.GetSetter(); // var f = await rp.FirstAsync(); // f.Should().Be(99); // var array = rp.Take(5).ToArrayAsync(); // setter(100); // setter(100); // setter(100); // setter(131); // var ar = await array; // ar.Should().Equal(new[] { 99, 100, 100, 100, 131 }); //} //[Fact] //public async Task StateWithoutCurrent() //{ // var rp = new ReadOnlyAsyncReactiveProperty(99); // var setter = rp.GetSetter(); // var array = rp.WithoutCurrent().Take(5).ToArrayAsync(); // setter(100); // setter(100); // setter(100); // setter(131); // setter(191); // var ar = await array; // ar.Should().Equal(new[] { 100, 100, 100, 131, 191 }); //} [Fact] public void StateFromEnumeration() { var rp = new AsyncReactiveProperty(10); var state = rp.ToReadOnlyAsyncReactiveProperty(CancellationToken.None); rp.Value = 10; state.Value.Should().Be(10); rp.Value = 20; state.Value.Should().Be(20); state.Dispose(); rp.Value = 30; state.Value.Should().Be(20); } [Fact] public async Task WaitAsyncTest() { var rp = new AsyncReactiveProperty(128); var f = await rp.FirstAsync(); f.Should().Be(128); { var t = rp.WaitAsync(); rp.Value = 99; rp.Value = 100; var v = await t; v.Should().Be(99); } { var t = rp.WaitAsync(); rp.Value = 99; rp.Value = 100; var v = await t; v.Should().Be(99); } } [Fact] public async Task WaitAsyncCancellationTest() { var cts = new CancellationTokenSource(); var rp = new AsyncReactiveProperty(128); var t = rp.WaitAsync(cts.Token); cts.Cancel(); rp.Value = 99; rp.Value = 100; await Assert.ThrowsAsync(async () => { await t; }); } [Fact] public async Task ReadOnlyWaitAsyncTest() { var rp = new AsyncReactiveProperty(128); var rrp = rp.ToReadOnlyAsyncReactiveProperty(CancellationToken.None); var t = rrp.WaitAsync(); rp.Value = 99; rp.Value = 100; var v = await t; v.Should().Be(99); } [Fact] public async Task ReadOnlyWaitAsyncCancellationTest() { var cts = new CancellationTokenSource(); var rp = new AsyncReactiveProperty(128); var rrp = rp.ToReadOnlyAsyncReactiveProperty(CancellationToken.None); var t = rrp.WaitAsync(cts.Token); cts.Cancel(); rp.Value = 99; rp.Value = 100; await Assert.ThrowsAsync(async () => { await t; }); } } } ================================================ FILE: src/UniTask.NetCoreTests/CancellationTokenTest.cs ================================================ 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(); } } } ================================================ FILE: src/UniTask.NetCoreTests/ChannelTest.cs ================================================ 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, Cysharp.Threading.Tasks.Channel) CreateChannel() { var reference = System.Threading.Channels.Channel.CreateUnbounded(new UnboundedChannelOptions { AllowSynchronousContinuations = true, SingleReader = true, SingleWriter = false }); var channel = Cysharp.Threading.Tasks.Channel.CreateSingleConsumerUnbounded(); 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(async () => await wait1)).Should().Be(ex); (await Assert.ThrowsAsync(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(async () => await wait1)).Should().Be(ex); (await Assert.ThrowsAsync(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(async () => await wait1)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(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().Equal(new[] { 10, 20, 30 }); (await ta2).Should().Equal(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(async () => await ta1); (await Assert.ThrowsAsync(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(async () => await ta1); (await Assert.ThrowsAsync(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(async () => await ta1); (await Assert.ThrowsAsync(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(async () => await ta1); (await Assert.ThrowsAsync(async () => await ta2)).CancellationToken.Should().Be(cts2.Token); } } } } ================================================ FILE: src/UniTask.NetCoreTests/CompletionSourceTest.cs ================================================ using Cysharp.Threading.Tasks; using FluentAssertions; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Channels; using Cysharp.Threading.Tasks.Linq; using System.Threading.Tasks; using Xunit; namespace NetCoreTests { public class CompletionSourceTest { [Fact] public async Task SetFirst() { { var tcs = new UniTaskCompletionSource(); tcs.TrySetResult(); await tcs.Task; // ok. await tcs.Task; // ok. tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded); } { var tcs = new UniTaskCompletionSource(); tcs.TrySetException(new TestException()); await Assert.ThrowsAsync(async () => await tcs.Task); await Assert.ThrowsAsync(async () => await tcs.Task); tcs.Task.Status.Should().Be(UniTaskStatus.Faulted); } var cts = new CancellationTokenSource(); { var tcs = new UniTaskCompletionSource(); tcs.TrySetException(new OperationCanceledException(cts.Token)); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } { var tcs = new UniTaskCompletionSource(); tcs.TrySetCanceled(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } } [Fact] public async Task SingleOnFirst() { { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); tcs.TrySetResult(); await a; await tcs.Task; // ok. tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); tcs.TrySetException(new TestException()); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await tcs.Task); tcs.Task.Status.Should().Be(UniTaskStatus.Faulted); } var cts = new CancellationTokenSource(); { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); tcs.TrySetException(new OperationCanceledException(cts.Token)); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); tcs.TrySetCanceled(cts.Token); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } } [Fact] public async Task MultiOne() { { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); var b = Await(); tcs.TrySetResult(); await a; await b; await tcs.Task; // ok. tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); var b = Await(); tcs.TrySetException(new TestException()); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await tcs.Task); tcs.Task.Status.Should().Be(UniTaskStatus.Faulted); } var cts = new CancellationTokenSource(); { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); var b = Await(); tcs.TrySetException(new OperationCanceledException(cts.Token)); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await b)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); var b = Await(); tcs.TrySetCanceled(cts.Token); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await b)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } } [Fact] public async Task MultiTwo() { { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); var b = Await(); var c = Await(); tcs.TrySetResult(); await a; await b; await c; await tcs.Task; // ok. tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); var b = Await(); var c = Await(); tcs.TrySetException(new TestException()); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); await Assert.ThrowsAsync(async () => await tcs.Task); tcs.Task.Status.Should().Be(UniTaskStatus.Faulted); } var cts = new CancellationTokenSource(); { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); var b = Await(); var c = Await(); tcs.TrySetException(new OperationCanceledException(cts.Token)); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await b)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await c)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { await tcs.Task; } var a = Await(); var b = Await(); var c = Await(); tcs.TrySetCanceled(cts.Token); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await b)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await c)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } } class TestException : Exception { } } public class CompletionSourceTest2 { [Fact] public async Task SetFirst() { { var tcs = new UniTaskCompletionSource(); tcs.TrySetResult(10); var a = await tcs.Task; // ok. var b = await tcs.Task; // ok. a.Should().Be(10); b.Should().Be(10); tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded); } { var tcs = new UniTaskCompletionSource(); tcs.TrySetException(new TestException()); await Assert.ThrowsAsync(async () => await tcs.Task); await Assert.ThrowsAsync(async () => await tcs.Task); tcs.Task.Status.Should().Be(UniTaskStatus.Faulted); } var cts = new CancellationTokenSource(); { var tcs = new UniTaskCompletionSource(); tcs.TrySetException(new OperationCanceledException(cts.Token)); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } { var tcs = new UniTaskCompletionSource(); tcs.TrySetCanceled(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } } [Fact] public async Task SingleOnFirst() { { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); tcs.TrySetResult(10); var r1 = await a; var r2 = await tcs.Task; // ok. r1.Should().Be(10); r2.Should().Be(10); tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); tcs.TrySetException(new TestException()); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await tcs.Task); tcs.Task.Status.Should().Be(UniTaskStatus.Faulted); } var cts = new CancellationTokenSource(); { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); tcs.TrySetException(new OperationCanceledException(cts.Token)); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); tcs.TrySetCanceled(cts.Token); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } } [Fact] public async Task MultiOne() { { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); var b = Await(); tcs.TrySetResult(10); var r1 = await a; var r2 = await b; var r3 = await tcs.Task; // ok. (r1, r2, r3).Should().Be((10, 10, 10)); tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); var b = Await(); tcs.TrySetException(new TestException()); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await tcs.Task); tcs.Task.Status.Should().Be(UniTaskStatus.Faulted); } var cts = new CancellationTokenSource(); { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); var b = Await(); tcs.TrySetException(new OperationCanceledException(cts.Token)); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await b)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); var b = Await(); tcs.TrySetCanceled(cts.Token); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await b)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } } [Fact] public async Task MultiTwo() { { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); var b = Await(); var c = Await(); tcs.TrySetResult(10); var r1 = await a; var r2 = await b; var r3 = await c; var r4 = await tcs.Task; // ok. (r1, r2, r3, r4).Should().Be((10, 10, 10, 10)); tcs.Task.Status.Should().Be(UniTaskStatus.Succeeded); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); var b = Await(); var c = Await(); tcs.TrySetException(new TestException()); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); await Assert.ThrowsAsync(async () => await tcs.Task); tcs.Task.Status.Should().Be(UniTaskStatus.Faulted); } var cts = new CancellationTokenSource(); { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); var b = Await(); var c = Await(); tcs.TrySetException(new OperationCanceledException(cts.Token)); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await b)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await c)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } { var tcs = new UniTaskCompletionSource(); async UniTask Await() { return await tcs.Task; } var a = Await(); var b = Await(); var c = Await(); tcs.TrySetCanceled(cts.Token); (await Assert.ThrowsAsync(async () => await a)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await b)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await c)).CancellationToken.Should().Be(cts.Token); (await Assert.ThrowsAsync(async () => await tcs.Task)).CancellationToken.Should().Be(cts.Token); tcs.Task.Status.Should().Be(UniTaskStatus.Canceled); } } class TestException : Exception { } } } ================================================ FILE: src/UniTask.NetCoreTests/DeferTest.cs ================================================ 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(); } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Aggregate.cs ================================================ 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 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 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 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 arr) { switch (arr) { case int[] array: { { if (array.Length == 0) { await Assert.ThrowsAsync(async () => await array.ToUniTaskAsyncEnumerable().MinAsync()); Assert.Throws(() => array.Min()); } else { var xs = await array.ToUniTaskAsyncEnumerable().MinAsync(); var ys = array.Min(); xs.Should().Be(ys); } } { if (array.Length == 0) { await Assert.ThrowsAsync(async () => await array.ToUniTaskAsyncEnumerable().MinAsync(x => x * 2)); Assert.Throws(() => 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(async () => await array.ToUniTaskAsyncEnumerable().MinAsync(x => x.Value)); Assert.Throws(() => 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 arr) { switch (arr) { case int[] array: { { if (array.Length == 0) { await Assert.ThrowsAsync(async () => await array.ToUniTaskAsyncEnumerable().MaxAsync()); Assert.Throws(() => array.Max()); } else { var xs = await array.ToUniTaskAsyncEnumerable().MaxAsync(); var ys = array.Max(); xs.Should().Be(ys); } } { if (array.Length == 0) { await Assert.ThrowsAsync(async () => await array.ToUniTaskAsyncEnumerable().MaxAsync(x => x * 2)); Assert.Throws(() => 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(async () => await array.ToUniTaskAsyncEnumerable().MaxAsync(x => x.Value)); Assert.Throws(() => 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 { public readonly int Value; public X(int value) { Value = value; } public int CompareTo([AllowNull] X other) { return Comparer.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(async () => await new int[] { }.ToUniTaskAsyncEnumerable().AggregateAsync((x, y) => x + y)); Assert.Throws(() => 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(); await Enumerable.Range(1, 10).ToUniTaskAsyncEnumerable().ForEachAsync(x => { list.Add(x); }); list.Should().Equal(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().Equal(list3); } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/AllAny.cs ================================================ 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(); } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Concat.cs ================================================ 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().Equal(ys); } [Fact] public async Task AppendThrow() { var xs = UniTaskTestException.ThrowImmediate().Append(99).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); var ys = UniTaskTestException.ThrowAfter().Append(99).ToArrayAsync(); await Assert.ThrowsAsync(async () => await ys); var zs = UniTaskTestException.ThrowInMoveNext().Append(99).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(ys); } [Fact] public async Task PrependThrow() { var xs = UniTaskTestException.ThrowImmediate().Prepend(99).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); var ys = UniTaskTestException.ThrowAfter().Prepend(99).ToArrayAsync(); await Assert.ThrowsAsync(async () => await ys); var zs = UniTaskTestException.ThrowInMoveNext().Prepend(99).ToArrayAsync(); await Assert.ThrowsAsync(async () => await zs); } public static IEnumerable 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().Equal(ys); } [Fact] public async Task ConcatThrow() { { var xs = UniTaskTestException.ThrowImmediate().Concat(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); var ys = UniTaskTestException.ThrowAfter().Concat(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await ys); var zs = UniTaskTestException.ThrowInMoveNext().Concat(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await zs); } { var xs = UniTaskAsyncEnumerable.Range(1, 10).Concat(UniTaskTestException.ThrowImmediate()).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); var ys = UniTaskAsyncEnumerable.Range(1, 10).Concat(UniTaskTestException.ThrowAfter()).ToArrayAsync(); await Assert.ThrowsAsync(async () => await ys); var zs = UniTaskAsyncEnumerable.Range(1, 10).Concat(UniTaskTestException.ThrowInMoveNext()).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(ys); } { var xs = await Enumerable.Range(1, 1).ToUniTaskAsyncEnumerable().DefaultIfEmpty(99).ToArrayAsync(); var ys = Enumerable.Range(1, 1).DefaultIfEmpty(99).ToArray(); xs.Should().Equal(ys); } { var xs = await Enumerable.Range(1, 10).ToUniTaskAsyncEnumerable().DefaultIfEmpty(99).ToArrayAsync(); var ys = Enumerable.Range(1, 10).DefaultIfEmpty(99).ToArray(); xs.Should().Equal(ys); } // Throw { foreach (var item in UniTaskTestException.Throws()) { var xs = item.DefaultIfEmpty().ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Convert.cs ================================================ 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().ToUniTaskAsyncEnumerable().ToArrayAsync(); xs.Length.Should().Be(0); } } [Fact] public async Task ToObservable() { { var xs = await UniTaskAsyncEnumerable.Range(1, 10).ToObservable().ToArray(); xs.Should().Equal(Enumerable.Range(1, 10)); } { var xs = await UniTaskAsyncEnumerable.Range(1, 0).ToObservable().ToArray(); xs.Should().Equal(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().Equal(ys); } { var xs = await Observable.Range(1, 100, ThreadPoolScheduler.Instance).ToUniTaskAsyncEnumerable().ToArrayAsync(); var ys = await Observable.Range(1, 100, ThreadPoolScheduler.Instance).ToArray(); xs.Should().Equal(ys); } { var xs = await Observable.Empty(ThreadPoolScheduler.Instance).ToUniTaskAsyncEnumerable().ToArrayAsync(); var ys = await Observable.Empty(ThreadPoolScheduler.Instance).ToArray(); xs.Should().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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.Should().BeEquivalentTo(ys); foreach (var key in xs.Select(x => x.Key)) { xs[key].Should().Equal(ys[key]); } } { var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToLookupAsync(x => x); var ys = Enumerable.Range(1, 0).ToLookup(x => x); xs.Should().BeEquivalentTo(ys); } { 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.Should().BeEquivalentTo(ys); foreach (var key in xs.Select(x => x.Key)) { xs[key].Should().Equal(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.Should().BeEquivalentTo(ys); } } [Fact] public async Task ToList() { { var xs = await Enumerable.Range(1, 100).ToUniTaskAsyncEnumerable().ToListAsync(); var ys = Enumerable.Range(1, 100).ToList(); xs.Should().Equal(ys); } { var xs = await Enumerable.Empty().ToUniTaskAsyncEnumerable().ToListAsync(); var ys = Enumerable.Empty().ToList(); xs.Should().Equal(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().Equal(ys.OrderBy(x => x)); } { var xs = await Enumerable.Empty().ToUniTaskAsyncEnumerable().ToHashSetAsync(); var ys = Enumerable.Empty().ToHashSet(); xs.Should().Equal(ys); } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/CreateTest.cs ================================================ #pragma warning disable CS1998 #pragma warning disable CS0162 using Cysharp.Threading.Tasks; using Cysharp.Threading.Tasks.Linq; using FluentAssertions; using System; using System.Collections.Generic; using System.Text; using System.Threading.Tasks; using Xunit; namespace NetCoreTests.Linq { public class CreateTest { [Fact] public async Task SyncCreation() { var from = 10; var count = 100; var xs = await UniTaskAsyncEnumerable.Create(async (writer, token) => { for (int i = 0; i < count; i++) { await writer.YieldAsync(from + i); } }).ToArrayAsync(); var ys = await Range(from, count).AsUniTaskAsyncEnumerable().ToArrayAsync(); xs.Should().Equal(ys); } [Fact] public async Task SyncManually() { var list = new List(); var xs = UniTaskAsyncEnumerable.Create(async (writer, token) => { list.Add(100); await writer.YieldAsync(10); list.Add(200); await writer.YieldAsync(20); list.Add(300); await writer.YieldAsync(30); list.Add(400); }); list.Should().BeEmpty(); var e = xs.GetAsyncEnumerator(); list.Should().BeEmpty(); await e.MoveNextAsync(); list.Should().Equal(100); e.Current.Should().Be(10); await e.MoveNextAsync(); list.Should().Equal(100, 200); e.Current.Should().Be(20); await e.MoveNextAsync(); list.Should().Equal(100, 200, 300); e.Current.Should().Be(30); (await e.MoveNextAsync()).Should().BeFalse(); list.Should().Equal(100, 200, 300, 400); } [Fact] public async Task SyncExceptionFirst() { var from = 10; var count = 100; var xs = UniTaskAsyncEnumerable.Create(async (writer, token) => { for (int i = 0; i < count; i++) { throw new UniTaskTestException(); await writer.YieldAsync(from + i); } }); await Assert.ThrowsAsync(async () => await xs.ToArrayAsync()); } [Fact] public async Task SyncException() { var from = 10; var count = 100; var xs = UniTaskAsyncEnumerable.Create(async (writer, token) => { for (int i = 0; i < count; i++) { await writer.YieldAsync(from + i); if (i == 15) { throw new UniTaskTestException(); } } }); await Assert.ThrowsAsync(async () => await xs.ToArrayAsync()); } [Fact] public async Task ASyncManually() { var list = new List(); var xs = UniTaskAsyncEnumerable.Create(async (writer, token) => { await UniTask.Yield(); list.Add(100); await writer.YieldAsync(10); await UniTask.Yield(); list.Add(200); await writer.YieldAsync(20); await UniTask.Yield(); list.Add(300); await UniTask.Yield(); await writer.YieldAsync(30); await UniTask.Yield(); list.Add(400); }); list.Should().BeEmpty(); var e = xs.GetAsyncEnumerator(); list.Should().BeEmpty(); await e.MoveNextAsync(); list.Should().Equal(100); e.Current.Should().Be(10); await e.MoveNextAsync(); list.Should().Equal(100, 200); e.Current.Should().Be(20); await e.MoveNextAsync(); list.Should().Equal(100, 200, 300); e.Current.Should().Be(30); (await e.MoveNextAsync()).Should().BeFalse(); list.Should().Equal(100, 200, 300, 400); } [Fact] public async Task AwaitForeachBreak() { var finallyCalled = false; var enumerable = UniTaskAsyncEnumerable.Create(async (writer, _) => { try { await writer.YieldAsync(1); } finally { finallyCalled = true; } }); await foreach (var x in enumerable) { x.Should().Be(1); break; } finallyCalled.Should().BeTrue(); } async IAsyncEnumerable Range(int from, int count) { for (int i = 0; i < count; i++) { yield return from + i; } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Factory.cs ================================================ 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().Equal(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().Equal(ys); } [Fact] public async Task EmptyTest() { var xs = await UniTaskAsyncEnumerable.Empty().ToArrayAsync(); var ys = Enumerable.Empty().ToArray(); xs.Should().Equal(ys); } [Theory] [InlineData(100)] [InlineData((string)null)] [InlineData("foo")] public async Task ReturnTest(T value) { var xs = await UniTaskAsyncEnumerable.Return(value).ToArrayAsync(); xs.Length.Should().Be(1); xs[0].Should().Be(value); } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Filtering.cs ================================================ 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().Equal(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().Equal(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().Equal(expected); b.Should().Equal(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().Equal(expected); b.Should().Equal(expected); } } [Fact] public async Task WhereException() { foreach (var item in UniTaskTestException.Throws()) { { var xs = item.Where(x => x % 2 == 0).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.Where((x, i) => x % 2 == 0).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.WhereAwait(x => UniTask.FromResult(x % 2 == 0)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.WhereAwait((x, i) => UniTask.FromResult(x % 2 == 0)).ToArrayAsync(); await Assert.ThrowsAsync(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().ToArrayAsync(); var b = data.OfType().ToArray(); a.Should().Equal(b); } [Fact] public async Task OfTypeException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Select(x => (object)x).OfType().ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } } [Fact] public async Task Cast() { var data = new object[] { 0, 10, 30, 99 }; var a = await data.ToUniTaskAsyncEnumerable().Cast().ToArrayAsync(); var b = data.Cast().ToArray(); a.Should().Equal(b); } [Fact] public async Task CastException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Select(x => (object)x).Cast().ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/FirstLast.cs ================================================ 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(async () => await Enumerable.Empty().ToUniTaskAsyncEnumerable().FirstAsync()); Assert.Throws(() => Enumerable.Empty().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(async () => await array.ToUniTaskAsyncEnumerable().FirstAsync(x => x % 98 == 0)); Assert.Throws(() => 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().ToUniTaskAsyncEnumerable().FirstOrDefaultAsync(); var y = Enumerable.Empty().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(async () => await Enumerable.Empty().ToUniTaskAsyncEnumerable().LastAsync()); Assert.Throws(() => Enumerable.Empty().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(async () => await array.ToUniTaskAsyncEnumerable().LastAsync(x => x % 98 == 0)); Assert.Throws(() => 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().ToUniTaskAsyncEnumerable().LastOrDefaultAsync(); var y = Enumerable.Empty().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(async () => await Enumerable.Empty().ToUniTaskAsyncEnumerable().SingleAsync()); Assert.Throws(() => Enumerable.Empty().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(async () => await array.ToUniTaskAsyncEnumerable().SingleAsync()); Assert.Throws(() => array.Single()); } { var array = new[] { 99, 11, 135, 10, 144, 800 }; // not found await Assert.ThrowsAsync(async () => await array.ToUniTaskAsyncEnumerable().SingleAsync(x => x % 999 == 0)); Assert.Throws(() => array.Single(x => x % 999 == 0)); // found multi await Assert.ThrowsAsync(async () => await array.ToUniTaskAsyncEnumerable().SingleAsync(x => x % 2 == 0)); Assert.Throws(() => 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().ToUniTaskAsyncEnumerable().SingleOrDefaultAsync(); var y = Enumerable.Empty().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(async () => await array.ToUniTaskAsyncEnumerable().SingleOrDefaultAsync()); Assert.Throws(() => 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(async () => await array.ToUniTaskAsyncEnumerable().SingleOrDefaultAsync(x => x % 2 == 0)); Assert.Throws(() => 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(async () => await Enumerable.Empty().ToUniTaskAsyncEnumerable().ElementAtAsync(0)); Assert.Throws(() => Enumerable.Empty().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(async () => await array.ToUniTaskAsyncEnumerable().ElementAtAsync(10)); Assert.Throws(() => 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().ToUniTaskAsyncEnumerable().ElementAtOrDefaultAsync(0); var y = Enumerable.Empty().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); } } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Joins.cs ================================================ 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 RandomRun(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().Equal(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(async () => await xs); await Assert.ThrowsAsync(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().Equal(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(async () => await xs); await Assert.ThrowsAsync(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().Equal(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(async () => await xs); await Assert.ThrowsAsync(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.Should().BeEquivalentTo(ys); } { 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().Equal(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.Should().BeEquivalentTo(ys); } { 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().Equal(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.Should().BeEquivalentTo(ys); } { 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().Equal(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(async () => await xs); await Assert.ThrowsAsync(async () => await ys); await Assert.ThrowsAsync(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().Equal(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().Equal(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().Equal(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(async () => await xs); await Assert.ThrowsAsync(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(async () => await xs); await Assert.ThrowsAsync(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(async () => await xs); await Assert.ThrowsAsync(async () => await ys); } } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Merge.cs ================================================ #pragma warning disable CS1998 using System; using System.Threading; using System.Threading.Tasks; using Cysharp.Threading.Tasks; using Cysharp.Threading.Tasks.Linq; using FluentAssertions; using Xunit; namespace NetCoreTests.Linq { public class MergeTest { [Fact] public async Task TwoSource() { var semaphore = new SemaphoreSlim(1, 1); var a = UniTaskAsyncEnumerable.Create(async (writer, _) => { await UniTask.SwitchToThreadPool(); await semaphore.WaitAsync(); await writer.YieldAsync("A1"); semaphore.Release(); await semaphore.WaitAsync(); await writer.YieldAsync("A2"); semaphore.Release(); }); var b = UniTaskAsyncEnumerable.Create(async (writer, _) => { await UniTask.SwitchToThreadPool(); await semaphore.WaitAsync(); await writer.YieldAsync("B1"); await writer.YieldAsync("B2"); semaphore.Release(); await semaphore.WaitAsync(); await writer.YieldAsync("B3"); semaphore.Release(); }); var result = await a.Merge(b).ToArrayAsync(); result.Should().Equal("A1", "B1", "B2", "A2", "B3"); } [Fact] public async Task ThreeSource() { var semaphore = new SemaphoreSlim(0, 1); var a = UniTaskAsyncEnumerable.Create(async (writer, _) => { await UniTask.SwitchToThreadPool(); await semaphore.WaitAsync(); await writer.YieldAsync("A1"); semaphore.Release(); await semaphore.WaitAsync(); await writer.YieldAsync("A2"); semaphore.Release(); }); var b = UniTaskAsyncEnumerable.Create(async (writer, _) => { await UniTask.SwitchToThreadPool(); await semaphore.WaitAsync(); await writer.YieldAsync("B1"); await writer.YieldAsync("B2"); semaphore.Release(); await semaphore.WaitAsync(); await writer.YieldAsync("B3"); semaphore.Release(); }); var c = UniTaskAsyncEnumerable.Create(async (writer, _) => { await UniTask.SwitchToThreadPool(); await writer.YieldAsync("C1"); semaphore.Release(); }); var result = await a.Merge(b, c).ToArrayAsync(); result.Should().Equal("C1", "A1", "B1", "B2", "A2", "B3"); } [Fact] public async Task Throw() { var a = UniTaskAsyncEnumerable.Create(async (writer, _) => { await writer.YieldAsync("A1"); }); var b = UniTaskAsyncEnumerable.Create(async (writer, _) => { throw new UniTaskTestException(); }); var enumerator = a.Merge(b).GetAsyncEnumerator(); (await enumerator.MoveNextAsync()).Should().Be(true); enumerator.Current.Should().Be("A1"); await Assert.ThrowsAsync(async () => await enumerator.MoveNextAsync()); } [Fact] public async Task Cancel() { var cts = new CancellationTokenSource(); var a = UniTaskAsyncEnumerable.Create(async (writer, _) => { await writer.YieldAsync("A1"); }); var b = UniTaskAsyncEnumerable.Create(async (writer, _) => { await writer.YieldAsync("B1"); }); var enumerator = a.Merge(b).GetAsyncEnumerator(cts.Token); (await enumerator.MoveNextAsync()).Should().Be(true); enumerator.Current.Should().Be("A1"); cts.Cancel(); await Assert.ThrowsAsync(async () => await enumerator.MoveNextAsync()); } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Paging.cs ================================================ 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().Equal(ys); } [Fact] public async Task SkipException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Skip(5).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(ys); } [Fact] public async Task SkipLastException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.SkipLast(5).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(ys); } [Fact] public async Task TakeLastException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.TakeLast(5).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(ys); } [Fact] public async Task TakeException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Take(5).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(ys); } } [Fact] public async Task SkipWhileException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.SkipWhile(x => x < 2).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.SkipWhile((x, i) => x < 2).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.SkipWhileAwait((x) => UniTask.Run(() => x < 2)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.SkipWhileAwait((x, i) => UniTask.Run(() => x < 2)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.SkipWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < 2)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.SkipWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < 2)).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(ys); } } [Fact] public async Task TakeWhileException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.TakeWhile(x => x < 5).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.TakeWhile((x, i) => x < 5).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.TakeWhileAwait((x) => UniTask.Run(() => x < 5)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.TakeWhileAwait((x, i) => UniTask.Run(() => x < 5)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.TakeWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < 5)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = item.TakeWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < 5)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Projection.cs ================================================ 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().Equal(ys); } [Fact] public async Task ReverseException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Reverse().ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(ys); var zs = await UniTaskAsyncEnumerable.Range(1, count).SelectAwait((x) => UniTask.Run(() => x * x)).ToArrayAsync(); zs.Should().Equal(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().Equal(ys); var zs = await UniTaskAsyncEnumerable.Range(1, count).SelectAwait((x, i) => UniTask.Run(() => x * x * i)).ToArrayAsync(); zs.Should().Equal(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(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(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(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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().Equal(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(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectMany(x => item).ToArrayAsync(); await Assert.ThrowsAsync(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(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectManyAwait(x => UniTask.Run(() => item)).ToArrayAsync(); await Assert.ThrowsAsync(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(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = UniTaskAsyncEnumerable.Range(0, 1).SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => item)).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(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().Equal(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().Equal(ys); } } [Fact] public async Task ZipException() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Zip(UniTaskAsyncEnumerable.Range(1, 10)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = UniTaskAsyncEnumerable.Range(1, 10).Zip(item).ToArrayAsync(); await Assert.ThrowsAsync(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(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(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(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(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().Equal(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().Equal(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(async () => await xs); await Assert.ThrowsAsync(async () => await ys); } } [Fact] public async Task CombineLatestOK() { var a = new AsyncReactiveProperty(0); var b = new AsyncReactiveProperty(0); var list = new List<(int, int)>(); var complete = a.WithoutCurrent().CombineLatest(b.WithoutCurrent(), (x, y) => (x, y)).ForEachAsync(x => list.Add(x)); list.Count.Should().Be(0); a.Value = 10; list.Count.Should().Be(0); a.Value = 20; list.Count.Should().Be(0); b.Value = 1; list.Count.Should().Be(1); list[0].Should().Be((20, 1)); a.Value = 30; list.Last().Should().Be((30, 1)); b.Value = 2; list.Last().Should().Be((30, 2)); a.Dispose(); b.Value = 3; list.Last().Should().Be((30, 3)); b.Dispose(); await complete; } [Fact] public async Task CombineLatestLong() { var a = UniTaskAsyncEnumerable.Range(1, 100000); var b = new AsyncReactiveProperty(0); var list = new List<(int, int)>(); var complete = a.CombineLatest(b.WithoutCurrent(), (x, y) => (x, y)).ForEachAsync(x => list.Add(x)); b.Value = 1; list[0].Should().Be((100000, 1)); b.Dispose(); await complete; } [Fact] public async Task CombineLatestError() { var a = new AsyncReactiveProperty(0); var b = new AsyncReactiveProperty(0); var list = new List<(int, int)>(); var complete = a.WithoutCurrent() .Select(x => { if (x == 0) { throw new MyException(); } return x; }) .CombineLatest(b.WithoutCurrent(), (x, y) => (x, y)).ForEachAsync(x => list.Add(x)); a.Value = 10; b.Value = 1; list.Last().Should().Be((10, 1)); a.Value = 0; await Assert.ThrowsAsync(async () => await complete); } [Fact] public async Task PariwiseImmediate() { var xs = await UniTaskAsyncEnumerable.Range(1, 5).Pairwise().ToArrayAsync(); xs.Should().Equal((1, 2), (2, 3), (3, 4), (4, 5)); } [Fact] public async Task Pariwise() { var a = new AsyncReactiveProperty(0); var list = new List<(int, int)>(); var complete = a.WithoutCurrent().Pairwise().ForEachAsync(x => list.Add(x)); list.Count.Should().Be(0); a.Value = 10; list.Count.Should().Be(0); a.Value = 20; list.Count.Should().Be(1); a.Value = 30; a.Value = 40; a.Value = 50; a.Dispose(); await complete; list.Should().Equal((10, 20), (20, 30), (30, 40), (40, 50)); } class MyException : Exception { } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/PulbishTest.cs ================================================ 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(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().Equal(1, 2); var c = multicast.ToArrayAsync(); rp.Value = 3; rp.Value = 4; rp.Value = 5; rp.Dispose(); (await a).Should().Equal(1, 2, 3, 4, 5); (await c).Should().Equal(3, 4, 5); disp.Dispose(); } [Fact] public async Task Cancel() { var rp = new AsyncReactiveProperty(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().Equal(1, 2); var c = multicast.ToArrayAsync(); rp.Value = 3; disp.Dispose(); rp.Value = 4; rp.Value = 5; rp.Dispose(); await Assert.ThrowsAsync(async () => await a); await Assert.ThrowsAsync(async () => await c); } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/QueueTest.cs ================================================ 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(100); var l = new List(); await rp.Take(10).Queue().ForEachAsync(x => { rp.Value += 10; l.Add(x); }); l.Should().Equal(100, 110, 120, 130, 140, 150, 160, 170, 180, 190); } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Sets.cs ================================================ 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 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 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().Equal(ys); (await array.ToUniTaskAsyncEnumerable().Distinct(x => x).ToArrayAsync()).Should().Equal(ys); (await array.ToUniTaskAsyncEnumerable().DistinctAwait(x => UniTask.Run(() => x)).ToArrayAsync()).Should().Equal(ys); (await array.ToUniTaskAsyncEnumerable().DistinctAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync()).Should().Equal(ys); } } [Fact] public async Task DistinctThrow() { foreach (var item in UniTaskTestException.Throws()) { { var xs = item.Distinct().ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.Distinct(x => x).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.DistinctAwait(x => UniTask.Run(() => x)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.DistinctAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync(); await Assert.ThrowsAsync(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().Equal(ys); (await array.ToUniTaskAsyncEnumerable().DistinctUntilChanged(x => x).ToArrayAsync()).Should().Equal(ys); (await array.ToUniTaskAsyncEnumerable().DistinctUntilChangedAwait(x => UniTask.Run(() => x)).ToArrayAsync()).Should().Equal(ys); (await array.ToUniTaskAsyncEnumerable().DistinctUntilChangedAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync()).Should().Equal(ys); } } [Fact] public async Task DistinctUntilChangedThrow() { foreach (var item in UniTaskTestException.Throws()) { { var xs = item.DistinctUntilChanged().ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.DistinctUntilChanged(x => x).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.DistinctUntilChangedAwait(x => UniTask.Run(() => x)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } { var xs = item.DistinctUntilChangedAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } } } [Fact] public async Task Except() { foreach (var a1 in array1.First().Cast()) { foreach (var a2 in array2.First().Cast()) { var xs = await a1.ToUniTaskAsyncEnumerable().Except(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync(); var ys = a1.Except(a2).ToArray(); xs.Should().Equal(ys); } } } [Fact] public async Task ExceptThrow() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Except(UniTaskAsyncEnumerable.Return(10)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = UniTaskAsyncEnumerable.Return(10).Except(item).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } } [Fact] public async Task Intersect() { foreach (var a1 in array1.First().Cast()) { foreach (var a2 in array2.First().Cast()) { var xs = await a1.ToUniTaskAsyncEnumerable().Intersect(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync(); var ys = a1.Intersect(a2).ToArray(); xs.Should().Equal(ys); } } } [Fact] public async Task IntersectThrow() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Intersect(UniTaskAsyncEnumerable.Return(10)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = UniTaskAsyncEnumerable.Return(10).Intersect(item).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } } [Fact] public async Task Union() { foreach (var a1 in array1.First().Cast()) { foreach (var a2 in array2.First().Cast()) { var xs = await a1.ToUniTaskAsyncEnumerable().Union(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync(); var ys = a1.Union(a2).ToArray(); xs.Should().Equal(ys); } } } [Fact] public async Task UnionThrow() { foreach (var item in UniTaskTestException.Throws()) { var xs = item.Union(UniTaskAsyncEnumerable.Return(10)).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } foreach (var item in UniTaskTestException.Throws()) { var xs = UniTaskAsyncEnumerable.Return(10).Union(item).ToArrayAsync(); await Assert.ThrowsAsync(async () => await xs); } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/Sort.cs ================================================ 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 RandomRun(T value) { if (Interlocked.Increment(ref rd) % 2 == 0) { return UniTask.Run(() => value); } else { return UniTask.FromResult(value); } } static UniTask RandomRun(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().Equal(ys); } { var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x).ToArrayAsync(); var ys = array.OrderByDescending(x => x).ToArray(); xs.Should().Equal(ys); } { var xs = await array.ToUniTaskAsyncEnumerable().OrderByAwait(RandomRun).ToArrayAsync(); var ys = array.OrderBy(x => x).ToArray(); xs.Should().Equal(ys); } { var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(RandomRun).ToArrayAsync(); var ys = array.OrderByDescending(x => x).ToArray(); xs.Should().Equal(ys); } { var xs = await array.ToUniTaskAsyncEnumerable().OrderByAwaitWithCancellation(RandomRun).ToArrayAsync(); var ys = array.OrderBy(x => x).ToArray(); xs.Should().Equal(ys); } { var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation(RandomRun).ToArrayAsync(); var ys = array.OrderByDescending(x => x).ToArray(); xs.Should().Equal(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().Equal(a2); b.Should().Equal(b2); c.Should().Equal(c2); d.Should().Equal(d2); e.Should().Equal(e2); f.Should().Equal(f2); g.Should().Equal(g2); h.Should().Equal(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().Equal(a2); b.Should().Equal(b2); c.Should().Equal(c2); d.Should().Equal(d2); e.Should().Equal(e2); f.Should().Equal(f2); g.Should().Equal(g2); h.Should().Equal(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().Equal(a2); b.Should().Equal(b2); c.Should().Equal(c2); d.Should().Equal(d2); e.Should().Equal(e2); f.Should().Equal(f2); g.Should().Equal(g2); h.Should().Equal(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(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); await Assert.ThrowsAsync(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(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); await Assert.ThrowsAsync(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(async () => await a); await Assert.ThrowsAsync(async () => await b); await Assert.ThrowsAsync(async () => await c); await Assert.ThrowsAsync(async () => await d); } } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/TakeInfinityTest.cs ================================================ 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(1); var xs = rp.Take(5).ToArrayAsync(); rp.Value = 2; rp.Value = 3; rp.Value = 4; rp.Value = 5; (await xs).Should().Equal(1, 2, 3, 4, 5); } [Fact] public async Task TakeWhile() { var rp = new AsyncReactiveProperty(1); var xs = rp.TakeWhile(x => x != 5).ToArrayAsync(); rp.Value = 2; rp.Value = 3; rp.Value = 4; rp.Value = 5; (await xs).Should().Equal(1, 2, 3, 4); } [Fact] public async Task TakeUntilCanceled() { var cts = new CancellationTokenSource(); var rp = new AsyncReactiveProperty(1); var xs = rp.TakeUntilCanceled(cts.Token).ToArrayAsync(); var c = CancelAsync(); await c; var foo = await xs; foo.Should().Equal(new[] { 1, 10, 20 }); async Task CancelAsync() { rp.Value = 10; await Task.Yield(); rp.Value = 20; await Task.Yield(); cts.Cancel(); rp.Value = 30; await Task.Yield(); rp.Value = 40; } } [Fact] public async Task SkipUntilCanceled() { var cts = new CancellationTokenSource(); var rp = new AsyncReactiveProperty(1); var xs = rp.SkipUntilCanceled(cts.Token).ToArrayAsync(); var c = CancelAsync(); await c; var foo = await xs; foo.Should().Equal(new[] { 20, 30, 40 }); async Task CancelAsync() { rp.Value = 10; await Task.Yield(); rp.Value = 20; await Task.Yield(); cts.Cancel(); rp.Value = 30; await Task.Yield(); rp.Value = 40; rp.Dispose(); // complete. } } [Fact] public async Task TakeUntil() { var cts = new AsyncReactiveProperty(0); var rp = new AsyncReactiveProperty(1); var xs = rp.TakeUntil(cts.WaitAsync()).ToArrayAsync(); var c = CancelAsync(); await c; var foo = await xs; foo.Should().Equal(new[] { 1, 10, 20 }); async Task CancelAsync() { rp.Value = 10; await Task.Yield(); rp.Value = 20; await Task.Yield(); cts.Value = 9999; rp.Value = 30; await Task.Yield(); rp.Value = 40; } } [Fact] public async Task SkipUntil() { var cts = new AsyncReactiveProperty(0); var rp = new AsyncReactiveProperty(1); var xs = rp.SkipUntil(cts.WaitAsync()).ToArrayAsync(); var c = CancelAsync(); await c; var foo = await xs; foo.Should().Equal(new[] { 20, 30, 40 }); async Task CancelAsync() { rp.Value = 10; await Task.Yield(); rp.Value = 20; await Task.Yield(); cts.Value = 9999; rp.Value = 30; await Task.Yield(); rp.Value = 40; rp.Dispose(); // complete. } } } } ================================================ FILE: src/UniTask.NetCoreTests/Linq/_Exception.cs ================================================ 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 ThrowImmediate() { return UniTaskAsyncEnumerable.Throw(new UniTaskTestException()); } public static IUniTaskAsyncEnumerable ThrowAfter() { return new ThrowAfter(new UniTaskTestException()); } public static IUniTaskAsyncEnumerable ThrowInMoveNext() { return new ThrowIn(new UniTaskTestException()); } public static IEnumerable> 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 : IUniTaskAsyncEnumerable { readonly Exception exception; public ThrowIn(Exception exception) { this.exception = exception; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new Enumerator(exception, cancellationToken); } class Enumerator : IUniTaskAsyncEnumerator { readonly Exception exception; CancellationToken cancellationToken; public Enumerator(Exception exception, CancellationToken cancellationToken) { this.exception = exception; this.cancellationToken = cancellationToken; } public TValue Current => default; public UniTask MoveNextAsync() { ExceptionDispatchInfo.Capture(exception).Throw(); return new UniTask(false); } public UniTask DisposeAsync() { return default; } } } internal class ThrowAfter : IUniTaskAsyncEnumerable { readonly Exception exception; public ThrowAfter(Exception exception) { this.exception = exception; } public IUniTaskAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { return new Enumerator(exception, cancellationToken); } class Enumerator : IUniTaskAsyncEnumerator { readonly Exception exception; CancellationToken cancellationToken; public Enumerator(Exception exception, CancellationToken cancellationToken) { this.exception = exception; this.cancellationToken = cancellationToken; } public TValue Current => default; public UniTask MoveNextAsync() { cancellationToken.ThrowIfCancellationRequested(); var tcs = new UniTaskCompletionSource(); var awaiter = UniTask.Yield().GetAwaiter(); awaiter.UnsafeOnCompleted(() => { Thread.Sleep(1); tcs.TrySetException(exception); }); return tcs.Task; } public UniTask DisposeAsync() { return default; } } } } ================================================ FILE: src/UniTask.NetCoreTests/TaskBuilderCases.cs ================================================ #pragma warning disable CS1998 using Cysharp.Threading.Tasks; using FluentAssertions; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Channels; using Cysharp.Threading.Tasks.Linq; using System.Threading.Tasks; using Xunit; using System.Runtime.CompilerServices; namespace NetCoreTests { public class UniTaskBuilderTest { [Fact] public async Task Empty() { await Core(); static async UniTask Core() { } } [Fact] public async Task EmptyThrow() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { throw new TaskTestException(); } } [Fact] public async Task Task_Done() { await Core(); static async UniTask Core() { await new TestAwaiter(true, UniTaskStatus.Succeeded); } } [Fact] public async Task Task_Fail() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { await new TestAwaiter(true, UniTaskStatus.Faulted); } } [Fact] public async Task Task_Cancel() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { await new TestAwaiter(true, UniTaskStatus.Canceled); } } [Fact] public async Task AwaitUnsafeOnCompletedCall_Task_SetResult() { await Core(); static async UniTask Core() { await new TestAwaiter(false, UniTaskStatus.Succeeded); await new TestAwaiter(false, UniTaskStatus.Succeeded); await new TestAwaiter(false, UniTaskStatus.Succeeded); } } [Fact] public async Task AwaitUnsafeOnCompletedCall_Task_SetException() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { await new TestAwaiter(false, UniTaskStatus.Succeeded); await new TestAwaiter(false, UniTaskStatus.Faulted); throw new InvalidOperationException(); } } [Fact] public async Task AwaitUnsafeOnCompletedCall_Task_SetCancelException() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { await new TestAwaiter(false, UniTaskStatus.Succeeded); await new TestAwaiter(false, UniTaskStatus.Canceled); throw new InvalidOperationException(); } } } public class UniTask_T_BuilderTest { [Fact] public async Task Empty() { (await Core()).Should().Be(10); static async UniTask Core() { return 10; } } [Fact] public async Task EmptyThrow() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { throw new TaskTestException(); } } [Fact] public async Task Task_Done() { (await Core()).Should().Be(10); static async UniTask Core() { return await new TestAwaiter(true, UniTaskStatus.Succeeded, 10); } } [Fact] public async Task Task_Fail() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { return await new TestAwaiter(true, UniTaskStatus.Faulted, 10); } } [Fact] public async Task Task_Cancel() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { return await new TestAwaiter(true, UniTaskStatus.Canceled, 10); } } [Fact] public async Task AwaitUnsafeOnCompletedCall_Task_SetResult() { (await Core()).Should().Be(6); static async UniTask Core() { var sum = 0; sum += await new TestAwaiter(false, UniTaskStatus.Succeeded, 1); sum += await new TestAwaiter(false, UniTaskStatus.Succeeded, 2); sum += await new TestAwaiter(false, UniTaskStatus.Succeeded, 3); return sum; } } [Fact] public async Task AwaitUnsafeOnCompletedCall_Task_SetException() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { await new TestAwaiter(false, UniTaskStatus.Succeeded, 10); await new TestAwaiter(false, UniTaskStatus.Faulted, 10); throw new InvalidOperationException(); } } [Fact] public async Task AwaitUnsafeOnCompletedCall_Task_SetCancelException() { await Assert.ThrowsAsync(async () => await Core()); static async UniTask Core() { await new TestAwaiter(false, UniTaskStatus.Succeeded, 10); await new TestAwaiter(false, UniTaskStatus.Canceled, 10); throw new InvalidOperationException(); } } } public class TaskTestException : Exception { } public struct TestAwaiter : ICriticalNotifyCompletion { readonly UniTaskStatus status; readonly bool isCompleted; public TestAwaiter(bool isCompleted, UniTaskStatus status) { this.isCompleted = isCompleted; this.status = status; } public TestAwaiter GetAwaiter() => this; public bool IsCompleted => isCompleted; public void GetResult() { switch (status) { case UniTaskStatus.Faulted: throw new TaskTestException(); case UniTaskStatus.Canceled: throw new OperationCanceledException(); case UniTaskStatus.Pending: case UniTaskStatus.Succeeded: default: break; } } public void OnCompleted(Action continuation) { ThreadPool.QueueUserWorkItem(_ => continuation(), null); } public void UnsafeOnCompleted(Action continuation) { ThreadPool.UnsafeQueueUserWorkItem(_ => continuation(), null); } } public struct TestAwaiter : ICriticalNotifyCompletion { readonly UniTaskStatus status; readonly bool isCompleted; readonly T value; public TestAwaiter(bool isCompleted, UniTaskStatus status, T value) { this.isCompleted = isCompleted; this.status = status; this.value = value; } public TestAwaiter GetAwaiter() => this; public bool IsCompleted => isCompleted; public T GetResult() { switch (status) { case UniTaskStatus.Faulted: throw new TaskTestException(); case UniTaskStatus.Canceled: throw new OperationCanceledException(); case UniTaskStatus.Pending: case UniTaskStatus.Succeeded: default: return value; } } public void OnCompleted(Action continuation) { ThreadPool.QueueUserWorkItem(_ => continuation(), null); } public void UnsafeOnCompleted(Action continuation) { ThreadPool.UnsafeQueueUserWorkItem(_ => continuation(), null); } } } ================================================ FILE: src/UniTask.NetCoreTests/TaskExtensionsTest.cs ================================================ #pragma warning disable CS1998 using System; using System.Threading.Tasks; using Cysharp.Threading.Tasks; using Xunit; namespace NetCoreTests { public class TaskExtensionsTest { [Fact] public async Task PropagateException() { await Assert.ThrowsAsync(async () => { await ThrowAsync().AsUniTask(); }); await Assert.ThrowsAsync(async () => { await ThrowOrValueAsync().AsUniTask(); }); } [Fact] public async Task PropagateExceptionWhenAll() { await Assert.ThrowsAsync(async () => { await Task.WhenAll(ThrowAsync(), ThrowAsync()).AsUniTask(); }); } async Task ThrowAsync() { throw new InvalidOperationException(); } async Task ThrowOrValueAsync() { throw new InvalidOperationException(); } } } ================================================ FILE: src/UniTask.NetCoreTests/TriggerEventTest.cs ================================================ using Cysharp.Threading.Tasks; using FluentAssertions; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Channels; using Cysharp.Threading.Tasks.Linq; using System.Threading.Tasks; using Xunit; namespace NetCoreTests { public class TriggerEventTest { [Fact] public void SimpleAdd() { var ev = new TriggerEvent(); // do nothing ev.SetResult(0); ev.SetError(null); ev.SetCompleted(); ev.SetCanceled(default); { var one = new TestEvent(1); ev.Add(one); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); ev.SetCompleted(); one.CompletedCalled.Count.Should().Be(1); // do nothing ev.SetResult(0); ev.SetError(null); ev.SetCompleted(); ev.SetCanceled(default); one.NextCalled.Should().Equal(10, 20, 30); one.CompletedCalled.Count.Should().Be(1); } // after removed, onemore { var one = new TestEvent(1); ev.Add(one); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); ev.SetCompleted(); one.CompletedCalled.Count.Should().Be(1); // do nothing ev.SetResult(0); ev.SetError(null); ev.SetCompleted(); ev.SetCanceled(default); one.NextCalled.Should().Equal(10, 20, 30); one.CompletedCalled.Count.Should().Be(1); } } [Fact] public void AddFour() { var ev = new TriggerEvent(); // do nothing ev.SetResult(0); ev.SetError(null); ev.SetCompleted(); ev.SetCanceled(default); { var one = new TestEvent(1); var two = new TestEvent(2); var three = new TestEvent(3); var four = new TestEvent(4); ev.Add(one); ev.Add(two); ev.Add(three); ev.Add(four); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30); four.NextCalled.Should().Equal(10, 20, 30); ev.SetCompleted(); one.CompletedCalled.Count.Should().Be(1); two.CompletedCalled.Count.Should().Be(1); three.CompletedCalled.Count.Should().Be(1); // do nothing ev.SetResult(0); ev.SetError(null); ev.SetCompleted(); ev.SetCanceled(default); one.NextCalled.Should().Equal(10, 20, 30); one.CompletedCalled.Count.Should().Be(1); two.NextCalled.Should().Equal(10, 20, 30); three.CompletedCalled.Count.Should().Be(1); two.NextCalled.Should().Equal(10, 20, 30); three.CompletedCalled.Count.Should().Be(1); } // after removed, onemore. { var one = new TestEvent(1); var two = new TestEvent(2); var three = new TestEvent(3); var four = new TestEvent(4); ev.Add(one); ev.Add(two); ev.Add(three); ev.Add(four); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); ev.Add(four); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30); four.NextCalled.Should().Equal(10, 20, 30); ev.SetCompleted(); one.CompletedCalled.Count.Should().Be(1); two.CompletedCalled.Count.Should().Be(1); three.CompletedCalled.Count.Should().Be(1); // do nothing ev.SetResult(0); ev.SetError(null); ev.SetCompleted(); ev.SetCanceled(default); one.NextCalled.Should().Equal(10, 20, 30); one.CompletedCalled.Count.Should().Be(1); two.NextCalled.Should().Equal(10, 20, 30); three.CompletedCalled.Count.Should().Be(1); two.NextCalled.Should().Equal(10, 20, 30); three.CompletedCalled.Count.Should().Be(1); } } [Fact] public void OneRemove() { var ev = new TriggerEvent(); { var one = new TestEvent(1); var two = new TestEvent(2); var three = new TestEvent(3); ev.Add(one); ev.Add(two); ev.Add(three); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30); ev.Remove(one); ev.SetResult(40); ev.SetResult(50); ev.SetResult(60); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60); three.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60); } } [Fact] public void TwoRemove() { var ev = new TriggerEvent(); { var one = new TestEvent(1); var two = new TestEvent(2); var three = new TestEvent(3); ev.Add(one); ev.Add(two); ev.Add(three); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30); ev.Remove(two); ev.SetResult(40); ev.SetResult(50); ev.SetResult(60); one.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60); } } [Fact] public void ThreeRemove() { var ev = new TriggerEvent(); { var one = new TestEvent(1); var two = new TestEvent(2); var three = new TestEvent(3); ev.Add(one); ev.Add(two); ev.Add(three); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30); ev.Remove(three); ev.SetResult(40); ev.SetResult(50); ev.SetResult(60); one.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60); two.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60); three.NextCalled.Should().Equal(10, 20, 30); } } [Fact] public void RemoveSelf() { new RemoveMe().Run1(); new RemoveMe().Run2(); new RemoveMe().Run3(); } [Fact] public void RemoveNextInIterating() { new RemoveNext().Run1(); new RemoveNext().Run2(); new RemoveNext().Run3(); } [Fact] public void RemoveNextNextTest() { new RemoveNextNext().Run1(); new RemoveNextNext().Run2(); } [Fact] public void AddTest() { new AddMe().Run1(); new AddMe().Run2(); } public class RemoveMe { TriggerEvent ev; public void Run1() { TestEvent one = default; one = new TestEvent(1, () => ev.Remove(one)); var two = new TestEvent(2); var three = new TestEvent(3); ev.Add(one); ev.Add(two); ev.Add(three); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30); } public void Run2() { TestEvent one = default; one = new TestEvent(1, () => ev.Remove(one)); var two = new TestEvent(2); var three = new TestEvent(3); ev.Add(two); ev.Add(one); // add second. ev.Add(three); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30); } public void Run3() { TestEvent one = default; one = new TestEvent(1, () => ev.Remove(one)); var two = new TestEvent(2); var three = new TestEvent(3); ev.Add(two); ev.Add(three); ev.Add(one); // add thired. ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10); two.NextCalled.Should().Equal(10, 20, 30); three.NextCalled.Should().Equal(10, 20, 30); } } public class RemoveNext { TriggerEvent ev; public void Run1() { TestEvent one = default; TestEvent two = default; TestEvent three = default; one = new TestEvent(1, () => ev.Remove(two)); two = new TestEvent(2); three = new TestEvent(3); ev.Add(one); ev.Add(two); ev.Add(three); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Count.Should().Be(0); three.NextCalled.Should().Equal(10, 20, 30); } public void Run2() { TestEvent one = default; TestEvent two = default; TestEvent three = default; one = new TestEvent(1, () => ev.Remove(two)); two = new TestEvent(2); three = new TestEvent(3); ev.Add(two); ev.Add(one); // add second ev.Add(three); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Should().Equal(10); three.NextCalled.Should().Equal(10, 20, 30); } public void Run3() { TestEvent one = default; TestEvent two = default; TestEvent three = default; one = new TestEvent(1, () => ev.Remove(two)); two = new TestEvent(2); three = new TestEvent(3); ev.Add(two); ev.Add(three); ev.Add(one); // add thired. ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Should().Equal(10); three.NextCalled.Should().Equal(10, 20, 30); } } public class RemoveNextNext { TriggerEvent ev; public void Run1() { TestEvent one = default; TestEvent two = default; TestEvent three = default; TestEvent four = default; one = new TestEvent(1, () => { ev.Remove(two); ev.Remove(three); }); two = new TestEvent(2); three = new TestEvent(3); four = new TestEvent(4); ev.Add(one); ev.Add(two); ev.Add(three); ev.Add(four); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10, 20, 30); two.NextCalled.Count.Should().Be(0); three.NextCalled.Count.Should().Be(0); four.NextCalled.Should().Equal(10, 20, 30); } public void Run2() { TestEvent one = default; TestEvent two = default; TestEvent three = default; TestEvent four = default; one = new TestEvent(1, () => { ev.Remove(one); ev.Remove(two); ev.Remove(three); }); two = new TestEvent(2); three = new TestEvent(3); four = new TestEvent(4); ev.Add(one); ev.Add(two); ev.Add(three); ev.Add(four); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); one.NextCalled.Should().Equal(10); two.NextCalled.Count.Should().Be(0); three.NextCalled.Count.Should().Be(0); four.NextCalled.Should().Equal(10, 20, 30); } } public class AddMe { TriggerEvent ev; public void Run1() { TestEvent one = default; TestEvent two = default; TestEvent three = default; TestEvent four = default; one = new TestEvent(1, () => { if (two == null) { ev.Add(two = new TestEvent(2)); } else if (three == null) { ev.Add(three = new TestEvent(3)); } else if (four == null) { ev.Add(four = new TestEvent(4)); } }); ev.Add(one); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); ev.SetResult(40); one.NextCalled.Should().Equal(10, 20, 30, 40); two.NextCalled.Should().Equal(20, 30, 40); three.NextCalled.Should().Equal(30, 40); four.NextCalled.Should().Equal(40); } public void Run2() { TestEvent one = default; TestEvent two = default; TestEvent three = default; TestEvent four = default; one = new TestEvent(1, () => { if (two == null) { ev.Add(two = new TestEvent(2, () => { if (three == null) { ev.Add(three = new TestEvent(3, () => { if (four == null) { ev.Add(four = new TestEvent(4)); } })); } })); } }); ev.Add(one); ev.SetResult(10); ev.SetResult(20); ev.SetResult(30); ev.SetResult(40); one.NextCalled.Should().Equal(10, 20, 30, 40); two.NextCalled.Should().Equal(20, 30, 40); three.NextCalled.Should().Equal(30, 40); four.NextCalled.Should().Equal(40); } } } public class TestEvent : ITriggerHandler { public readonly int Id; readonly Action iteratingEvent; public TestEvent(int id) { this.Id = id; } public TestEvent(int id, Action iteratingEvent) { this.Id = id; this.iteratingEvent = iteratingEvent; } public List NextCalled = new List(); public List ErrorCalled = new List(); public List CompletedCalled = new List(); public List CancelCalled = new List(); public ITriggerHandler Prev { get; set; } public ITriggerHandler Next { get; set; } public void OnCanceled(CancellationToken cancellationToken) { CancelCalled.Add(cancellationToken); } public void OnCompleted() { CompletedCalled.Add(new object()); } public void OnError(Exception ex) { ErrorCalled.Add(ex); } public void OnNext(int value) { NextCalled.Add(value); iteratingEvent?.Invoke(); } public override string ToString() { return Id.ToString(); } } } ================================================ FILE: src/UniTask.NetCoreTests/UniTask.NetCoreTests.csproj ================================================  net7.0 NetCoreTests all runtime; build; native; contentfiles; analyzers; buildtransitive ================================================ FILE: src/UniTask.NetCoreTests/UniTaskCompletionSourceTest.cs ================================================ using System.Threading.Tasks; using Cysharp.Threading.Tasks; using FluentAssertions; using NetCoreTests.Linq; using Xunit; namespace NetCoreTests { public class AutoResetUniTaskCompletionSourceTest { [Fact] public async Task SetResultAfterReturn() { var source1 = AutoResetUniTaskCompletionSource.Create(); source1.TrySetResult(); await source1.Task; source1.TrySetResult().Should().BeFalse(); var source2 = AutoResetUniTaskCompletionSource.Create(); source2.TrySetResult(); await source2.Task; source2.TrySetResult().Should().BeFalse(); } [Fact] public async Task SetCancelAfterReturn() { var source = AutoResetUniTaskCompletionSource.Create(); source.TrySetResult(); await source.Task; source.TrySetCanceled().Should().BeFalse(); } [Fact] public async Task SetExceptionAfterReturn() { var source = AutoResetUniTaskCompletionSource.Create(); source.TrySetResult(); await source.Task; source.TrySetException(new UniTaskTestException()).Should().BeFalse(); } [Fact] public async Task SetResultWithValueAfterReturn() { var source1 = AutoResetUniTaskCompletionSource.Create(); source1.TrySetResult(100); (await source1.Task).Should().Be(100); source1.TrySetResult(100).Should().BeFalse(); var source2 = AutoResetUniTaskCompletionSource.Create(); source2.TrySetResult(); await source2.Task; source2.TrySetResult().Should().BeFalse(); } [Fact] public async Task SetCancelWithValueAfterReturn() { var source = AutoResetUniTaskCompletionSource.Create(); source.TrySetResult(100); (await source.Task).Should().Be(100); source.TrySetCanceled().Should().BeFalse(); } [Fact] public async Task SetExceptionWithValueAfterReturn() { var source = AutoResetUniTaskCompletionSource.Create(); source.TrySetResult(100); (await source.Task).Should().Be(100); source.TrySetException(new UniTaskTestException()).Should().BeFalse(); } } } ================================================ FILE: src/UniTask.NetCoreTests/WhenEachTest.cs ================================================ using Cysharp.Threading.Tasks; using FluentAssertions; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Xunit; namespace NetCoreTests { public class WhenEachTest { [Fact] public async Task Each() { var a = Delay(1, 3000); var b = Delay(2, 1000); var c = Delay(3, 2000); var l = new List(); await foreach (var item in UniTask.WhenEach(a, b, c)) { l.Add(item.Result); } l.Should().Equal(2, 3, 1); } [Fact] public async Task Error() { var a = Delay2(1, 3000); var b = Delay2(2, 1000); var c = Delay2(3, 2000); var l = new List>(); await foreach (var item in UniTask.WhenEach(a, b, c)) { l.Add(item); } l[0].IsCompletedSuccessfully.Should().BeTrue(); l[0].IsFaulted.Should().BeFalse(); l[0].Result.Should().Be(2); l[1].IsCompletedSuccessfully.Should().BeFalse(); l[1].IsFaulted.Should().BeTrue(); l[1].Exception.Message.Should().Be("ERROR"); l[2].IsCompletedSuccessfully.Should().BeTrue(); l[2].IsFaulted.Should().BeFalse(); l[2].Result.Should().Be(1); } async UniTask Delay(int id, int sleep) { await Task.Delay(sleep); return id; } async UniTask Delay2(int id, int sleep) { await Task.Delay(sleep); if (id == 3) throw new Exception("ERROR"); return id; } } } ================================================ FILE: src/UniTask.NetCoreTests/WithCancellationTest.cs ================================================ using Cysharp.Threading.Tasks; using FluentAssertions; using System; using System.Collections.Generic; using System.Text; using System.Threading; using System.Threading.Tasks; using Xunit; namespace NetCoreTests { public class WithCancellationTest { [Fact] public async Task Standard() { CancellationTokenSource cts = new CancellationTokenSource(); var v = await UniTask.Run(() => 10).AttachExternalCancellation(cts.Token); v.Should().Be(10); } [Fact] public async Task Cancel() { CancellationTokenSource cts = new CancellationTokenSource(); var t = UniTask.Create(async () => { await Task.Delay(TimeSpan.FromSeconds(1)); return 10; }).AttachExternalCancellation(cts.Token); cts.Cancel(); (await Assert.ThrowsAsync(async () => await t)).CancellationToken.Should().Be(cts.Token); } } }