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