C#

public sealed class Throttle
{
    private readonly Queue<TaskCompletionSource<IDisposable>> _waiters = new Queue<TaskCompletionSource<IDisposable>>();
    private readonly WaitCallback _releaseCoreCallback;
    private readonly Task<IDisposable> _releaserTask;
    private readonly Releaser _releaser;
    private readonly int _maxCount;
    private int _currentCount;

    public Throttle(int initialCount)
    {
        if (initialCount <= 0) throw new ArgumentOutOfRangeException();

        _maxCount = _currentCount = initialCount;

        _releaser = new Releaser(this);
        _releaserTask = Task.FromResult((IDisposable)_releaser);
        _releaseCoreCallback = ReleaseCore;
    }

    public Task<IDisposable> WaitAsync()
    {
        lock (_waiters)
        {
            if (_currentCount > 0)
            {
                // We have a spare slot - let the caller continue immediately:
                _currentCount--;
                return _releaserTask;
            }
            
            // The caller needs to wait for a slot to be released:
            var waiter = new TaskCompletionSource<IDisposable>();
            _waiters.Enqueue(waiter);
            return waiter.Task;
        }
    }

    private void Release()
    {
        TaskCompletionSource<IDisposable> toRelease = null;
        lock (_waiters)
        {
            if (_waiters.Count > 0)
            {
                // Another thread is waiting - let it continue now:
                toRelease = _waiters.Dequeue();
            }
            else if (_currentCount < _maxCount)
            {
                // Release the slot back to the pool:
                _currentCount++;
            }
            else
            {
                // Someone called "Dispose" twice:
                throw new SemaphoreFullException();
            }
        }
        
        if (toRelease != null)
        {
            // Release the next waiter on a background thread
            // to avoid a possible StackOverflowException:
            ThreadPool.QueueUserWorkItem(_releaseCoreCallback, toRelease);
        }
    }

    private void ReleaseCore(object state)
    {
        ((TaskCompletionSource<IDisposable>)state).SetResult(_releaser);
    }

    private sealed class Releaser : IDisposable
    {
        private readonly Throttle _throttle;

        public Releaser(Throttle throttle)
        {
            _throttle = throttle;
        }

        public void Dispose()
        {
            _throttle.Release();
        }
    }
}

public static class FTPQueue
{
    private const int MAX_FILE_UPLOADS = 3;
    private static readonly Throttle UploadThrottle = new Throttle(MAX_FILE_UPLOADS);
    
    public static async Task FileReceived(string fileName)
    {
        Console.WriteLine("Received file {0}", fileName);
        
        using (await UploadThrottle.WaitAsync())
        {
            Console.WriteLine("Uploading file {0}", fileName);
            bool result = await TransferFile(fileName);
            if (result)
            {
                Console.WriteLine("Finished uploading {0}", fileName);
            }
            else
            {
                Console.WriteLine("Failed to upload {0}", fileName);
            }
        }
    }
    
    private static async Task<bool> TransferFile(string fileName)
    {
        await Task.Delay(10000);
        return true;
    }
}

Quote:

you can write any C# you like in your 'configuration file'