AsyncBulkheadPolicy<TResult>
                    public class AsyncBulkheadPolicy<TResult> : AsyncPolicy<TResult>, IBulkheadPolicy<TResult>, IBulkheadPolicy, IsPolicy, IDisposable
                
                A bulkhead-isolation policy which can be applied to delegates.
            
                using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace Polly.Bulkhead
{
    [System.Runtime.CompilerServices.NullableContext(1)]
    [System.Runtime.CompilerServices.Nullable(new byte[] {
        0,
        1
    })]
    public class AsyncBulkheadPolicy<[System.Runtime.CompilerServices.Nullable(2)] TResult> : AsyncPolicy<TResult>, IBulkheadPolicy<TResult>, IBulkheadPolicy, IsPolicy, IDisposable
    {
        private readonly SemaphoreSlim _maxParallelizationSemaphore;
        private readonly SemaphoreSlim _maxQueuedActionsSemaphore;
        private readonly int _maxQueueingActions;
        private readonly Func<Context, Task> _onBulkheadRejectedAsync;
        public int BulkheadAvailableCount => _maxParallelizationSemaphore.CurrentCount;
        public int QueueAvailableCount => Math.Min(_maxQueuedActionsSemaphore.CurrentCount, _maxQueueingActions);
        internal AsyncBulkheadPolicy(int maxParallelization, int maxQueueingActions, Func<Context, Task> onBulkheadRejectedAsync)
            : base((PolicyBuilder<TResult>)null)
        {
            _maxQueueingActions = maxQueueingActions;
            _onBulkheadRejectedAsync = onBulkheadRejectedAsync;
            (SemaphoreSlim, SemaphoreSlim) valueTuple = BulkheadSemaphoreFactory.CreateBulkheadSemaphores(maxParallelization, maxQueueingActions);
            _maxParallelizationSemaphore = valueTuple.Item1;
            _maxQueuedActionsSemaphore = valueTuple.Item2;
        }
        [DebuggerStepThrough]
        protected override Task<TResult> ImplementationAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext)
        {
            if (action == null)
                throw new ArgumentNullException("action");
            return AsyncBulkheadEngine.ImplementationAsync<TResult>(action, context, _onBulkheadRejectedAsync, _maxParallelizationSemaphore, _maxQueuedActionsSemaphore, continueOnCapturedContext, cancellationToken);
        }
        public void Dispose()
        {
            _maxParallelizationSemaphore.Dispose();
            _maxQueuedActionsSemaphore.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}