static void Main()
{
mrvts = new ManualResetValueTaskSource <int>();
_task = new ValueTask <int>(mrvts, 0).ConfigureAwait(false);
//mrvts.OnCompleted(s => { Console.WriteLine(1); }, null, 2, ValueTaskSourceOnCompletedFlags.None);
//mrvts.Reset();
//mrvts.Reset();
//Console.WriteLine(mrvts.Version);
//mrvts.SetResult(42);
//Assert.Equal(ValueTaskSourceStatus.Succeeded, mrvts.GetStatus(2));
//Assert.Equal(42, mrvts.GetResult(2));
//Test();
Task.Run(() =>
{
for (int i = 0; i < 10; i++)
{
Run();
Thread.Sleep(3000);
mrvts.SetResult(i);
//mrvts.Reset();
//mrvts.ve
}
});
//Assert.Equal(2, mrvts.Version);
Console.ReadKey();
}
private protected async Task SerializeToStreamAsyncCore(
Stream stream,
TransportContext context,
CancellationToken cancellationToken)
{
MultipartContent multipartContent = this;
try
{
ConfiguredValueTaskAwaitable valueTaskAwaitable = MultipartContent.EncodeStringToStreamAsync(stream, "--" + multipartContent._boundary + "\r\n", cancellationToken).ConfigureAwait(false);
await valueTaskAwaitable;
StringBuilder output = new StringBuilder();
for (int contentIndex = 0; contentIndex < multipartContent._nestedContent.Count; ++contentIndex)
{
HttpContent content = multipartContent._nestedContent[contentIndex];
valueTaskAwaitable = MultipartContent.EncodeStringToStreamAsync(stream, multipartContent.SerializeHeadersToString(output, contentIndex, content), cancellationToken).ConfigureAwait(false);
await valueTaskAwaitable;
await content.CopyToAsync(stream, context, cancellationToken).ConfigureAwait(false);
content = (HttpContent)null;
}
valueTaskAwaitable = MultipartContent.EncodeStringToStreamAsync(stream, "\r\n--" + multipartContent._boundary + "--\r\n", cancellationToken).ConfigureAwait(false);
await valueTaskAwaitable;
output = (StringBuilder)null;
}
catch (Exception ex)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Error((object)multipartContent, (object)ex, nameof(SerializeToStreamAsyncCore));
}
throw;
}
}
private void Release()
{
_Operation = null;
_Collection = null;
_Awaiter = default;
Waiters.Add(this);
}
public static ConfiguredValueTaskAwaitable EnsureCompleted(this ConfiguredValueTaskAwaitable awaitable, bool async)
{
if (!async)
{
#if DEBUG
VerifyTaskCompleted(awaitable.GetAwaiter().IsCompleted);
#endif
}
return(awaitable);
}
public void ConfigureAwait_AwaitMoveNextAsync_FlagsSetAppropriately(bool continueOnCapturedContext)
{
var enumerable = new TrackFlagsAsyncEnumerable()
{
Flags = 0
};
ConfiguredAsyncEnumerable <int> .Enumerator enumerator = enumerable.ConfigureAwait(continueOnCapturedContext).GetAsyncEnumerator();
ConfiguredValueTaskAwaitable <bool> .ConfiguredValueTaskAwaiter moveNextAwaiter = enumerator.MoveNextAsync().GetAwaiter();
moveNextAwaiter.UnsafeOnCompleted(() => { });
Assert.Equal(
continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None,
enumerable.Flags);
}
//****************************************
public void Attach(AsyncCounterDecrement decrement)
{
var Task = new ValueTask <bool>(decrement, decrement.Version);
_Awaiter = Task.ConfigureAwait(false).GetAwaiter();
if (_Awaiter.IsCompleted)
{
OnContinuePeekDecrement();
}
else
{
_Awaiter.OnCompleted(_ContinuePeekDecrement);
}
}
public WithCancellationValueTaskAwaiter(ConfiguredValueTaskAwaitable <T> .ConfiguredValueTaskAwaiter awaiter, CancellationToken cancellationToken)
{
_taskAwaiter = awaiter;
_cancellationToken = cancellationToken;
}
public WithCancellationValueTaskAwaitable(ValueTask <T> task, CancellationToken cancellationToken)
{
_awaitable = task.ConfigureAwait(false);
_cancellationToken = cancellationToken;
}
private static bool GetContinueOnCapturedContext(ConfiguredValueTaskAwaitable task) => GetValueTaskContinueOnCapturedContext(task);
/// <summary> /// 结束对已完成任务的等待，并返回执行结果。 /// </summary> /// <typeparam name="TResult">指定的结果类型。</typeparam> /// <param name="awaitable">给定的 <see cref="ConfiguredValueTaskAwaitable" />。</param> /// <returns>返回 <typeparamref name="TResult"/>。</returns> public static TResult AwaitResult <TResult>(this ConfiguredValueTaskAwaitable <TResult> awaitable) => awaitable.GetAwaiter().GetResult();
=> task.ConfigureAwait(false); // .NET 默认调用 task.ConfigureAwait(true);
#endregion
#region ConfiguredValueTaskAwaitable
/// <summary>
/// 结束对已完成任务的等待。
/// </summary>
/// <param name="awaitable">给定的 <see cref="ConfiguredValueTaskAwaitable" />。</param>
public static void Await(this ConfiguredValueTaskAwaitable awaitable)
=> awaitable.GetAwaiter().GetResult();
public ConfiguredValueTaskAwaiterWrapper(ConfiguredValueTaskAwaitable <TResult> .ConfiguredValueTaskAwaiter cfgAwaiter)
{
_cfgAwaiter = cfgAwaiter;
}
public ConfiguredValueTaskAwaitableWrapper(ConfiguredValueTaskAwaitable <TResult> cfgAwaitable)
{
_cfgAwaitable = cfgAwaitable;
}
public ConfiguredValueTaskAwaitableWrapper(ConfiguredValueTaskAwaitable <TResult> awaitable)
{
_awaitable = awaitable;
}
public static ConfiguredValueTaskAwaitable EnsureCompleted(this ConfiguredValueTaskAwaitable task, bool async)
{
Debug.Assert(async || task.GetAwaiter().IsCompleted);
return(task);
}
public ConfiguredValueTaskAwaiterWrapper(ConfiguredValueTaskAwaitable <TResult> .ConfiguredValueTaskAwaiter awaiter)
{
_awaiter = awaiter;
}
public void MoveNext()
{
try
{
bool waitToReadResult = false;
switch ((State)_state)
{
case State.OuterLoop:
ValueTask <bool> waitToReadTask = _reader.WaitToReadAsync(_cancellationToken);
if (waitToReadTask.IsCompleted)
{
// WaitToReadAsync completed. Get the result and jump to process it.
waitToReadResult = waitToReadTask.GetAwaiter().GetResult();
_state = (int)State.HaveWaitToReadResult;
goto case State.HaveWaitToReadResult;
}
// WaitToReadAsync wasn't yet complete. Mark that the promise
// is being used for the result, set where we should return to when it completes,
// store the awaiter, and hook up the continuation.
_usePromiseForResult = true;
_state = (int)State.FinishingAwait;
_waitToReadAwaiter = waitToReadTask.ConfigureAwait(false).GetAwaiter();
AsyncEnumerable inst = this;
_builder.AwaitUnsafeOnCompleted(ref _waitToReadAwaiter, ref inst);
return;
case State.FinishingAwait:
// The await on WaitToReadAsync finished. Get its result and process it.
waitToReadResult = _waitToReadAwaiter.GetResult();
_state = (int)State.HaveWaitToReadResult;
goto case State.HaveWaitToReadResult;
case State.HaveWaitToReadResult:
// We have a result from WaitToReadAsync. If an item might be available,
// jump to try to read it. If an item will never be available, complete.
if (waitToReadResult)
{
_state = (int)State.TryRead;
goto case State.TryRead;
}
else
{
_state = (int)State.Completing;
goto case State.Completing;
}
case State.TryRead:
// Do the read. If we successfully get an item, mark that an item is
// available. Then if we've already awaited as part of this MoveNextAsync,
// also complete the promise.
if (_reader.TryRead(out _current))
{
_itemAvailable = true;
if (_usePromiseForResult)
{
_promise.SetResult(true);
}
return;
}
else
{
// No item was available. Start over.
_state = (int)State.OuterLoop;
goto case State.OuterLoop;
}
case State.Completing:
// Cleanup. And if there's an outstanding promise, complete it
// to indicate iteration is done.
_builder.Complete();
_state = (int)State.Done;
if (_usePromiseForResult)
{
_promise.SetResult(false);
}
return;
}
}
catch (Exception e)
{
_state = (int)State.Done;
_builder.Complete();
_itemAvailable = false;
_usePromiseForResult = true;
_promise.SetException(e);
}
}
