--- /dev/null
+<Project>
+ <Import Project="..\Directory.Build.props" />
+ <PropertyGroup>
+ <StrongNameKeyId>Open</StrongNameKeyId>
+ <!-- This assembly should never be placed inbox as it is only for downlevel compatibility. -->
+ </PropertyGroup>
+</Project>
--- /dev/null
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30120.7
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.AsyncInterfaces", "src\Microsoft.Bcl.AsyncInterfaces.csproj", "{E6C08D1F-5DAC-470E-809D-42DBFAA56DD4}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{8FA3CF3F-DF33-4DC4-A261-4642AB786838}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{0C330C14-95F7-4AD3-9BD0-8AAB6E3013D8}"
+ ProjectSection(SolutionItems) = preProject
+ ref\Microsoft.Bcl.AsyncInterfaces.csproj = ref\Microsoft.Bcl.AsyncInterfaces.csproj
+ EndProjectSection
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.AsyncInterfaces.Tests", "tests\Microsoft.Bcl.AsyncInterfaces.Tests.csproj", "{857B2747-4D8E-4A0C-9C38-521F690ED28E}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{78938ED3-0E8A-451A-A508-0E724E471B91}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{95680D66-EE1B-4389-A84D-0C49AF570732}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {E6C08D1F-5DAC-470E-809D-42DBFAA56DD4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {E6C08D1F-5DAC-470E-809D-42DBFAA56DD4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {E6C08D1F-5DAC-470E-809D-42DBFAA56DD4}.Release|Any CPU.ActiveCfg = Debug|Any CPU
+ {E6C08D1F-5DAC-470E-809D-42DBFAA56DD4}.Release|Any CPU.Build.0 = Debug|Any CPU
+ {857B2747-4D8E-4A0C-9C38-521F690ED28E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {857B2747-4D8E-4A0C-9C38-521F690ED28E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {857B2747-4D8E-4A0C-9C38-521F690ED28E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {857B2747-4D8E-4A0C-9C38-521F690ED28E}.Release|Any CPU.Build.0 = Release|Any CPU
+ {95680D66-EE1B-4389-A84D-0C49AF570732}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {95680D66-EE1B-4389-A84D-0C49AF570732}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {95680D66-EE1B-4389-A84D-0C49AF570732}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {95680D66-EE1B-4389-A84D-0C49AF570732}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+ GlobalSection(NestedProjects) = preSolution
+ {E6C08D1F-5DAC-470E-809D-42DBFAA56DD4} = {8FA3CF3F-DF33-4DC4-A261-4642AB786838}
+ {857B2747-4D8E-4A0C-9C38-521F690ED28E} = {78938ED3-0E8A-451A-A508-0E724E471B91}
+ {95680D66-EE1B-4389-A84D-0C49AF570732} = {78938ED3-0E8A-451A-A508-0E724E471B91}
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {48FA418B-CCC2-4EBD-9CDA-F31C72AC9B05}
+ EndGlobalSection
+EndGlobal
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), Directory.Build.props))\Directory.Build.props" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Bcl.AsyncInterfaces.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), Directory.Build.targets))\Directory.Build.targets" />
+</Project>
\ No newline at end of file
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IAsyncDisposable))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Collections.Generic.IAsyncEnumerable<>))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Collections.Generic.IAsyncEnumerator<>))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.AsyncIteratorMethodBuilder))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.ConfiguredAsyncDisposable))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable<>))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.EnumeratorCancellationAttribute))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.Tasks.TaskAsyncEnumerableExtensions))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<>))]
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
+
+namespace System
+{
+ public partial interface IAsyncDisposable
+ {
+ System.Threading.Tasks.ValueTask DisposeAsync();
+ }
+}
+namespace System.Collections.Generic
+{
+ public partial interface IAsyncEnumerable<out T>
+ {
+ System.Collections.Generic.IAsyncEnumerator<T> GetAsyncEnumerator(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
+ }
+ public partial interface IAsyncEnumerator<out T> : System.IAsyncDisposable
+ {
+ T Current { get; }
+ System.Threading.Tasks.ValueTask<bool> MoveNextAsync();
+ }
+}
+namespace System.Runtime.CompilerServices
+{
+ public partial struct AsyncIteratorMethodBuilder
+ {
+ private object _dummy;
+ private int _dummyPrimitive;
+ public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.INotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { }
+ public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { }
+ public void Complete() { }
+ public static System.Runtime.CompilerServices.AsyncIteratorMethodBuilder Create() { throw null; }
+ public void MoveNext<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { }
+ }
+ [System.AttributeUsageAttribute(System.AttributeTargets.Method, Inherited=false, AllowMultiple=false)]
+ public sealed partial class AsyncIteratorStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute
+ {
+ public AsyncIteratorStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { }
+ }
+ public readonly partial struct ConfiguredAsyncDisposable
+ {
+ private readonly object _dummy;
+ private readonly int _dummyPrimitive;
+ public System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable DisposeAsync() { throw null; }
+ }
+ public readonly partial struct ConfiguredCancelableAsyncEnumerable<T>
+ {
+ private readonly object _dummy;
+ private readonly int _dummyPrimitive;
+ public System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait(bool continueOnCapturedContext) { throw null; }
+ public System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable<T>.Enumerator GetAsyncEnumerator() { throw null; }
+ public System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable<T> WithCancellation(System.Threading.CancellationToken cancellationToken) { throw null; }
+ public readonly partial struct Enumerator
+ {
+ private readonly object _dummy;
+ private readonly int _dummyPrimitive;
+ public T Current { get { throw null; } }
+ public System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable DisposeAsync() { throw null; }
+ public System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable<bool> MoveNextAsync() { throw null; }
+ }
+ }
+ [System.AttributeUsageAttribute(System.AttributeTargets.Parameter, Inherited=false)]
+ public sealed partial class EnumeratorCancellationAttribute : System.Attribute
+ {
+ public EnumeratorCancellationAttribute() { }
+ }
+}
+namespace System.Threading.Tasks
+{
+ public static partial class TaskAsyncEnumerableExtensions
+ {
+ public static System.Runtime.CompilerServices.ConfiguredAsyncDisposable ConfigureAwait(this System.IAsyncDisposable source, bool continueOnCapturedContext) { throw null; }
+ public static System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait<T>(this System.Collections.Generic.IAsyncEnumerable<T> source, bool continueOnCapturedContext) { throw null; }
+ public static System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable<T> WithCancellation<T>(this System.Collections.Generic.IAsyncEnumerable<T> source, System.Threading.CancellationToken cancellationToken) { throw null; }
+ }
+}
+namespace System.Threading.Tasks.Sources
+{
+ public partial struct ManualResetValueTaskSourceCore<TResult>
+ {
+ private TResult _result;
+ private object _dummy;
+ private int _dummyPrimitive;
+ public bool RunContinuationsAsynchronously { readonly get { throw null; } set { } }
+ public short Version { get { throw null; } }
+ public TResult GetResult(short token) { throw null; }
+ public System.Threading.Tasks.Sources.ValueTaskSourceStatus GetStatus(short token) { throw null; }
+ public void OnCompleted(System.Action<object> continuation, object state, short token, System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags flags) { }
+ public void Reset() { }
+ public void SetException(System.Exception error) { }
+ public void SetResult(TResult result) { }
+ }
+}
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <TargetFrameworks>net461;netstandard2.0;netstandard2.1</TargetFrameworks>
+ </PropertyGroup>
+ <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.1'">
+ <Compile Include="Microsoft.Bcl.AsyncInterfaces.cs" />
+ </ItemGroup>
+ <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.1'">
+ <Compile Include="Microsoft.Bcl.AsyncInterfaces.Forwards.cs" />
+ </ItemGroup>
+ <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.1'">
+ <PackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
+ </ItemGroup>
+</Project>
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <TargetFrameworks>net461;netstandard2.0;netstandard2.1</TargetFrameworks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <IsPartialFacadeAssembly Condition="'$(TargetFramework)' == 'netstandard2.1'">true</IsPartialFacadeAssembly>
+ </PropertyGroup>
+ <ItemGroup Condition="'$(IsPartialFacadeAssembly)' != 'true'">
+ <Compile Include="System\Threading\Tasks\Sources\ManualResetValueTaskSourceCore.cs" />
+ <Compile Include="System\Runtime\CompilerServices\AsyncIteratorMethodBuilder.cs" />
+ <Compile Include="$(CoreLibSharedDir)\System\Collections\Generic\IAsyncEnumerable.cs">
+ <Link>System.Private.CoreLib\System\Collections\Generic\IAsyncEnumerable.cs</Link>
+ </Compile>
+ <Compile Include="$(CoreLibSharedDir)\System\Collections\Generic\IAsyncEnumerator.cs">
+ <Link>System.Private.CoreLib\System\Collections\Generic\IAsyncEnumerator.cs</Link>
+ </Compile>
+ <Compile Include="$(CoreLibSharedDir)\System\IAsyncDisposable.cs">
+ <Link>System.Private.CoreLib\System\IAsyncDisposable.cs</Link>
+ </Compile>
+ <Compile Include="$(CoreLibSharedDir)\System\Runtime\CompilerServices\AsyncIteratorStateMachineAttribute.cs">
+ <Link>System.Private.CoreLib\System\Runtime\CompilerServices\AsyncIteratorStateMachineAttribute.cs</Link>
+ </Compile>
+ <Compile Include="$(CoreLibSharedDir)\System\Runtime\CompilerServices\ConfiguredAsyncDisposable.cs">
+ <Link>System.Private.CoreLib\System\Runtime\CompilerServices\ConfiguredAsyncDisposable.cs</Link>
+ </Compile>
+ <Compile Include="$(CoreLibSharedDir)\System\Runtime\CompilerServices\ConfiguredCancelableAsyncEnumerable.cs">
+ <Link>System.Private.CoreLib\System\Runtime\CompilerServices\ConfiguredCancelableAsyncEnumerable.cs</Link>
+ </Compile>
+ <Compile Include="$(CoreLibSharedDir)\System\Threading\Tasks\TaskAsyncEnumerableExtensions.cs">
+ <Link>System.Private.CoreLib\System\Threading\Tasks\TaskAsyncEnumerableExtensions.cs</Link>
+ </Compile>
+ <Compile Include="$(CoreLibSharedDir)\System\Runtime\CompilerServices\EnumeratorCancellationAttribute.cs">
+ <Link>System.Private.CoreLib\System\Runtime\CompilerServices\EnumeratorCancellationAttribute.cs</Link>
+ </Compile>
+ </ItemGroup>
+ <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.1'">
+ <PackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
+ </ItemGroup>
+</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// NOTE: This is a copy of
+// https://github.com/dotnet/coreclr/blame/07b3afc27304800f00975c8fd4836b319aaa8820/src/System.Private.CoreLib/shared/System/Runtime/CompilerServices/AsyncIteratorMethodBuilder.cs
+// modified to be compilable against .NET Standard 2.0. Key differences:
+// - Uses the wrapped AsyncTaskMethodBuilder for Create and MoveNext.
+// - Uses a custom object for the debugger identity.
+// - Nullable annotations removed.
+
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace System.Runtime.CompilerServices
+{
+ /// <summary>Represents a builder for asynchronous iterators.</summary>
+ [StructLayout(LayoutKind.Auto)]
+ public struct AsyncIteratorMethodBuilder
+ {
+ private AsyncTaskMethodBuilder _methodBuilder; // mutable struct; do not make it readonly
+ private object _id;
+
+ /// <summary>Creates an instance of the <see cref="AsyncIteratorMethodBuilder"/> struct.</summary>
+ /// <returns>The initialized instance.</returns>
+ public static AsyncIteratorMethodBuilder Create() =>
+ new AsyncIteratorMethodBuilder() { _methodBuilder = AsyncTaskMethodBuilder.Create() };
+
+ /// <summary>Invokes <see cref="IAsyncStateMachine.MoveNext"/> on the state machine while guarding the <see cref="ExecutionContext"/>.</summary>
+ /// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+ /// <param name="stateMachine">The state machine instance, passed by reference.</param>
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void MoveNext<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine =>
+ _methodBuilder.Start(ref stateMachine);
+
+ /// <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes.</summary>
+ /// <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+ /// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+ /// <param name="awaiter">The awaiter.</param>
+ /// <param name="stateMachine">The state machine.</param>
+ public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+ where TAwaiter : INotifyCompletion
+ where TStateMachine : IAsyncStateMachine =>
+ _methodBuilder.AwaitOnCompleted(ref awaiter, ref stateMachine);
+
+ /// <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes.</summary>
+ /// <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+ /// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+ /// <param name="awaiter">The awaiter.</param>
+ /// <param name="stateMachine">The state machine.</param>
+ public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+ where TAwaiter : ICriticalNotifyCompletion
+ where TStateMachine : IAsyncStateMachine =>
+ _methodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
+
+ /// <summary>Marks iteration as being completed, whether successfully or otherwise.</summary>
+ public void Complete() => _methodBuilder.SetResult();
+
+ /// <summary>Gets an object that may be used to uniquely identify this builder to the debugger.</summary>
+ internal object ObjectIdForDebugger => _id ?? Interlocked.CompareExchange(ref _id, new object(), null) ?? _id;
+ }
+}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// NOTE: This is a copy of
+// https://github.com/dotnet/coreclr/blame/07b3afc27304800f00975c8fd4836b319aaa8820/src/System.Private.CoreLib/shared/System/Threading/Tasks/Sources/ManualResetValueTaskSourceCore.cs,
+// modified to be compilable against .NET Standard 2.0. It is missing optimizations present in the .NET Core implementation and should
+// only be used when a .NET Standard 2.0 implementation is required. Key differences:
+// - ThrowHelper call sites are replaced by normal exception throws.
+// - ThreadPool.{Unsafe}QueueUserWorkItem calls that accepted Action<object>/object/bool arguments are replaced by Task.Factory.StartNew usage.
+// - ExecutionContext.RunInternal are replaced by ExecutionContext.Run.
+// - Nullability annotations are removed.
+
+using System.Diagnostics;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
+
+namespace System.Threading.Tasks.Sources
+{
+ /// <summary>Provides the core logic for implementing a manual-reset <see cref="IValueTaskSource"/> or <see cref="IValueTaskSource{TResult}"/>.</summary>
+ /// <typeparam name="TResult"></typeparam>
+ [StructLayout(LayoutKind.Auto)]
+ public struct ManualResetValueTaskSourceCore<TResult>
+ {
+ /// <summary>
+ /// The callback to invoke when the operation completes if <see cref="OnCompleted"/> was called before the operation completed,
+ /// or <see cref="ManualResetValueTaskSourceCoreShared.s_sentinel"/> if the operation completed before a callback was supplied,
+ /// or null if a callback hasn't yet been provided and the operation hasn't yet completed.
+ /// </summary>
+ private Action<object> _continuation;
+ /// <summary>State to pass to <see cref="_continuation"/>.</summary>
+ private object _continuationState;
+ /// <summary><see cref="ExecutionContext"/> to flow to the callback, or null if no flowing is required.</summary>
+ private ExecutionContext _executionContext;
+ /// <summary>
+ /// A "captured" <see cref="SynchronizationContext"/> or <see cref="TaskScheduler"/> with which to invoke the callback,
+ /// or null if no special context is required.
+ /// </summary>
+ private object _capturedContext;
+ /// <summary>Whether the current operation has completed.</summary>
+ private bool _completed;
+ /// <summary>The result with which the operation succeeded, or the default value if it hasn't yet completed or failed.</summary>
+ private TResult _result;
+ /// <summary>The exception with which the operation failed, or null if it hasn't yet completed or completed successfully.</summary>
+ private ExceptionDispatchInfo _error;
+ /// <summary>The current version of this value, used to help prevent misuse.</summary>
+ private short _version;
+
+ /// <summary>Gets or sets whether to force continuations to run asynchronously.</summary>
+ /// <remarks>Continuations may run asynchronously if this is false, but they'll never run synchronously if this is true.</remarks>
+ public bool RunContinuationsAsynchronously { get; set; }
+
+ /// <summary>Resets to prepare for the next operation.</summary>
+ public void Reset()
+ {
+ // Reset/update state for the next use/await of this instance.
+ _version++;
+ _completed = false;
+ _result = default!;
+ _error = null;
+ _executionContext = null;
+ _capturedContext = null;
+ _continuation = null;
+ _continuationState = null;
+ }
+
+ /// <summary>Completes with a successful result.</summary>
+ /// <param name="result">The result.</param>
+ public void SetResult(TResult result)
+ {
+ _result = result;
+ SignalCompletion();
+ }
+
+ /// <summary>Complets with an error.</summary>
+ /// <param name="error"></param>
+ public void SetException(Exception error)
+ {
+ _error = ExceptionDispatchInfo.Capture(error);
+ SignalCompletion();
+ }
+
+ /// <summary>Gets the operation version.</summary>
+ public short Version => _version;
+
+ /// <summary>Gets the status of the operation.</summary>
+ /// <param name="token">Opaque value that was provided to the <see cref="ValueTask"/>'s constructor.</param>
+ public ValueTaskSourceStatus GetStatus(short token)
+ {
+ ValidateToken(token);
+ return
+ _continuation == null || !_completed ? ValueTaskSourceStatus.Pending :
+ _error == null ? ValueTaskSourceStatus.Succeeded :
+ _error.SourceException is OperationCanceledException ? ValueTaskSourceStatus.Canceled :
+ ValueTaskSourceStatus.Faulted;
+ }
+
+ /// <summary>Gets the result of the operation.</summary>
+ /// <param name="token">Opaque value that was provided to the <see cref="ValueTask"/>'s constructor.</param>
+ public TResult GetResult(short token)
+ {
+ ValidateToken(token);
+ if (!_completed)
+ {
+ throw new InvalidOperationException();
+ }
+
+ _error?.Throw();
+ return _result;
+ }
+
+ /// <summary>Schedules the continuation action for this operation.</summary>
+ /// <param name="continuation">The continuation to invoke when the operation has completed.</param>
+ /// <param name="state">The state object to pass to <paramref name="continuation"/> when it's invoked.</param>
+ /// <param name="token">Opaque value that was provided to the <see cref="ValueTask"/>'s constructor.</param>
+ /// <param name="flags">The flags describing the behavior of the continuation.</param>
+ public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
+ {
+ if (continuation == null)
+ {
+ throw new ArgumentNullException(nameof(continuation));
+ }
+ ValidateToken(token);
+
+ if ((flags & ValueTaskSourceOnCompletedFlags.FlowExecutionContext) != 0)
+ {
+ _executionContext = ExecutionContext.Capture();
+ }
+
+ if ((flags & ValueTaskSourceOnCompletedFlags.UseSchedulingContext) != 0)
+ {
+ SynchronizationContext sc = SynchronizationContext.Current;
+ if (sc != null && sc.GetType() != typeof(SynchronizationContext))
+ {
+ _capturedContext = sc;
+ }
+ else
+ {
+ TaskScheduler ts = TaskScheduler.Current;
+ if (ts != TaskScheduler.Default)
+ {
+ _capturedContext = ts;
+ }
+ }
+ }
+
+ // We need to set the continuation state before we swap in the delegate, so that
+ // if there's a race between this and SetResult/Exception and SetResult/Exception
+ // sees the _continuation as non-null, it'll be able to invoke it with the state
+ // stored here. However, this also means that if this is used incorrectly (e.g.
+ // awaited twice concurrently), _continuationState might get erroneously overwritten.
+ // To minimize the chances of that, we check preemptively whether _continuation
+ // is already set to something other than the completion sentinel.
+
+ object oldContinuation = _continuation;
+ if (oldContinuation == null)
+ {
+ _continuationState = state;
+ oldContinuation = Interlocked.CompareExchange(ref _continuation, continuation, null);
+ }
+
+ if (oldContinuation != null)
+ {
+ // Operation already completed, so we need to queue the supplied callback.
+ if (!ReferenceEquals(oldContinuation, ManualResetValueTaskSourceCoreShared.s_sentinel))
+ {
+ throw new InvalidOperationException();
+ }
+
+ switch (_capturedContext)
+ {
+ case null:
+ Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
+ break;
+
+ case SynchronizationContext sc:
+ sc.Post(s =>
+ {
+ var tuple = (Tuple<Action<object>, object>)s;
+ tuple.Item1(tuple.Item2);
+ }, Tuple.Create(continuation, state));
+ break;
+
+ case TaskScheduler ts:
+ Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, ts);
+ break;
+ }
+ }
+ }
+
+ /// <summary>Ensures that the specified token matches the current version.</summary>
+ /// <param name="token">The token supplied by <see cref="ValueTask"/>.</param>
+ private void ValidateToken(short token)
+ {
+ if (token != _version)
+ {
+ throw new InvalidOperationException();
+ }
+ }
+
+ /// <summary>Signals that the operation has completed. Invoked after the result or error has been set.</summary>
+ private void SignalCompletion()
+ {
+ if (_completed)
+ {
+ throw new InvalidOperationException();
+ }
+ _completed = true;
+
+ if (_continuation != null || Interlocked.CompareExchange(ref _continuation, ManualResetValueTaskSourceCoreShared.s_sentinel, null) != null)
+ {
+ if (_executionContext != null)
+ {
+ ExecutionContext.Run(
+ _executionContext,
+ s => ((ManualResetValueTaskSourceCore<TResult>)s).InvokeContinuation(),
+ this);
+ }
+ else
+ {
+ InvokeContinuation();
+ }
+ }
+ }
+
+ /// <summary>
+ /// Invokes the continuation with the appropriate captured context / scheduler.
+ /// This assumes that if <see cref="_executionContext"/> is not null we're already
+ /// running within that <see cref="ExecutionContext"/>.
+ /// </summary>
+ private void InvokeContinuation()
+ {
+ Debug.Assert(_continuation != null);
+
+ switch (_capturedContext)
+ {
+ case null:
+ if (RunContinuationsAsynchronously)
+ {
+ Task.Factory.StartNew(_continuation, _continuationState, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
+ }
+ else
+ {
+ _continuation(_continuationState);
+ }
+ break;
+
+ case SynchronizationContext sc:
+ sc.Post(s =>
+ {
+ var state = (Tuple<Action<object>, object>)s;
+ state.Item1(state.Item2);
+ }, Tuple.Create(_continuation, _continuationState));
+ break;
+
+ case TaskScheduler ts:
+ Task.Factory.StartNew(_continuation, _continuationState, CancellationToken.None, TaskCreationOptions.DenyChildAttach, ts);
+ break;
+ }
+ }
+ }
+
+ internal static class ManualResetValueTaskSourceCoreShared // separated out of generic to avoid unnecessary duplication
+ {
+ internal static readonly Action<object> s_sentinel = CompletionSentinel;
+ private static void CompletionSentinel(object _) // named method to aid debugging
+ {
+ Debug.Fail("The sentinel delegate should never be invoked.");
+ throw new InvalidOperationException();
+ }
+ }
+}
--- /dev/null
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="..\..\Common\tests\System\Threading\Tasks\Sources\ManualResetValueTaskSource.cs">
+ <Link>Common\tests\System\Threading\Tasks\Sources\ManualResetValueTaskSource.cs</Link>
+ </Compile>
+ <Compile Include="..\..\System.Threading.Tasks\tests\System.Runtime.CompilerServices\ConfiguredCancelableAsyncEnumerableTests.cs">
+ <Link>System.Threading.Tasks\tests\System.Runtime.CompilerServices\ConfiguredCancelableAsyncEnumerableTests.cs</Link>
+ </Compile>
+ <Compile Include="..\..\System.Threading.Tasks\tests\System.Runtime.CompilerServices\ConfiguredAsyncDisposable.cs">
+ <Link>System.Threading.Tasks\tests\System.Runtime.CompilerServices\ConfiguredAsyncDisposable.cs</Link>
+ </Compile>
+ <Compile Condition="'$(TargetFramework)' != 'net461'" Include="..\..\System.Threading.Tasks.Extensions\tests\ManualResetValueTaskSourceTests.cs">
+ <Link>System.Threading.Tasks.Extensions\tests\ManualResetValueTaskSourceTests.cs</Link>
+ </Compile>
+ </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Bcl.AsyncInterfaces.csproj" />
+ </ItemGroup>
+</Project>
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.1'">
<PackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\ref\Microsoft.Bcl.AsyncInterfaces.csproj" />
</ItemGroup>
</Project>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or
$(TargetFramework.StartsWith('net4'))">
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj" />
<PackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
</ItemGroup>
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or
'$(TargetFramework)' == 'net461'">
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\ref\Microsoft.Bcl.AsyncInterfaces.csproj" />
</ItemGroup>
</Project>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or
$(TargetFramework.StartsWith('net4'))">
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj" />
<PackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or
$(TargetFramework.StartsWith('net4'))">
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj" />
<PackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' != '$(NetCoreAppCurrent)'">
<PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj" />
</ItemGroup>
<ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or
$(TargetFramework.StartsWith('net4'))">
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj" />
<PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
<ProjectReference Include="$(LibrariesProjectRoot)System.Text.Json\src\System.Text.Json.csproj" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or
$(TargetFramework.StartsWith('net4'))">
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'net461'">
'$(TargetFramework)' == 'net461'">
<PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
<PackageReference Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\ref\Microsoft.Bcl.AsyncInterfaces.csproj" />
</ItemGroup>
<!-- Since S.T.E.W continues to be built live within this repo (as both an in-box library and a standalone netstandard2.0 assembly),
we should use ProjectReference instead of Reference to make sure that its ref assembly gets built first before S.T.Json, regardless of the TFM. -->
<Reference Include="System.Threading.Tasks.Extensions" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or $(TargetFramework.StartsWith('net4'))">
- <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesVersion)" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj" />
<PackageReference Include="System.Buffers" Version="$(SystemBuffersVersion)" />
<PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
<PackageReference Include="System.Numerics.Vectors" Version="$(SystemNumericsVectorsVersion)" />
"StableVersions": [
"1.0.0"
],
- "BaselineVersion": "1.0.0",
+ "BaselineVersion": "5.0.0",
"InboxOn": {},
"AssemblyVersionInPackageVersion": {
- "1.0.0.0": "1.0.0"
+ "1.0.0.0": "1.0.0",
+ "5.0.0.0": "5.0.0"
}
},
"Microsoft.Bcl.HashCode": {
]
},
{
+ "Name": "Microsoft.Bcl.AsyncInterfaces",
+ "Description": "Provides the IAsyncEnumerable<T> and IAsyncDisposable interfaces and helper types for .NET Standard 2.0. This package is not required starting with .NET Standard 2.1 and .NET Core 3.0.",
+ "CommonTypes": [
+ "System.IAsyncDisposable",
+ "System.Collections.Generic.IAsyncEnumerable",
+ "System.Collections.Generic.IAsyncEnumerator"
+ ]
+ },
+ {
"Name": "System.Net.Http",
"Description": "Provides a programming interface for modern HTTP applications, including HTTP client components that allow applications to consume web services over HTTP and HTTP components that can be used by both clients and servers for parsing HTTP headers.",
"CommonTypes": [
projects / platform / upstream / dotnet / runtime.git / commitdiff