public interface IRateLimitStore<T>
{
    Task<bool> ExistsAsync(string id, CancellationToken cancellationToken = default);
    Task<T> GetAsync(string id, CancellationToken cancellationToken = default);
    Task RemoveAsync(string id, CancellationToken cancellationToken = default);
    Task SetAsync(string id, T entry, TimeSpan? expirationTime = null, 
        CancellationToken cancellationToken = default
    );
}

// src/AspNetCoreRateLimit/Core/IpRateLimitProcessor.cs
public async Task<IEnumerable<RateLimitRule>> GetMatchingRulesAsync(
    ClientRequestIdentity identity, 
    CancellationToken cancellationToken = default
)
{
    var policies = await _policyStore.GetAsync(
        $"{_options.IpPolicyPrefix}",
        cancellationToken
    );
    var rules = new List<RateLimitRule>();
    if (policies?.IpRules?.Any() == true)
    {
        // search for rules with IP intervals containing client IP
        var matchPolicies = policies.IpRules
            .Where(r => IpParser.ContainsIp(r.Ip, identity.ClientIp));
        foreach (var item in matchPolicies)
        {
            rules.AddRange(item.Rules);
        }
    }

    return GetMatchingRules(identity, rules);
}

// src/AspNetCoreRateLimit/Core/ClientRateLimitProcessor.cs
public async Task<IEnumerable<RateLimitRule>> GetMatchingRulesAsync(
    ClientRequestIdentity identity, 
    CancellationToken cancellationToken = default
)
{
    var policy = await _policyStore.GetAsync(
        $"{_options.ClientPolicyPrefix}_{identity.ClientId}", 
        cancellationToken
    );
    return GetMatchingRules(identity, policy?.Rules);
}

public virtual async Task<RateLimitCounter> ProcessRequestAsync(
    ClientRequestIdentity requestIdentity, 
    RateLimitRule rule, 
    CancellationToken cancellationToken = default
)
{
    var counter = new RateLimitCounter
    {
        Timestamp = DateTime.UtcNow,
        Count = 1
    };

    // 生成CounterId
    var counterId = BuildCounterKey(requestIdentity, rule);
    
    // 基于AsyncLock的计数器
    // serial reads and writes on same key
    using (await AsyncLock.WriterLockAsync(counterId).ConfigureAwait(false))
    {
        var entry = await _counterStore.GetAsync(counterId, cancellationToken);

        if (entry.HasValue)
        {
            // entry has not expired
            if (entry.Value.Timestamp + rule.PeriodTimespan.Value >= DateTime.UtcNow)
            {
                // increment request count
                var totalCount = entry.Value.Count + _config.RateIncrementer?.Invoke() ?? 1;

                // deep copy
                counter = new RateLimitCounter
                {
                    Timestamp = entry.Value.Timestamp,
                    Count = totalCount
                };
            }
        }
        
        // 计数器存储
        // stores: id (string) - timestamp (datetime) - total_requests (long)
        await _counterStore.SetAsync(
            counterId, 
            counter, 
            rule.PeriodTimespan.Value, 
            cancellationToken
        );
    }

    return counter;
}

public AsyncKeyLockDoorman(Action<AsyncKeyLockDoorman> reset)
{   
    // 多个写入者
    _waitingWriters = new Queue<TaskCompletionSource<Releaser>>();
    // 单个读取者
    _waitingReader = new TaskCompletionSource<Releaser>();
    _status = 0;

    _readerReleaser = Task.FromResult(new Releaser(this, false));
    _writerReleaser = Task.FromResult(new Releaser(this, true));
    _reset = reset;
}

public Task<Releaser> WriterLockAsync()
{
    lock (_waitingWriters)
    {
        if (_status == 0)
        {
            _status = -1;
            return _writerReleaser;
        }
        else
        {
            var waiter = new TaskCompletionSource<Releaser>();
            _waitingWriters.Enqueue(waiter);
            return waiter.Task;
        }
    }
}

public Task<Releaser> ReaderLockAsync()
{
    lock (_waitingWriters)
    {
        if (_status >= 0 && _waitingWriters.Count == 0)
        {
            ++_status;
            return _readerReleaser;
        }
        else
        {
            ++_readersWaiting;
            return _waitingReader.Task.ContinueWith(t => t.Result);
        }
    }
}

// GetDoorman()
private static AsyncKeyLockDoorman GetDoorman(string key)
{
    AsyncKeyLockDoorman doorman;
    bool lockTaken = false;
    try
    {
        _spinLock.Enter(ref lockTaken);
        if (!Keys.TryGetValue(key, out doorman))
        {
            doorman = (Pool.Count > 0) ? Pool.Pop() : 
                new AsyncKeyLockDoorman(ReleaseDoorman);
            doorman.Key = key;
            Keys.Add(key, doorman);
        }

        doorman.RefCount++;
    }
    finally
    {
        if (lockTaken)
        {
            _spinLock.Exit();
        }
    }

    return doorman;
}

// ReleaseDoorman()
private static void ReleaseDoorman(AsyncKeyLockDoorman doorman)
{
    bool lockTaken = false;
    try
    {
        _spinLock.Enter(ref lockTaken);
        if (--doorman.RefCount == 0)
        {
            Keys.Remove(doorman.Key);
            if (Pool.Count < MaxPoolSize)
            {
                doorman.Key = null;
                Pool.Push(doorman);
            }
        }
    }
    finally
    {
        if (lockTaken)
        {
            _spinLock.Exit();
        }
    }
}

public async Task Invoke(HttpContext context)
{
    // 检查限流是否启用
    if (_options == null)
    {
        await _next.Invoke(context);
        return;
    }

    // 获取用户身份
    var identity = await ResolveIdentityAsync(context);

    // 检查白名单
    if (_processor.IsWhitelisted(identity))
    {
        await _next.Invoke(context);
        return;
    }

    //获取限流规则
    var rulesDict = new Dictionary<RateLimitRule, RateLimitCounter>();
    var rules = await _processor.GetMatchingRulesAsync(
        identity, 
        context.RequestAborted
    );
    foreach (var rule in rules)
    {
        // 获取计数器数目
        var rateLimitCounter = await _processor.ProcessRequestAsync(
            identity, 
            rule, 
            context.RequestAborted
        );
        if (rule.Limit > 0)
        {
            // 请求未过期
            if (rateLimitCounter.Timestamp + rule.PeriodTimespan.Value < DateTime.UtcNow)
            {
                continue;
            }

            // 请求过期
            if (rateLimitCounter.Count > rule.Limit)
            {
                // 各种记日志，告诉调用者多长时间后再重试
                var retryAfter = rateLimitCounter.Timestamp.RetryAfterFrom(rule);
                
                // ...

                // 中止请求
                await ReturnQuotaExceededResponse(context, rule, retryAfter);
                return;
            }
        }
        else
        {
            // Limit <= 0, 相当于直接不允许放行，中止请求
            await ReturnQuotaExceededResponse(
                context, 
                rule, 
                int.MaxValue.ToString(System.Globalization.CultureInfo.InvariantCulture)
            ); 
        }

        // ...
    }

    // 设置X-Rate-Limit头
    // ...

    await _next.Invoke(context);
}