public override ManualResetValueTaskSource <object> GetAwaitable()
{
if (_awaitableQueue == null)
{
_awaitableQueue = new Queue <ManualResetValueTaskSource <object> >();
_awaitableCache = new Queue <ManualResetValueTaskSource <object> >();
}
// First attempt to reuse an existing awaitable in the queue
// to save allocating a new instance.
if (_awaitableCache.TryDequeue(out var awaitable))
{
// Reset previously used awaitable
Debug.Assert(awaitable.GetStatus() == ValueTaskSourceStatus.Succeeded, "Previous awaitable should have been completed.");
awaitable.Reset();
}
else
{
awaitable = new ManualResetValueTaskSource <object>();
}
_awaitableQueue.Enqueue(awaitable);
return(awaitable);
}
public async Task SetResult_RunContinuationsAsynchronously_ContinuationInvokedAccordingly(bool runContinuationsAsynchronously)
{
var mrvts = new ManualResetValueTaskSource <int>()
{
RunContinuationsAsynchronously = runContinuationsAsynchronously
};
for (short i = 0; i < 10; i++)
{
var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var tl = new ThreadLocal <int> {
Value = 42
};
mrvts.OnCompleted(
_ =>
{
Assert.Equal(!runContinuationsAsynchronously, tl.Value == 42);
tcs.SetResult();
},
null,
i,
ValueTaskSourceOnCompletedFlags.None);
mrvts.SetResult(42);
mrvts.Reset();
tl.Value = 0;
await tcs.Task;
}
}
public async Task SynchronizationContext_CaptureIfRequested(
bool runContinuationsAsynchronously, bool captureSyncCtx, bool setBeforeOnCompleted)
{
await Task.Run(async() => // escape xunit sync ctx
{
var mrvts = new ManualResetValueTaskSource <int>()
{
RunContinuationsAsynchronously = runContinuationsAsynchronously
};
if (setBeforeOnCompleted)
{
mrvts.SetResult(42);
}
var tcs = new TaskCompletionSource();
var sc = new TrackingSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(sc);
Assert.Equal(0, sc.Posts);
mrvts.OnCompleted(
_ => tcs.SetResult(),
null,
0,
captureSyncCtx ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
SynchronizationContext.SetSynchronizationContext(null);
if (!setBeforeOnCompleted)
{
mrvts.SetResult(42);
}
await tcs.Task;
Assert.Equal(captureSyncCtx ? 1 : 0, sc.Posts);
});
}
public void OnCompleted_UsedTwiceBeforeCompletion_Throws()
{
var mrvts = new ManualResetValueTaskSource <int>();
mrvts.OnCompleted(_ => { }, null, 0, ValueTaskSourceOnCompletedFlags.None);
Assert.Throws <InvalidOperationException>(() => mrvts.OnCompleted(_ => { }, null, 0, ValueTaskSourceOnCompletedFlags.None));
}
private async Task <RemoteInvokeResultMessage> RegisterResultCallbackAsync(string id,
CancellationToken cancellationToken)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"准备获取Id为：{id}的响应内容。");
}
var task = new ManualResetValueTaskSource <TransportMessage>();
_resultDictionary.TryAdd(id, task);
try
{
var result = await task.AwaitValue(cancellationToken);
return(result.GetContent <RemoteInvokeResultMessage>());
}
finally
{
// 删除回调任务
ManualResetValueTaskSource <TransportMessage> value;
_resultDictionary.TryRemove(id, out value);
value.SetCanceled();
}
}
public async Task SetResult_AfterOnCompleted_ResultAvailableAsynchronously()
{
var mrvts = new ManualResetValueTaskSource <int>();
mrvts.Reset();
mrvts.Reset();
Assert.Equal(2, mrvts.Version);
Assert.Equal(ValueTaskSourceStatus.Pending, mrvts.GetStatus(2));
Assert.Throws <InvalidOperationException>(() => mrvts.GetResult(2));
var onCompletedRan = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
mrvts.OnCompleted(s => ((TaskCompletionSource)s).SetResult(), onCompletedRan, 2, ValueTaskSourceOnCompletedFlags.None);
Assert.False(onCompletedRan.Task.IsCompleted);
await Task.Delay(1);
Assert.False(onCompletedRan.Task.IsCompleted);
mrvts.SetResult(42);
Assert.Equal(ValueTaskSourceStatus.Succeeded, mrvts.GetStatus(2));
Assert.Equal(42, mrvts.GetResult(2));
await onCompletedRan.Task;
Assert.Equal(2, mrvts.Version);
}
public void SetResult_RunContinuationsAsynchronously_ContinuationInvokedAccordingly(bool runContinuationsAsynchronously)
{
var mres = new ManualResetEventSlim();
var mrvts = new ManualResetValueTaskSource <int>()
{
RunContinuationsAsynchronously = runContinuationsAsynchronously
};
for (short i = 0; i < 10; i++)
{
int threadId = Environment.CurrentManagedThreadId;
mrvts.OnCompleted(
_ =>
{
Assert.Equal(!runContinuationsAsynchronously, threadId == Environment.CurrentManagedThreadId);
mres.Set();
},
null,
i,
ValueTaskSourceOnCompletedFlags.None);
mrvts.SetResult(42);
mres.Wait();
mrvts.Reset();
mres.Reset();
}
}
public int AdvanceUpToAndWait(long bytes, out ValueTask <object?> availabilityTask)
{
var leastAvailableFlow = _connectionLevelFlowControl.Available < _streamLevelFlowControl.Available
? _connectionLevelFlowControl : _streamLevelFlowControl;
// Clamp ~= Math.Clamp from netcoreapp >= 2.0
var actual = Clamp(leastAvailableFlow.Available, 0, bytes);
// Make sure to advance prior to accessing AvailabilityAwaitable.
_connectionLevelFlowControl.Advance(actual);
_streamLevelFlowControl.Advance(actual);
availabilityTask = default;
_currentConnectionLevelAwaitable = null;
_currentConnectionLevelAwaitableVersion = -1;
if (actual < bytes)
{
var awaitable = leastAvailableFlow.AvailabilityAwaitable;
if (leastAvailableFlow == _connectionLevelFlowControl)
{
_currentConnectionLevelAwaitable = awaitable;
_currentConnectionLevelAwaitableVersion = awaitable.Version;
}
availabilityTask = new ValueTask <object?>(awaitable, awaitable.Version);
}
return(actual);
}
public void AccessAfterReset_Fails()
{
var mrvts = new ManualResetValueTaskSource <int>();
mrvts.Reset();
Assert.Throws <InvalidOperationException>(() => mrvts.GetResult(0));
Assert.Throws <InvalidOperationException>(() => mrvts.GetStatus(0));
Assert.Throws <InvalidOperationException>(() => mrvts.OnCompleted(_ => { }, new object(), 0, ValueTaskSourceOnCompletedFlags.None));
}
public void SetException_OperationCanceledException_StatusIsCanceled()
{
var mrvts = new ManualResetValueTaskSource <int>();
var e = new OperationCanceledException();
mrvts.SetException(e);
Assert.Equal(ValueTaskSourceStatus.Canceled, mrvts.GetStatus(0));
Assert.Same(e, Assert.Throws <OperationCanceledException>(() => mrvts.GetResult(0)));
}
public async Task ManualTaskSource(int count)
{
for (int i = 0; i < count; i++)
{
var source = new ManualResetValueTaskSource <int>();
source.SetResult(i);
await source.AsTask();
}
}
public async Task Create()
{
var source = new ManualResetValueTaskSource <int>();
var valueTask = new ValueTask <int>(source, 0);
source.SetResult(10);
var result = await valueTask;
Assert.True(result == 10);
}
public void Reset(uint initialWindowSize)
{
_streamLevelFlowControl.Reset(initialWindowSize);
if (_currentConnectionLevelAwaitable != null)
{
Debug.Assert(_currentConnectionLevelAwaitable.GetStatus() == ValueTaskSourceStatus.Succeeded, "Should have been completed by the previous stream.");
_currentConnectionLevelAwaitable = null;
_currentConnectionLevelAwaitableVersion = -1;
}
}
public CircleTaskBuffer()
{
var first = new SingleLinks5 <T>(ArrayLength);
first.InReading = true;
first.Next = first;
_writePtr = first;
_readPtr = first;
_currentWrite = first.Buffer;
_currentRead = first.Buffer;
Parallel.For(0, ArrayLength, (index) => { _currentWrite[index] = new ManualResetValueTaskSource <T>(); });
}
public async Task ReuseInstanceWithResets_Success()
{
var mrvts = new ManualResetValueTaskSource <int>();
for (short i = 42; i < 48; i++)
{
var ignored = Task.Delay(1).ContinueWith(_ => mrvts.SetResult(i));
Assert.Equal(i, await new ValueTask <int>(mrvts, mrvts.Version));
Assert.Equal(i, await new ValueTask <int>(mrvts, mrvts.Version)); // can use multiple times until it's reset
mrvts.Reset();
}
}
public void SetTwice_Fails()
{
var mrvts = new ManualResetValueTaskSource <int>();
mrvts.SetResult(42);
Assert.Throws <InvalidOperationException>(() => mrvts.SetResult(42));
Assert.Throws <InvalidOperationException>(() => mrvts.SetException(new Exception()));
mrvts.Reset();
mrvts.SetException(new Exception());
Assert.Throws <InvalidOperationException>(() => mrvts.SetResult(42));
Assert.Throws <InvalidOperationException>(() => mrvts.SetException(new Exception()));
}
public static ManualResetValueTaskSource <T> Completed <T>(T result, Exception error = null)
{
var vts = new ManualResetValueTaskSource <T>();
if (error != null)
{
vts.SetException(error);
}
else
{
vts.SetResult(result);
}
return(vts);
}
public override ManualResetValueTaskSource <object?> GetAwaitable()
{
if (_awaitable == null)
{
_awaitable = new ManualResetValueTaskSource <object?>();
}
else
{
Debug.Assert(_awaitable.GetStatus() == ValueTaskSourceStatus.Succeeded, "Previous awaitable should have been completed.");
_awaitable.Reset();
}
return(_awaitable);
}
private async Task <RemoteInvokeResultMessage> RegisterResultCallbackAsync(string id, CancellationToken cancellationToken)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"准备获取Id为：{id}的响应内容。");
}
var task = new ManualResetValueTaskSource <TransportMessage>();
_resultDictionary.TryAdd(id, task);
try
{
var result = await task.AwaitValue(cancellationToken);
return(result.GetContent <RemoteInvokeResultMessage>());
}
catch (CPlatformException ex)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(ex.Message, ex);
}
return(new RemoteInvokeResultMessage()
{
ExceptionMessage = ex.Message,
StatusCode = ex.ExceptionCode,
});
}
catch (Exception ex)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError(ex.Message, ex);
}
return(new RemoteInvokeResultMessage()
{
ExceptionMessage = ex.Message,
StatusCode = StatusCode.UnKnownError,
});
}
finally
{
//删除回调任务
ManualResetValueTaskSource <TransportMessage> value;
_resultDictionary.TryRemove(id, out value);
value.SetCanceled();
}
}
public async Task CreateAndAwait_FromCompletedValueTaskSource_ConfigureAwait()
{
IValueTaskSource <int> vts = ManualResetValueTaskSource.Completed(42);
foreach (BenchmarkIteration iteration in Benchmark.Iterations)
{
long iters = Benchmark.InnerIterationCount;
using (iteration.StartMeasurement())
{
for (long i = 0; i < iters; i++)
{
await new ValueTask <int>(vts, 0).ConfigureAwait(false);
}
}
}
}
public async Task Reset_Success()
{
var source = new ManualResetValueTaskSource <int>();
var valueTask = new ValueTask <int>(source, source.Version);
source.SetResult(10);
var result = await valueTask;
Assert.True(result == 10);
source.Reset();
var valueTask_1 = new ValueTask <int>(source, source.Version);
source.SetResult(100);
result = await valueTask_1;
Assert.True(result == 100);
}
/// <summary>
/// Complete with or without an error.
/// </summary>
public static void SetExceptionOrResult(this ManualResetValueTaskSource ts, Exception exceptionOrNot)
{
if (ts is null)
{
throw new ArgumentNullException(nameof(ts));
}
if (exceptionOrNot is null)
{
ts.SetResult();
}
else
{
ts.SetException(exceptionOrNot);
}
}
public void Copy_PassAsArgumentAndReturn_FromValueTaskSource()
{
ValueTask <int> vt = new ValueTask <int>(ManualResetValueTaskSource.Completed(42), 0);
foreach (BenchmarkIteration iteration in Benchmark.Iterations)
{
long iters = Benchmark.InnerIterationCount;
using (iteration.StartMeasurement())
{
for (long i = 0; i < iters; i++)
{
vt = ReturnValueTask(vt);
}
}
}
}
public async Task Await_FromCompletedValueTaskSource()
{
ValueTask <int> vt = new ValueTask <int>(ManualResetValueTaskSource.Completed <int>(42), 0);
foreach (BenchmarkIteration iteration in Benchmark.Iterations)
{
long iters = Benchmark.InnerIterationCount;
using (iteration.StartMeasurement())
{
for (long i = 0; i < iters; i++)
{
await vt;
}
}
}
}
/// <summary>
/// 添加异步回调到表中
/// </summary>
/// <param name="Ids"></param>
/// <returns></returns>
protected virtual ManualResetValueTaskSource <Result> AddAsyncResult(long ids)
{
ManualResetValueTaskSource <Result> asyncResult = new ManualResetValueTaskSource <Result>();
if (!AsyncResultDict.TryAdd(ids, asyncResult))
{
Log.InfoFormat("add async back have id:{ids}", ids);
AsyncResultDict[ids] = asyncResult;
}
if (RequestOutTime > 0)
{
RequestOutTimeQueue.Enqueue(new RequestKeyTime(ids, TimeHelper.GetTime()));
}
return(asyncResult);
}
public static ManualResetValueTaskSource <T> Delay <T>(int delayMs, T result, Exception error = null)
{
var vts = new ManualResetValueTaskSource <T>();
Task.Delay(delayMs).ContinueWith(_ =>
{
if (error != null)
{
vts.SetException(error);
}
else
{
vts.SetResult(result);
}
});
return(vts);
}
private async Task <object> RegisterResultCallbackAsync(string id, CancellationToken cancellationToken)
{
var task = new ManualResetValueTaskSource <TransportMessage>();
_resultDictionary.TryAdd(id, task);
try
{
var result = await task.AwaitValue(cancellationToken);
return(result.GetContent <ReactiveResultMessage>()?.Result);
}
finally
{
//删除回调任务
ManualResetValueTaskSource <TransportMessage> value;
_resultDictionary.TryRemove(id, out value);
value.SetCanceled();
}
}
public IAsyncEnumerator <T> GetAsyncEnumerator(CancellationToken token)
{
if (token.IsCancellationRequested)
{
return(new LinxAsyncEnumerable.ThrowIterator <T>(new OperationCanceledException(token)));
}
var state = Atomic.Lock(ref _state);
if (state != _sInitial)
{
_state = state;
return(new CoroutineIterator <T>(this).GetAsyncEnumerator(token));
}
try
{
_tsAccepting = new();
_tsEmitting = new();
_tsEmitting.Reset();
_state = _sEmitting;
Produce(token);
if (token.CanBeCanceled)
{
_ctr = token.Register(() => SetFinal(new OperationCanceledException(token)));
}
return(this);
}
catch (Exception ex)
{
_state = Atomic.LockBit;
Current = default;
_tsAccepting = default;
_tsEmitting = default;
_atmbFinal = default;
_atmbDisposed = default;
_ctr = default;
_state = _sFinal;
_atmbFinal.SetException(ex);
_atmbDisposed.SetResult();
return(new LinxAsyncEnumerable.ThrowIterator <T>(ex));
}
}
public CircleTaskBuffer2()
{
_writeQueue = new Queue <ManualResetValueTaskSource <T>[]>(32);
_readQueue = new Queue <ManualResetValueTaskSource <T>[]>(32);
var _current = new ManualResetValueTaskSource <T> [ArrayLength];
for (int i = 0; i < ArrayLength; i++)
{
_current[i] = new ManualResetValueTaskSource <T>();
}
_currentWrite = _current;
_currentRead = _current;
_readQueue.Enqueue(_currentRead);
//_list = new List<int>();
//_cache = new HashSet<int>();
//_index = new HashSet<int>();
//_repeates = new List<ManualResetValueTaskSource<T>>();
//Task.Run(() =>
//{
// for (int i = 0; i < 10; i++)
// {
// Thread.Sleep(10000);
// if (_index.Count>0)
// {
// Console.WriteLine("HashCode:" + _list.Count);
// Console.WriteLine("自增索引："+_index.Count);
// Console.WriteLine("无重复HashCode：" + _cache.Count);
// }
// }
// Console.WriteLine("End");
// foreach (var item in _repeates)
// {
// if (item.AwaitableTask.IsCanceled)
// {
// Console.WriteLine("已取消！");
// }
// item.SetResult((T)(object)(true));
// }
//});
}
public void SetResult_BeforeOnCompleted_ResultAvailableSynchronously()
{
var mrvts = new ManualResetValueTaskSource <int>();
mrvts.Reset();
mrvts.Reset();
Assert.Equal(2, mrvts.Version);
mrvts.SetResult(42);
Assert.Equal(ValueTaskSourceStatus.Succeeded, mrvts.GetStatus(2));
Assert.Equal(42, mrvts.GetResult(2));
var mres = new ManualResetEventSlim();
mrvts.OnCompleted(s => ((ManualResetEventSlim)s).Set(), mres, 2, ValueTaskSourceOnCompletedFlags.None);
mres.Wait();
Assert.Equal(2, mrvts.Version);
}
