public void SetException(Exception exception) { #if PROMISE_CANCEL if (exception is OperationCanceledException ex) { if (_deferred == null) { Task = Promise.Canceled(ex); } else { _deferred.Cancel(ex); _deferred = null; } } else #endif { if (_deferred == null) { Task = Promise.Rejected(exception); } else { _deferred.Reject(exception); _deferred = null; } } }
public void SetResult() { if (_deferred == null) { Task = Promise.Resolved(); } else { _deferred.Resolve(); _deferred = null; } }
public void UniTask() { Promise.Config.ObjectPooling = Promise.PoolType.All; // Create a promise to await so that the async functions won't complete synchronously. Promise.Deferred deferred = Promise.NewDeferred(); Promise promise = deferred.Promise; long counter = 0L; for (int i = 0; i < N; ++i) { // Forget so that the objects will repool. TaskVoid().Forget(); TaskVector().Forget(); TaskObject().Forget(); } async UniTask TaskVoid() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); } async UniTask <Vector4> TaskVector() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); return(Program.vector); } async UniTask <object> TaskObject() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); return(Program.obj); } deferred.Resolve(); Promise.Manager.HandleCompletesAndProgress(); while (Interlocked.Read(ref counter) > 0) { } }
public void DotNetTask() { Promise.Config.ObjectPooling = Promise.PoolType.All; // Create a promise to await so that the async functions won't complete synchronously. Promise.Deferred deferred = Promise.NewDeferred(); task_promise = deferred.Promise; task_counter = 0L; for (int i = 0; i < N; ++i) { _ = TaskVoid(); _ = TaskVector(); _ = TaskObject(); } async Task TaskVoid() { Interlocked.Increment(ref task_counter); await task_promise; Interlocked.Decrement(ref task_counter); } async Task <Vector4> TaskVector() { Interlocked.Increment(ref task_counter); await task_promise; Interlocked.Decrement(ref task_counter); return(Instances.vector); } async Task <object> TaskObject() { Interlocked.Increment(ref task_counter); await task_promise; Interlocked.Decrement(ref task_counter); return(Instances.obj); } deferred.Resolve(); Promise.Manager.HandleCompletesAndProgress(); while (Interlocked.Read(ref task_counter) > 0) { } }
private void Proto() { // Create a promise to await so that the async functions won't complete synchronously. Promise.Deferred deferred = Promise.NewDeferred(); Promise promise = deferred.Promise; long counter = 0L; for (int i = 0; i < N; ++i) { _ = TaskVoid(); _ = TaskVector(); _ = TaskObject(); } async Promise TaskVoid() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); } async Promise <Vector4> TaskVector() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); return(Program.vector); } async Promise <object> TaskObject() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); return(Program.obj); } deferred.Resolve(); Promise.Manager.HandleCompletesAndProgress(); while (Interlocked.Read(ref counter) > 0) { } }
private static void Execute() { // Create a promise to await so that the async functions won't complete synchronously. Promise.Deferred deferred = Promise.NewDeferred(); promise = deferred.Promise; counter = 0L; for (int i = 0; i < N; ++i) { _ = PromiseVoid(); _ = PromiseVector(); _ = PromiseObject(); } async Promise PromiseVoid() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); } async Promise <Vector4> PromiseVector() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); return(Instances.vector); } async Promise <object> PromiseObject() { Interlocked.Increment(ref counter); await promise; Interlocked.Decrement(ref counter); return(Instances.obj); } deferred.Resolve(); Promise.Manager.HandleCompletesAndProgress(); while (Interlocked.Read(ref counter) > 0) { } }
private void SetContinuation <TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine { if (_continuation == null) { _deferred = Promise.NewDeferred(); Task = _deferred.Promise; var sm = stateMachine; _continuation = () => { Promise.SetInvokingAsyncFunctionInternal(true); try { sm.MoveNext(); } finally { Promise.SetInvokingAsyncFunctionInternal(false); } }; } }