protected void UnregisterCancellation()
        {
            _TokenSource?.Dispose();
            _TokenSource = null;
            _Token       = default;

#if NETSTANDARD2_0
            // This may block if SwitchToCancelled is running
            _Registration.Dispose();

            OnCompletedCleanup();
#else
            // This will not block if SwitchToCancelled is running, but may continue later
            _Awaiter = _Registration.DisposeAsync().ConfigureAwait(false).GetAwaiter();

            if (_Awaiter.IsCompleted)
            {
                OnCompletedCleanup();
            }
            else
            {
                _Awaiter.OnCompleted(_CompletedCleanup);
            }
#endif
        }
Exemple #2
0
            private void Release()
            {
                _Operation = null;
                _Decrement = null;
                _Awaiter   = default;

                Waiters.Add(this);
            }
        //****************************************

        private void OnCompletedCleanup()
        {
#if !NETSTANDARD2_0
            _Awaiter.GetResult();

            _Awaiter = default;
#endif

            UnregisteredCancellation();
        }
        public ValueTaskAwaitable(ValueTask task, bool continueOnCapturedContext, IAsyncScheduler scheduler, CancellationToken token)
        {
            if (task == null)
            {
                throw new ArgumentNullException(nameof(task));
            }

            _task      = task.ConfigureAwait(continueOnCapturedContext).GetAwaiter();
            _scheduler = scheduler;
            _token     = token;
        }
        public void ConfigureAwait_AwaitDisposeAsync_FlagsSetAppropriately(bool continueOnCapturedContext)
        {
            var enumerable = new TrackFlagsAsyncEnumerable()
            {
                Flags = 0
            };

            ConfiguredAsyncEnumerable <int> .Enumerator             enumerator     = enumerable.ConfigureAwait(continueOnCapturedContext).GetAsyncEnumerator();
            ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter disposeAwaiter = enumerator.DisposeAsync().GetAwaiter();
            disposeAwaiter.UnsafeOnCompleted(() => { });
            Assert.Equal(
                continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None,
                enumerable.Flags);
        }
Exemple #6
0
            //****************************************

            public void Attach(AsyncCounterDecrement decrement)
            {
                _Decrement = decrement;

                var Task = new ValueTask(decrement, decrement.Version);

                _Awaiter = Task.ConfigureAwait(false).GetAwaiter();

                if (_Awaiter.IsCompleted)
                {
                    OnContinuePeekDecrement();
                }
                else
                {
                    _Awaiter.OnCompleted(_ContinuePeekDecrement);
                }
            }
 public ValueTaskAwaiter(ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter awaiter, IAsyncScheduler scheduler, CancellationToken token)
 {
     _awaiter   = awaiter;
     _scheduler = scheduler;
     _token     = token;
 }