SemaphoreSlim throttling

First the "new" keyword. If casting this class back down to SemaphoreSlim then none of the code that has the new keyword would be used and just the base SemaphoreSlim code would execute.

Since we want the new code to execute I would suggest not inheriting from SemaphoreSlim but rather wrap it and then chain the calls down into the wrapped SemaphoreSlim. Something like, I didn't put in all the method this just an example of the approach.

public class SemaphoreSlimThrottle : IDisposable
{
    private volatile int _throttleCount;
    private readonly SemaphoreSlim _semaphore;
    private readonly object _lock = new object();
    private bool _turnOffThrottleCheck = false;

    public SemaphoreSlimThrottle(int initialCount, int maxCount)
    {
        if (initialCount < 0)
        {
            _semaphore = new SemaphoreSlim(0, maxCount);
            _turnOffThrottleCheck = true;
        }
        else
        {
            _semaphore = new SemaphoreSlim(initialCount, maxCount);
            _turnOffThrottleCheck = true;
        }
    }

    public WaitHandle AvailableWaitHandle => _semaphore.AvailableWaitHandle;

    public int CurrentCount => _throttleCount + _semaphore.CurrentCount;

    public bool Wait(TimeSpan timeout, CancellationToken cancellationToken) => _semaphore.Wait(timeout, cancellationToken);

    public int Release() => Release(1);

    public void Dispose()
    {
        _semaphore.Dispose();
    }
}

The other optimization that can be preformed is to not have the volatile field accessed once the "extra" have been used up. Also calling into the base outside the lock to have the locks short as possible.

Warning I did not test this code there could be typo or bugs in it - use as a gist

    public int Release(int releaseCount)
    {
        // using bool property to avoid unnecessary volatile accesses in happy path
        if (releaseCount < 1 || _turnOffThrottleCheck)
        {
            return _semaphore.Release(releaseCount);
        }

        int remainingCount;
        var returnCount = 0;
        lock (_lock)
        {
            var throttleCount = _throttleCount;
            if (throttleCount == 0) // Different thread release all them just call into base
            {
                remainingCount = releaseCount;
            }
            else if (releaseCount + throttleCount < 0) // Releasing less than throttle just decrease
            {
                _throttleCount += releaseCount;
                remainingCount = 0;
                returnCount = throttleCount;
            }
            else // releasing all the throttles
            {
                _throttleCount = 0;
                _turnOffThrottleCheck = true;
                returnCount = throttleCount;
                remainingCount = releaseCount + throttleCount;
            }
        }

        // doing outside lock
        if (remainingCount > 0) // call into base if more locks to be released
        {
            return _semaphore.Release(releaseCount) + returnCount;
        }

        return returnCount + _semaphore.CurrentCount;

    }

This way we don't access _throttleCount in the happy path. We also release the lock and just call into the SemaphoreSlim outside the lock.