private const int RequestsLimit = 50;
private static readonly SemaphoreSlim Throttler =
  new SemaphoreSlim(RequestsLimit);
async Task<HttpResponseMessage> InvokeServiceAsync(HttpClient client)
{
  try
  {
    await Throttler.WaitAsync().ConfigureAwait(false);
    return await client.GetAsync("todos/1").ConfigureAwait(false);
  }
  finally
  {
    Throttler.Release();
  }
}

--[[
  KEYS[1] - Имя семафора
  ARGV[1] - Время жизни блокировки
  ARGV[2] - Идентификатор блокировки, чтобы её можно было возвратить
  ARGV[3] - Доступный объем семафора
]]--
-- Будем использовать команды с недетерминированным результатом,
-- Redis-у важно знать заранее
redis.replicate_commands()
local unix_time = redis.call('TIME')[1]
-- Удаляем блокировки с истёкшим TTL
redis.call('ZREMRANGEBYSCORE', KEYS[1], '-inf', unix_time - ARGV[1])
-- Получаем число элементов в множестве
local count = redis.call('zcard', KEYS[1])
if count < tonumber(ARGV[3]) then
  -- добавляем блокировку в множество, если есть место
  -- время будет являться ключем сортировки (для последующий чистки записей)
  redis.call('ZADD', KEYS[1], unix_time, ARGV[2])
  -- Возвращаем число взятых блокировок (например, для логирования)
  return count
end
return nil

public sealed class RedisSemaphore
{
  private static readonly string AcquireScript = "...";
  private static readonly int TimeToLiveInSeconds = 300;
  private readonly Func<ConnectionMultiplexer> _redisFactory;
  public RedisSemaphore(Func<ConnectionMultiplexer> redisFactory)
  {
    _redisFactory = redisFactory;
  }
  public async Task<LockHandler> AcquireAsync(string name, int limit)
  {
    var handler = new LockHandler(this, name);
    do
    {
      var redisDb = _redisFactory().GetDatabase();
      var rawResult = await redisDb
        .ScriptEvaluateAsync(AcquireScript, new RedisKey[] { name },
          new RedisValue[] { TimeToLiveInSeconds, handler.Id, limit })
        .ConfigureAwait(false);
      var acquired = !rawResult.IsNull;
      if (acquired)
        break;
      await Task.Delay(10).ConfigureAwait(false);
    } while (true);
    return handler;
  }
  public async Task ReleaseAsync(LockHandler handler, string name)
  {
    var redis = _redisFactory().GetDatabase();
    await redis.SortedSetRemoveAsync(name, handler.Id)
      .ConfigureAwait(false);
  }
}
public sealed class LockHandler : IAsyncDisposable
{
  private readonly RedisSemaphore _semaphore;
  private readonly string _name;
  public LockHandler(RedisSemaphore semaphore, string name)
  {
    _semaphore = semaphore;
    _name = name;
    Id = Guid.NewGuid().ToString();
  }
  public string Id { get; }
  public async ValueTask DisposeAsync()
  {
    await _semaphore.ReleaseAsync(this, _name).ConfigureAwait(false);
  }
}