public void Dispose()
        {
            if (_signal == null)
            {
                return;
            }

            BCLDebug.Assert(Thread.CurrentThread == _signal.Thread, "You called Dispose on the wrong thread, or reused your cancellation signal?");
            List <CancellationSignal> signals = _signal.Thread.CancellationSignals;

            bool tookLock = false;

            RuntimeHelpers.PrepareConstrainedRegions();
            try {
                Monitor.ReliableEnter(signals, out tookLock);
                CancellationSignal s = signals[signals.Count - 1];
                signals.RemoveAt(signals.Count - 1);
                if (!Object.ReferenceEquals(s, _signal))
                {
                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CancellationRegionLeak"));
                }
                _signal.Thread = null;
                _signal        = null;
            }
            finally {
                if (tookLock)
                {
                    Monitor.Exit(signals);
                }
                Thread.EndThreadAffinity();
            }
        }
        public void Dispose()
        {
            if (_signal == null)
                return;

            BCLDebug.Assert(Thread.CurrentThread == _signal.Thread, "You called Dispose on the wrong thread, or reused your cancellation signal?");
            List<CancellationSignal> signals = _signal.Thread.CancellationSignals;

            bool tookLock = false;
            RuntimeHelpers.PrepareConstrainedRegions();
            try {
                Monitor.ReliableEnter(signals, out tookLock);
                CancellationSignal s = signals[signals.Count - 1];
                signals.RemoveAt(signals.Count - 1);
                if (!Object.ReferenceEquals(s, _signal))
                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CancellationRegionLeak"));
                _signal.Thread = null;
                _signal = null;
            }
            finally {
                if (tookLock)
                    Monitor.Exit(signals);
                Thread.EndThreadAffinity();
            }
        }
 public override async Task<FingerprintAuthenticationResult> AuthenticateNoDialogAsync(IAuthenticationFailedListener failedListener, CancellationToken cancellationToken)
 {
     using (var cancellationSignal = new CancellationSignal())
     using (cancellationToken.Register(() => cancellationSignal.Cancel()))
     {
         var callback = new FingerprintAuthenticationCallback(failedListener);
         GetService().Authenticate(null, cancellationSignal, FingerprintAuthenticationFlags.None, callback, null);
         return await callback.GetTask();
     }
 }
        public static CancellationRegion SetNonCancelable()
        {
            CancellationSignal signal = new CancellationSignal(false);
            Thread t = Thread.CurrentThread;
            signal.Thread = t;
            List<CancellationSignal> signals = t.CancellationSignals;
            CancellationRegion region = new CancellationRegion(signal);

            lock(signals) {
                signals.Add(signal);
                // Note that all failures due to allocations will be above 
                // this point in this method.  Also, note that it's fine to 
                // Add first then get thread affinity later - the Cancel
                // method holds this same lock while cancelling.
                // Ensure that another fiber cannot run on this thread.
                Thread.BeginThreadAffinity();
            }
            return region;
        }
        public static CancellationRegion SetNonCancelable()
        {
            CancellationSignal signal = new CancellationSignal(false);
            Thread             t      = Thread.CurrentThread;

            signal.Thread = t;
            List <CancellationSignal> signals = t.CancellationSignals;
            CancellationRegion        region  = new CancellationRegion(signal);

            lock (signals) {
                signals.Add(signal);
                // Note that all failures due to allocations will be above
                // this point in this method.  Also, note that it's fine to
                // Add first then get thread affinity later - the Cancel
                // method holds this same lock while cancelling.
                // Ensure that another fiber cannot run on this thread.
                Thread.BeginThreadAffinity();
            }
            return(region);
        }
        private CancellationRegion(CancellationSignal signal)
        {
            BCLDebug.Assert(signal != null, "Must have a cancelation signal instance.");

            _signal = signal;
        }
        private CancellationRegion(CancellationSignal signal)
        {
            BCLDebug.Assert(signal != null, "Must have a cancelation signal instance.");

            _signal = signal;
        }