public TResult GetResult(short token)
{
var result = _core.GetResult(token);
Reset();
return(result);
}
public T GetResult(short token)
{
bool isValid = token == _valueTaskSource.Version;
try
{
return(_valueTaskSource.GetResult(token));
}
finally
{
if (isValid)
{
_valueTaskSource.Reset();
}
}
}
T IValueTaskSource <T> .GetResult(short token)
{
Debug.Assert(token == _source.Version);
// Get the result. This will throw if the stream has been aborted. In this case, we let the
// exception go through and don't reset the source.
T result = _source.GetResult(token);
// Reset the source to allow the stream to be signaled again.
_tokenRegistration.Dispose();
_tokenRegistration = default;
_source.Reset();
int value = Interlocked.CompareExchange(ref _signaled, 0, 1);
Debug.Assert(value == 1);
// If an exception is set, we try to set it on the source if it wasn't signaled in the meantime.
if (_exception != null)
{
if (Interlocked.CompareExchange(ref _signaled, 1, 0) == 0)
{
_source.RunContinuationsAsynchronously = true;
_source.SetException(_exception);
}
}
return(result);
}
public T GetResult(short token)
{
var res = tsc.GetResult(token);
tsc.Reset();
return(res);
}
public void GetResult(short token)
{
try
{
core.GetResult(token);
}
finally
{
Pool.Return(this);
}
}
void IValueTaskSource.GetResult(short token)
{
Debug.Assert(_hasWaiter == 0);
// Clean up the registration. This will wait for any in-flight cancellation to complete.
_waitSourceCancellation.Dispose();
_waitSourceCancellation = default;
// Propagate any exceptions if there were any.
_waitSource.GetResult(token);
}
private long GetResultAndRelease(short token)
{
try
{
return(_source.GetResult(token));
}
finally
{
_source.Reset();
_fileHandle.TryToReuse(this);
}
}
public int GetResult(short token)
{
try
{
return(_source.GetResult(token));
}
finally
{
// The instance is ready to be reused
_fileHandle.TryToReuse(this);
}
}
private int GetResultAndRelease(short token)
{
try
{
return(_source.GetResult(token));
}
finally
{
// The instance is ready to be reused
_strategy.TryToReuse(this);
}
}
public long GetResult(short token)
{
try
{
return(_source.GetResult(token));
}
finally
{
_source.Reset();
Volatile.Write(ref _fileHandle._reusableThreadPoolValueTaskSource, this);
}
}
void IValueTaskSource.GetResult(short token)
{
try
{
_TaskSource.GetResult(token);
}
finally
{
if (_InstanceState == Status.Completed || !_WaitForCompletion || Interlocked.CompareExchange(ref _InstanceState, Status.CancelledGotResult, Status.Cancelled) == Status.CancelledCompleted)
{
Release(); // Completed and not waiting for the callback to execute (or we don't care because it should be unregistered)
}
}
}
bool IValueTaskSource <bool> .GetResult(short token)
{
var isValid = token == _valueTaskSource.Version;
try
{
return(_valueTaskSource.GetResult(token));
}
finally
{
if (isValid)
{
_valueTaskSource.Reset();
_queue._cachedResettableTCS = this;
}
}
}
public ValueTask <bool> MoveNextAsync()
{
_vts.Reset();
CountAsyncEnumerable inst = this;
_builder.MoveNext(ref inst); // invokes MoveNext, protected by ExecutionContext guards
switch (_vts.GetStatus(_vts.Version))
{
case ValueTaskSourceStatus.Succeeded:
return(new ValueTask <bool>(_vts.GetResult(_vts.Version)));
default:
return(new ValueTask <bool>(this, _vts.Version));
}
}
public uint GetResult(short token)
{
var isValid = token == _valueTaskSource.Version;
try
{
return(_valueTaskSource.GetResult(token));
}
finally
{
if (isValid)
{
_valueTaskSource.Reset();
_stream._resettableCompletion = this;
}
}
}
public TMessage GetResult(short token)
{
return(core.GetResult(token));
}
public object?GetResult(short token)
{
return(_core.GetResult(token));
}
FlushResult IValueTaskSource <FlushResult> .GetResult(short token) => _responseCompleteTaskSource.GetResult(token);
T IValueTaskSource <T> .GetResult(short token)
{
return(_taskSourceCore.GetResult(token));
}
void IValueTaskSource.GetResult(short token)
{
_taskSourceCore.GetResult(token);
}
TPackageInfo IValueTaskSource <TPackageInfo> .GetResult(short token)
{
return(_packageTaskSource.GetResult(token));
}
bool IValueTaskSource <bool> .GetResult(short token)
{
return(_manualResetValueTaskSourceCore.GetResult(token));
}
public AirDropHubMessage GetResult(short token) => _valueTaskSource.GetResult(token);
public void GetResult(short token) => _valueTaskSource.GetResult(token);
T IValueTaskSource <T> .GetResult(short token) => _source.GetResult(token);
void IValueTaskSource.GetResult(short token) => _taskSource.GetResult(token);
int IValueTaskSource <int> .GetResult(short token) => _valueTaskSource.GetResult(token);
public TResult GetResult(short token) => _core.GetResult(token);
public void GetResult(short token) => _manualResetValueTaskSource.GetResult(token);
