private Task <bool> MoveNextContinuation(Task <bool> t)
{
if (!t.Result)
{
return(TaskUtil.FalseTask);
}
if (_token.IsCancellationRequested)
{
return(TaskUtil.FromCanceled <bool>(_token));
}
return(_innerCursor.MoveNext() ? TaskUtil.TrueTask : MoveNext(_token));
}
private Task <bool> MoveNextSlow(CancellationToken cancellationToken)
{
// we took a task, but it could have been created after the previous update, need to try moving next
var task = _innerCursor.Source.Updated;
if (_innerCursor.MoveNext())
{
return(TaskUtil.TrueTask);
}
if (_innerCursor.Source.IsReadOnly)
{
// false almost always
if (_innerCursor.MoveNext())
{
return(TaskUtil.TrueTask);
}
return(TaskUtil.FalseTask);
}
// now task will always be completed by NotifyUpdate
Task <Task <bool> > returnTask = task.ContinueWith(continuationFunction: MoveNextContinuation,
continuationOptions: TaskContinuationOptions.DenyChildAttach);
if (!cancellationToken.CanBeCanceled)
{
return(returnTask.Unwrap());
}
if (_token != cancellationToken)
{
_registration.Dispose();
_token = cancellationToken;
_cancelledTcs = new TaskCompletionSource <Task <bool> >();
_registration = _token.Register(() =>
{
_cancelledTcs.SetResult(TaskUtil.FromCanceled <bool>(_token));
});
}
var anyReturn = Task.WhenAny(returnTask, _cancelledTcs.Task);
return(anyReturn.Unwrap().Unwrap());
}
public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (buffer is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.buffer);
}
if ((uint)offset > SharedConstants.TooBigOrNegative)
{
ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(ExceptionArgument.offset);
}
if ((uint)count > SharedConstants.TooBigOrNegative)
{
ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum(ExceptionArgument.count);
}
if ((uint)buffer.Length < (uint)(offset + count))
{
ThrowHelper.ThrowArgumentException_InvalidOffLen();
}
EnsureNotClosed();
EnsureWriteable();
// If cancellation is already requested, bail early
if (cancellationToken.IsCancellationRequested)
{
return(TaskUtil.FromCanceled(cancellationToken));
}
try
{
_ = _buffer.WriteBytes(buffer, offset, count);
return(TaskUtil.Completed);
}
//catch (OperationCanceledException oce)
//{
// return Task.FromCancellation<VoidTaskResult>(oce);
//}
catch (Exception exception)
{
return(TaskUtil.FromException(exception));
}
}
public override Task <int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(TaskUtil.FromCanceled <int>(cancellationToken));
}
try
{
var readNum = Read(buffer, offset, count);
return(Task.FromResult(readNum));
}
//catch (OperationCanceledException oce)
//{
// return Task.FromCancellation<int>(oce);
//}
catch (Exception ex2)
{
return(TaskUtil.FromException <int>(ex2));
}
}
