2.0.10-rc7

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

@@ -14,16 +14,19 @@ namespace Cysharp.Threading.Tasks
     {
         public static UniTask.Awaiter GetAwaiter(this IEnumerator enumerator)
         {
+            Error.ThrowArgumentNullException(enumerator, nameof(enumerator));
             return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, CancellationToken.None, out var token), token).GetAwaiter();
         }
 
-        public static UniTask ToUniTask(this IEnumerator enumerator)
+        public static UniTask WithCancellation(this IEnumerator enumerator, CancellationToken cancellationToken)
         {
-            return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, CancellationToken.None, out var token), token);
+            Error.ThrowArgumentNullException(enumerator, nameof(enumerator));
+            return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, cancellationToken, out var token), token);
         }
 
-        public static UniTask ConfigureAwait(this IEnumerator enumerator, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        public static UniTask ToUniTask(this IEnumerator enumerator, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
+            Error.ThrowArgumentNullException(enumerator, nameof(enumerator));
             return new UniTask(EnumeratorPromise.Create(enumerator, timing, cancellationToken, out var token), token);
         }
 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/AddressableAsyncExtensions.cs

@@ -13,21 +13,23 @@ namespace Cysharp.Threading.Tasks
 {
     public static class AddressableAsyncExtensions
     {
-#region AsyncOperationHandle
+        #region AsyncOperationHandle
 
         public static AsyncOperationHandleAwaiter GetAwaiter(this AsyncOperationHandle handle)
         {
             return new AsyncOperationHandleAwaiter(handle);
         }
 
-        public static UniTask ToUniTask(this AsyncOperationHandle handle)
+        public static UniTask WithCancellation(this AsyncOperationHandle handle, CancellationToken cancellationToken)
         {
-            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (handle.IsDone) return UniTask.CompletedTask;
+            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
         }
 
-        public static UniTask ConfigureAwait(this AsyncOperationHandle handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask ToUniTask(this AsyncOperationHandle handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
-            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellation, out var token), token);
+            if (handle.IsDone) return UniTask.CompletedTask;
+            return new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellationToken, out var token), token);
         }
 
         public struct AsyncOperationHandleAwaiter : ICriticalNotifyCompletion
@@ -75,7 +77,7 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        sealed class AsyncOperationHandleConfiguredSource : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
         {
             static readonly PromisePool<AsyncOperationHandleConfiguredSource> pool = new PromisePool<AsyncOperationHandleConfiguredSource>();
 
@@ -185,22 +187,24 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-#endregion
+        #endregion
 
-#region AsyncOperationHandle_T
+        #region AsyncOperationHandle_T
 
         public static AsyncOperationHandleAwaiter<T> GetAwaiter<T>(this AsyncOperationHandle<T> handle)
         {
             return new AsyncOperationHandleAwaiter<T>(handle);
         }
 
-        public static UniTask<T> ToUniTask<T>(this AsyncOperationHandle<T> handle)
+        public static UniTask<T> WithCancellation<T>(this AsyncOperationHandle<T> handle, CancellationToken cancellationToken)
         {
-            return new UniTask<T>(AsyncOperationHandleConfiguredSource<T>.Create(handle, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (handle.IsDone) return UniTask.FromResult(handle.Result);
+            return new UniTask<T>(AsyncOperationHandleConfiguredSource<T>.Create(handle, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
         }
 
-        public static UniTask<T> ConfigureAwait<T>(this AsyncOperationHandle<T> handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask<T> ToUniTask<T>(this AsyncOperationHandle<T> handle, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
         {
+            if (handle.IsDone) return UniTask.FromResult(handle.Result);
             return new UniTask<T>(AsyncOperationHandleConfiguredSource<T>.Create(handle, timing, progress, cancellation, out var token), token);
         }
 
@@ -250,7 +254,7 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-        class AsyncOperationHandleConfiguredSource<T> : IUniTaskSource<T>, IPlayerLoopItem, IPromisePoolItem
+        sealed class AsyncOperationHandleConfiguredSource<T> : IUniTaskSource<T>, IPlayerLoopItem, IPromisePoolItem
         {
             static readonly PromisePool<AsyncOperationHandleConfiguredSource<T>> pool = new PromisePool<AsyncOperationHandleConfiguredSource<T>>();
 
@@ -366,7 +370,7 @@ namespace Cysharp.Threading.Tasks
             }
         }
 
-#endregion
+        #endregion
     }
 }
 

src/UniTask/Assets/Plugins/UniTask/Runtime/External/DoTweenAsyncExtensions.cs

@@ -0,0 +1,245 @@
+// 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.Runtime.CompilerServices;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    // The idea of TweenCancelBehaviour is borrowed from https://www.shibuya24.info/entry/dotween_async_await
+    public enum TweenCancelBehaviour
+    {
+        Kill,
+        KillWithCompleteCallback,
+        Complete,
+        CompleteWithSeqeunceCallback,
+        CancelAwait,
+
+        // AndCancelAwait
+        KillAndCancelAwait,
+        KillWithCompleteCallbackAndCancelAwait,
+        CompleteAndCancelAwait,
+        CompleteWithSeqeunceCallbackAndCancelAwait
+    }
+
+    public static class DOTweenAsyncExtensions
+    {
+        public static TweenAwaiter GetAwaiter(this Tween tween)
+        {
+            return new TweenAwaiter(tween);
+        }
+
+        public static UniTask WithCancellation(this Tween tween, CancellationToken cancellationToken = default)
+        {
+            Error.ThrowArgumentNullException(tween, nameof(tween));
+
+            if (!tween.IsActive()) return UniTask.CompletedTask;
+            return new UniTask(TweenConfiguredSource.Create(tween, TweenCancelBehaviour.Kill, cancellationToken, out var token), token);
+        }
+
+        public static UniTask ToUniTask(this Tween tween, TweenCancelBehaviour tweenCancelBehaviour = TweenCancelBehaviour.Kill, CancellationToken cancellationToken = default)
+        {
+            Error.ThrowArgumentNullException(tween, nameof(tween));
+
+            if (!tween.IsActive()) return UniTask.CompletedTask;
+            return new UniTask(TweenConfiguredSource.Create(tween, tweenCancelBehaviour, cancellationToken, out var token), token);
+        }
+
+        public struct TweenAwaiter : ICriticalNotifyCompletion
+        {
+            readonly Tween tween;
+
+            // killed(non active) as completed.
+            public bool IsCompleted => !tween.IsActive();
+
+            public TweenAwaiter(Tween tween)
+            {
+                this.tween = tween;
+            }
+
+            public TweenAwaiter GetAwaiter()
+            {
+                return this;
+            }
+
+            public void GetResult()
+            {
+            }
+
+            public void OnCompleted(System.Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(System.Action continuation)
+            {
+                // convert Action -> TweenCallback allocation.
+                // onKill is called after OnCompleted, both Complete(false/true) and Kill(false/true).
+                tween.onKill = new TweenCallback(continuation);
+            }
+        }
+
+        sealed class TweenConfiguredSource : IUniTaskSource, IPromisePoolItem
+        {
+            static readonly PromisePool<TweenConfiguredSource> pool = new PromisePool<TweenConfiguredSource>();
+            static Action<object> CancellationCallbackDelegate = CancellationCallback;
+
+            Tween tween;
+            TweenCancelBehaviour cancelBehaviour;
+            CancellationToken cancellationToken;
+            bool canceled;
+
+            CancellationTokenRegistration cancellationTokenRegistration;
+            UniTaskCompletionSourceCore<AsyncUnit> core;
+
+            TweenConfiguredSource()
+            {
+
+            }
+
+            public static IUniTaskSource Create(Tween tween, TweenCancelBehaviour cancelBehaviour, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                var result = pool.TryRent() ?? new TweenConfiguredSource();
+
+                result.tween = tween;
+                result.cancelBehaviour = cancelBehaviour;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                result.RegisterEvent();
+
+                token = result.core.Version;
+                return result;
+            }
+
+            void RegisterEvent()
+            {
+                if (cancellationToken.CanBeCanceled)
+                {
+                    cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(CancellationCallbackDelegate, this);
+                }
+
+                // allocate delegate.
+                tween.OnKill(new TweenCallback(OnKill));
+            }
+
+            void OnKill()
+            {
+                cancellationTokenRegistration.Dispose();
+                if (canceled)
+                {
+                    if (cancelBehaviour == TweenCancelBehaviour.CancelAwait)
+                    {
+                        // already called TrySetCanceled, do nothing.
+                    }
+                    else
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                    }
+                }
+                else
+                {
+                    core.TrySetResult(AsyncUnit.Default);
+                }
+            }
+
+            static void CancellationCallback(object state)
+            {
+                var self = (TweenConfiguredSource)state;
+
+                switch (self.cancelBehaviour)
+                {
+                    case TweenCancelBehaviour.Kill:
+                    default:
+                        self.tween.Kill(false);
+                        break;
+                    case TweenCancelBehaviour.KillAndCancelAwait:
+                        self.canceled = true;
+                        self.tween.Kill(false);
+                        break;
+                    case TweenCancelBehaviour.KillWithCompleteCallback:
+                        self.tween.Kill(true);
+                        break;
+                    case TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait:
+                        self.canceled = true;
+                        self.tween.Kill(true);
+                        break;
+                    case TweenCancelBehaviour.Complete:
+                        self.tween.Complete(false);
+                        break;
+                    case TweenCancelBehaviour.CompleteAndCancelAwait:
+                        self.canceled = true;
+                        self.tween.Complete(false);
+                        break;
+                    case TweenCancelBehaviour.CompleteWithSeqeunceCallback:
+                        self.tween.Complete(true);
+                        break;
+                    case TweenCancelBehaviour.CompleteWithSeqeunceCallbackAndCancelAwait:
+                        self.canceled = true;
+                        self.tween.Complete(true);
+                        break;
+                    case TweenCancelBehaviour.CancelAwait:
+                        self.canceled = true;
+                        self.core.TrySetCanceled(self.cancellationToken);
+                        break;
+                }
+            }
+
+            public void GetResult(short token)
+            {
+                try
+                {
+                    TaskTracker.RemoveTracking(this);
+                    core.GetResult(token);
+                }
+                finally
+                {
+                    pool.TryReturn(this);
+                }
+            }
+
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public void Reset()
+            {
+                core.Reset();
+                tween = default;
+                cancellationToken = default;
+            }
+
+            ~TweenConfiguredSource()
+            {
+                if (pool.TryReturn(this))
+                {
+                    GC.ReRegisterForFinalize(this);
+                }
+            }
+        }
+    }
+}
+
+#endif

src/UniTask/Assets/Plugins/UniTask/Runtime/External/DoTweenAsyncExtensions.cs.meta

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

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

@@ -159,6 +159,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 }
                 catch (Exception ex)
                 {
+                    self.running<#= j #> = true; // as complete, no more call MoveNextAsync.
                     self.completedCount = CompleteCount;
                     self.completionSource.TrySetException(ex);
                     return;
@@ -168,6 +169,7 @@ namespace Cysharp.Threading.Tasks.Linq
                 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();

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

@@ -105,34 +105,67 @@ namespace Cysharp.Threading.Tasks
         /// helper of create add UniTaskVoid to delegate.
         /// For example: FooEvent += () => UniTask.Void(async () => { /* */ })
         /// </summary>
-        public static void Void(Func<UniTask> asyncAction)
+        public static void Void(Func<UniTaskVoid> asyncAction)
         {
             asyncAction().Forget();
         }
 
-        public static Action VoidAction(Func<UniTask> asyncAction)
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// </summary>
+        public static void Void(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
         {
-            return () => Void(asyncAction);
+            asyncAction(cancellationToken).Forget();
         }
 
-#if UNITY_2018_3_OR_NEWER
-
-        public static UnityEngine.Events.UnityAction VoidUnityAction(Func<UniTask> asyncAction)
-        {
-            return () => Void(asyncAction);
-        }
-
-#endif
-
         /// <summary>
         /// helper of create add UniTaskVoid to delegate.
         /// For example: FooEvent += (sender, e) => UniTask.Void(async arg => { /* */ }, (sender, e))
         /// </summary>
-        public static void Void<T>(Func<T, UniTask> asyncAction, T state)
+        public static void Void<T>(Func<T, UniTaskVoid> asyncAction, T state)
         {
             asyncAction(state).Forget();
         }
 
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// For example: FooAction = UniTask.Action(async () => { /* */ })
+        /// </summary>
+        public static Action Action(Func<UniTaskVoid> asyncAction)
+        {
+            return () => asyncAction().Forget();
+        }
+
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// </summary>
+        public static Action Action(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
+        {
+            return () => asyncAction(cancellationToken).Forget();
+        }
+
+#if UNITY_2018_3_OR_NEWER
+
+        /// <summary>
+        /// Create async void(UniTaskVoid) UnityAction.
+        /// For exampe: onClick.AddListener(UniTask.UnityAction(async () => { /* */ } ))
+        /// </summary>
+        public static UnityEngine.Events.UnityAction UnityAction(Func<UniTaskVoid> asyncAction)
+        {
+            return () => asyncAction().Forget();
+        }
+
+        /// <summary>
+        /// Create async void(UniTaskVoid) UnityAction.
+        /// For exampe: onClick.AddListener(UniTask.UnityAction(FooAsync, this.GetCancellationTokenOnDestroy()))
+        /// </summary>
+        public static UnityEngine.Events.UnityAction UnityAction(Func<CancellationToken, UniTaskVoid> asyncAction, CancellationToken cancellationToken)
+        {
+            return () => asyncAction(cancellationToken).Forget();
+        }
+
+#endif
+
         /// <summary>
         /// Defer the task creation just before call await.
         /// </summary>

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

@@ -2,7 +2,8 @@
     "name": "UniTask",
     "references": [
         "Unity.ResourceManager",
-        "Unity.TextMeshPro"
+        "Unity.TextMeshPro",
+        "DOTween.Modules"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],
@@ -21,6 +22,11 @@
             "name": "com.unity.textmeshpro",
             "expression": "",
             "define": "UNITASK_TEXTMESHPRO_SUPPORT"
+        },
+        {
+            "name": "com.demigiant.dotween",
+            "expression": "",
+            "define": "UNITASK_DOTWEEN_SUPPORT"
         }
     ],
     "noEngineReferences": false

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

@@ -123,7 +123,14 @@ namespace Cysharp.Threading.Tasks
             {
                 // setup result
                 this.hasUnhandledError = true;
-                this.error = ExceptionDispatchInfo.Capture(error);
+                if (error is OperationCanceledException)
+                {
+                    this.error = error;
+                }
+                else
+                {
+                    this.error = ExceptionDispatchInfo.Capture(error);
+                }
 
                 if (continuation != null || Interlocked.CompareExchange(ref this.continuation, UniTaskCompletionSourceCoreShared.s_sentinel, null) != null)
                 {

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

@@ -559,36 +559,6 @@ namespace Cysharp.Threading.Tasks
             return await continuationFunction();
         }
 
-#if UNITY_2018_3_OR_NEWER
-
-        public static async UniTask ConfigureAwait(this Task task, PlayerLoopTiming timing)
-        {
-            await task.ConfigureAwait(false);
-            await UniTask.Yield(timing);
-        }
-
-        public static async UniTask<T> ConfigureAwait<T>(this Task<T> task, PlayerLoopTiming timing)
-        {
-            var v = await task.ConfigureAwait(false);
-            await UniTask.Yield(timing);
-            return v;
-        }
-
-        public static async UniTask ConfigureAwait(this UniTask task, PlayerLoopTiming timing)
-        {
-            await task;
-            await UniTask.Yield(timing);
-        }
-
-        public static async UniTask<T> ConfigureAwait<T>(this UniTask<T> task, PlayerLoopTiming timing)
-        {
-            var v = await task;
-            await UniTask.Yield(timing);
-            return v;
-        }
-
-#endif
-
         public static async UniTask<T> Unwrap<T>(this UniTask<UniTask<T>> task)
         {
             return await await task;

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

@@ -28,22 +28,8 @@ namespace Cysharp.Threading.Tasks
 
             return new UniTask(handler, token).GetAwaiter();
         }
-
-        public static UniTask ToUniTask(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);
-        }
-
-        public static UniTask ConfigureAwait(this JobHandle jobHandle, PlayerLoopTiming waitTiming)
+     
+        public static UniTask ToUniTask(this JobHandle jobHandle, PlayerLoopTiming waitTiming)
         {
             var handler = JobHandlePromise.Create(jobHandle, out var token);
             {

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

@@ -21,18 +21,18 @@ namespace Cysharp.Threading.Tasks
             return new AsyncOperationAwaiter(asyncOperation);
         }
 
-        public static UniTask ToUniTask(this AsyncOperation asyncOperation)
+        public static UniTask WithCancellation(this AsyncOperation asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask(AsyncOperationConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (asyncOperation.isDone) return UniTask.CompletedTask;
+            return new UniTask(AsyncOperationConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
         }
 
-        public static UniTask ConfigureAwait(this AsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask ToUniTask(this AsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask(AsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellation, out var token), token);
+            if (asyncOperation.isDone) return UniTask.CompletedTask;
+            return new UniTask(AsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
 
         public struct AsyncOperationAwaiter : ICriticalNotifyCompletion
@@ -125,7 +125,6 @@ namespace Cysharp.Threading.Tasks
                 }
             }
 
-
             public UniTaskStatus GetStatus(short token)
             {
                 return core.GetStatus(token);
@@ -190,18 +189,18 @@ namespace Cysharp.Threading.Tasks
             return new ResourceRequestAwaiter(asyncOperation);
         }
 
-        public static UniTask<UnityEngine.Object> ToUniTask(this ResourceRequest asyncOperation)
+        public static UniTask<UnityEngine.Object> WithCancellation(this ResourceRequest asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask<UnityEngine.Object>(ResourceRequestConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
+            return new UniTask<UnityEngine.Object>(ResourceRequestConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
         }
 
-        public static UniTask<UnityEngine.Object> ConfigureAwait(this ResourceRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask<UnityEngine.Object> ToUniTask(this ResourceRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask<UnityEngine.Object>(ResourceRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellation, out var token), token);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
+            return new UniTask<UnityEngine.Object>(ResourceRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
 
         public struct ResourceRequestAwaiter : ICriticalNotifyCompletion
@@ -367,18 +366,18 @@ namespace Cysharp.Threading.Tasks
             return new AssetBundleRequestAwaiter(asyncOperation);
         }
 
-        public static UniTask<UnityEngine.Object> ToUniTask(this AssetBundleRequest asyncOperation)
+        public static UniTask<UnityEngine.Object> WithCancellation(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask<UnityEngine.Object>(AssetBundleRequestConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
+            return new UniTask<UnityEngine.Object>(AssetBundleRequestConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
         }
 
-        public static UniTask<UnityEngine.Object> ConfigureAwait(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask<UnityEngine.Object> ToUniTask(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask<UnityEngine.Object>(AssetBundleRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellation, out var token), token);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
+            return new UniTask<UnityEngine.Object>(AssetBundleRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
 
         public struct AssetBundleRequestAwaiter : ICriticalNotifyCompletion
@@ -544,18 +543,18 @@ namespace Cysharp.Threading.Tasks
             return new AssetBundleCreateRequestAwaiter(asyncOperation);
         }
 
-        public static UniTask<AssetBundle> ToUniTask(this AssetBundleCreateRequest asyncOperation)
+        public static UniTask<AssetBundle> WithCancellation(this AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask<AssetBundle>(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
+            return new UniTask<AssetBundle>(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
         }
 
-        public static UniTask<AssetBundle> ConfigureAwait(this AssetBundleCreateRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask<AssetBundle> ToUniTask(this AssetBundleCreateRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask<AssetBundle>(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellation, out var token), token);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
+            return new UniTask<AssetBundle>(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
 
         public struct AssetBundleCreateRequestAwaiter : ICriticalNotifyCompletion
@@ -722,18 +721,18 @@ namespace Cysharp.Threading.Tasks
             return new UnityWebRequestAsyncOperationAwaiter(asyncOperation);
         }
 
-        public static UniTask<UnityWebRequest> ToUniTask(this UnityWebRequestAsyncOperation asyncOperation)
+        public static UniTask<UnityWebRequest> WithCancellation(this UnityWebRequestAsyncOperation asyncOperation, CancellationToken cancellationToken)
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask<UnityWebRequest>(UnityWebRequestAsyncOperationConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, CancellationToken.None, out var token), token);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.webRequest);
+            return new UniTask<UnityWebRequest>(UnityWebRequestAsyncOperationConfiguredSource.Create(asyncOperation, PlayerLoopTiming.Update, null, cancellationToken, out var token), token);
         }
 
-        public static UniTask<UnityWebRequest> ConfigureAwait(this UnityWebRequestAsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        public static UniTask<UnityWebRequest> ToUniTask(this UnityWebRequestAsyncOperation asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
         {
             Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-
-            return new UniTask<UnityWebRequest>(UnityWebRequestAsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellation, out var token), token);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.webRequest);
+            return new UniTask<UnityWebRequest>(UnityWebRequestAsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
         }
 
         public struct UnityWebRequestAsyncOperationAwaiter : ICriticalNotifyCompletion

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

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

src/UniTask/Assets/Scenes/SandboxMain.cs

@@ -12,6 +12,9 @@ using Unity.Jobs;
 using UnityEngine;
 using UnityEngine.UI;
 
+
+// using DG.Tweening;
+
 public struct MyJob : IJob
 {
     public int loopCount;
@@ -142,7 +145,7 @@ public class SandboxMain : MonoBehaviour
     {
         // State<int> Hp { get; }
 
-        
+
 
 
         public Model()
@@ -173,7 +176,7 @@ public class SandboxMain : MonoBehaviour
 
     void Start2()
     {
-        
+
     }
 
 
@@ -240,16 +243,9 @@ public class SandboxMain : MonoBehaviour
         public int MyProperty { get; set; }
     }
 
-    MyClass mcc;
 
-    void Start()
+    void  Start()
     {
-        this.mcc = new MyClass();
-        this.MyProperty = 999;
-
-        CheckDest().Forget();
-
-
         //UniTaskAsyncEnumerable.EveryValueChanged(mcc, x => x.MyProperty)
         //    .Do(_ => { }, () => Debug.Log("COMPLETED"))
         //    .ForEachAsync(x =>
@@ -260,37 +256,51 @@ public class SandboxMain : MonoBehaviour
 
 
 
-        
+        // DG.Tweening.Core.TweenerCore<int>
+        //okButton.GetComponent<RectTransform>().DOMoveX(10.2f, 30);
 
 
+        // DOTween.To(
+
+        var cts = new CancellationTokenSource();
+
+        //var tween = okButton.GetComponent<RectTransform>().DOLocalMoveX(100, 5.0f);
+
+        cancelButton.OnClickAsAsyncEnumerable().ForEachAsync(_ =>
+        {
+            cts.Cancel();
+        }).Forget();
+
+
+        // await tween.ToUniTask(TweenCancelBehaviour.KillAndCancelAwait, cts.Token);
+
+        //tween.SetRecyclable(true);
+
+        Debug.Log("END");
+
+        // tween.Play();
+
+        // DOTween.
+
+        // DOVirtual.Float(0, 1, 1, x => { }).ToUniTask();
+
         okButton.OnClickAsAsyncEnumerable().ForEachAsync(_ =>
         {
 
-            mcc.MyProperty += 10;
+
 
 
 
         }).Forget();
 
-        cancelButton.OnClickAsAsyncEnumerable().ForEachAsync(_ =>
-        {
-            this.mcc = null;
-        });
 
+
+        okButton.onClick.AddListener(UniTask.UnityAction(async () => await UniTask.Yield()));
     }
 
-    async UniTaskVoid CheckDest()
+    async UniTaskVoid CloseAsync(CancellationToken cancellationToken = default)
     {
-        try
-        {
-            Debug.Log("WAIT");
-            await UniTask.WaitUntilValueChanged(mcc, x => x.MyProperty);
-            Debug.Log("CHANGED?");
-        }
-        finally
-        {
-            Debug.Log("END");
-        }
+        await UniTask.Yield();
     }
 
     async UniTaskVoid Running(CancellationToken ct)
@@ -525,7 +535,7 @@ public class SandboxMain : MonoBehaviour
 
 public class ShowPlayerLoop
 {
-    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+    // [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
     static void Init()
     {
         var playerLoop = UnityEngine.LowLevel.PlayerLoop.GetDefaultPlayerLoop();

src/UniTask/Assets/Tests/AsyncTest.cs

@@ -124,7 +124,6 @@ namespace Cysharp.Threading.TasksTests
         public IEnumerator BothEnumeratorCheck() => UniTask.ToCoroutine(async () =>
         {
             await ToaruCoroutineEnumerator(); // wait 5 frame:)
-            await ToaruCoroutineEnumerator().ConfigureAwait(PlayerLoopTiming.PostLateUpdate);
         });
 
         [UnityTest]

src/UniTask/Assets/Tests/Editor/AsyncTestEditor.cs

@@ -124,7 +124,6 @@ namespace Cysharp.Threading.TasksTests
         public IEnumerator BothEnumeratorCheck() => UniTask.ToCoroutine(async () =>
         {
             await ToaruCoroutineEnumerator(); // wait 5 frame:)
-            await ToaruCoroutineEnumerator().ConfigureAwait(PlayerLoopTiming.PostLateUpdate);
         });
 
         [UnityTest]

src/UniTask/Assets/Tests/Editor/UniTask.Tests.Editor.asmdef

@@ -5,7 +5,8 @@
         "UnityEditor.TestRunner",
         "UniTask.Tests",
         "UniTask",
-        "Unity.ResourceManager"
+        "Unity.ResourceManager",
+        "DOTween.Modules"
     ],
     "includePlatforms": [
         "Editor"
@@ -14,7 +15,8 @@
     "allowUnsafeCode": false,
     "overrideReferences": true,
     "precompiledReferences": [
-        "nunit.framework.dll"
+        "nunit.framework.dll",
+        "DOTween.dll"
     ],
     "autoReferenced": false,
     "defineConstraints": [

src/UniTask/Assets/Tests/UniTask.Tests.asmdef

@@ -4,14 +4,16 @@
         "UnityEngine.TestRunner",
         "UnityEditor.TestRunner",
         "UniTask",
-        "Unity.ResourceManager"
+        "Unity.ResourceManager",
+        "DOTween.Modules"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],
     "allowUnsafeCode": false,
     "overrideReferences": true,
     "precompiledReferences": [
-        "nunit.framework.dll"
+        "nunit.framework.dll",
+        "DOTween.dll"
     ],
     "autoReferenced": false,
     "defineConstraints": [