# Redis 服务使用案例

## 1. 缓存（ICacheService）

通过构造函数注入 `ICacheService`，HybridCacheService 自动实现 L1(内存) + L2(Redis) 双层缓存。

```csharp
public class MyService
{
    private readonly ICacheService _cache;

    public MyService(ICacheService cache)
    {
        _cache = cache;
    }

    // 缓存字符串，60秒过期
    public void CacheString()
    {
        _cache.Add("token:10001", "abc123", 60);
        var token = _cache.Get("token:10001");
    }

    // 缓存对象
    public void CacheObject()
    {
        var user = new { Id = 1, Name = "张三" };
        _cache.AddObject("user:1", user, 300);
        var cached = _cache.Get<dynamic>("user:1");
    }

    // 删除缓存
    public void RemoveCache()
    {
        _cache.Remove("user:1");
        _cache.Remove(new[] { "token:10001", "token:10002" });
    }
}
```

## 2. 分布式锁（IDistributedLockService）

```csharp
public class OrderService
{
    private readonly IDistributedLockService _lock;

    public OrderService(IDistributedLockService lockService)
    {
        _lock = lockService;
    }

    // 方式一：手动获取和释放锁
    public void ProcessOrder(string orderId)
    {
        var token = _lock.AcquireLock($"order:{orderId}", TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(5));
        if (token == null)
        {
            Console.WriteLine("获取锁失败，其他进程正在处理");
            return;
        }
        try
        {
            // 业务逻辑...
        }
        finally
        {
            _lock.ReleaseLock($"order:{orderId}", token);
        }
    }

    // 方式二：自动管理锁的生命周期
    public void ProcessOrderAuto(string orderId)
    {
        var success = _lock.ExecuteWithLock($"order:{orderId}", TimeSpan.FromSeconds(30), () =>
        {
            // 业务逻辑...
        });
    }
}
```

## 3. 计数器（ICounterService）

```csharp
public class StatisticsService
{
    private readonly ICounterService _counter;

    public StatisticsService(ICounterService counter)
    {
        _counter = counter;
    }

    // 任务计数
    public void OnTaskCompleted()
    {
        _counter.Increment("task:completed");
        var total = _counter.GetCount("task:completed");
    }

    // 带过期时间的计数（如：每小时请求数）
    public void OnApiRequest()
    {
        var count = _counter.IncrementWithExpiry("api:hourly", TimeSpan.FromHours(1));
    }
}
```

## 4. 发布/订阅（IMessageQueueService）

```csharp
public class NotificationService
{
    private readonly IMessageQueueService _mq;

    public NotificationService(IMessageQueueService mq)
    {
        _mq = mq;
    }

    // 发布消息
    public void NotifyTaskComplete(int taskId)
    {
        _mq.Publish("task:complete", $"{{\"taskId\":{taskId}}}");
    }

    // 订阅消息
    public void SubscribeTaskEvents()
    {
        _mq.Subscribe("task:complete", (channel, message) =>
        {
            Console.WriteLine($"收到任务完成通知: {message}");
        });
    }

    // 简单队列：入队/出队
    public void UseQueue()
    {
        _mq.Enqueue("pending-tasks", "task_001");
        var task = _mq.Dequeue("pending-tasks");
    }
}
```

## 5. 限流（IRateLimitingService）

```csharp
public class ApiController
{
    private readonly IRateLimitingService _rateLimiter;

    public ApiController(IRateLimitingService rateLimiter)
    {
        _rateLimiter = rateLimiter;
    }

    // 固定窗口限流：每分钟最多100次
    public bool CheckRateLimit(string clientIp)
    {
        return _rateLimiter.IsAllowed($"api:{clientIp}", 100, TimeSpan.FromMinutes(1));
    }

    // 滑动窗口限流
    public bool CheckSlidingRateLimit(string clientIp)
    {
        return _rateLimiter.IsAllowedSliding($"api:{clientIp}", 100, TimeSpan.FromMinutes(1));
    }

    // 令牌桶限流：桶容量50，每秒补充10个
    public bool CheckTokenBucket(string clientIp)
    {
        return _rateLimiter.TryAcquireToken($"api:{clientIp}", 50, 10, TimeSpan.FromSeconds(1));
    }
}
```

## 6. 分布式ID生成器（IDistributedIdGenerator）

```csharp
public class TaskService
{
    private readonly IDistributedIdGenerator _idGen;

    public TaskService(IDistributedIdGenerator idGen)
    {
        _idGen = idGen;
    }

    // 自增ID
    public long CreateTask()
    {
        var id = _idGen.NextId("task");
        return id; // 1, 2, 3...
    }

    // 带日期前缀的ID
    public string CreateTaskCode()
    {
        var code = _idGen.NextIdWithDate("task");
        return code; // 20260302000001
    }
}
```

## 7. 排行榜（ILeaderboardService）

```csharp
public class LeaderboardDemo
{
    private readonly ILeaderboardService _board;

    public LeaderboardDemo(ILeaderboardService board)
    {
        _board = board;
    }

    public void Demo()
    {
        // 添加/更新分数
        _board.AddOrUpdate("efficiency", "设备A", 95.5);
        _board.AddOrUpdate("efficiency", "设备B", 88.0);

        // 增加分数
        _board.IncrementScore("efficiency", "设备A", 2.0);

        // 获取排名和Top N
        var rank = _board.GetRank("efficiency", "设备A"); // 0 = 第一名
        var top10 = _board.GetTopN("efficiency", 10);
    }
}
```

## 8. 对象存储（IObjectStorageService）

```csharp
public class DeviceService
{
    private readonly IObjectStorageService _storage;

    public DeviceService(IObjectStorageService storage)
    {
        _storage = storage;
    }

    public void Demo()
    {
        // 存储完整对象
        var device = new { Id = 1, Name = "堆垛机01", Status = "Running" };
        _storage.SetObject("device:1", device, TimeSpan.FromMinutes(30));

        // 读取对象
        var cached = _storage.GetObject<dynamic>("device:1");

        // Hash字段操作
        _storage.SetField("device:1:props", "temperature", "36.5");
        var temp = _storage.GetField("device:1:props", "temperature");
    }
}
```

## 9. 配置中心（IConfigurationCenterService）

```csharp
public class ConfigDemo
{
    private readonly IConfigurationCenterService _config;

    public ConfigDemo(IConfigurationCenterService config)
    {
        _config = config;
    }

    public void Demo()
    {
        // 设置配置
        _config.Set("system", "MaxTaskCount", "100");
        _config.Set("system", "EnableAutoDispatch", "true");

        // 读取配置
        var maxTask = _config.Get("system", "MaxTaskCount");
        var allConfig = _config.GetSection("system");

        // 监听配置变更
        _config.Subscribe("system", (key, value) =>
        {
            Console.WriteLine($"配置变更: {key} = {value}");
        });
    }
}
```

## 10. 监控（IRedisMonitorService）

```csharp
public class MonitorDemo
{
    private readonly IRedisMonitorService _monitor;

    public MonitorDemo(IRedisMonitorService monitor)
    {
        _monitor = monitor;
    }

    public void Demo()
    {
        // 健康检查
        var healthy = _monitor.HealthCheck();

        // 内存信息
        var mem = _monitor.GetMemoryInfo();
        Console.WriteLine($"内存使用: {mem.UsedMemoryHuman}, 使用率: {mem.UsagePercent}%");

        // 连接数和Key数量
        var clients = _monitor.GetClientCount();
        var dbSize = _monitor.GetDbSize();
    }
}
```

## 11. Session存储（ISessionStorage）

```csharp
public class SessionDemo
{
    private readonly ISessionStorage _session;

    public SessionDemo(ISessionStorage session)
    {
        _session = session;
    }

    public void Demo()
    {
        var sid = Guid.NewGuid().ToString("N");

        // 设置Session数据，30分钟过期
        _session.Set(sid, "userId", "10001", TimeSpan.FromMinutes(30));
        _session.Set(sid, "role", "admin");

        // 读取
        var userId = _session.Get(sid, "userId");

        // 续期
        _session.RefreshSession(sid, TimeSpan.FromMinutes(30));

        // 销毁
        _session.DestroySession(sid);
    }
}
```

## 12. 布隆过滤器（IBloomFilterService）

```csharp
public class BloomFilterDemo
{
    private readonly IBloomFilterService _bloom;

    public BloomFilterDemo(IBloomFilterService bloom)
    {
        _bloom = bloom;
    }

    // 防止缓存穿透
    public void Demo()
    {
        // 预热：将已有数据加入过滤器
        _bloom.AddRange("task:ids", new[] { "T001", "T002", "T003" });

        // 查询前先检查
        if (!_bloom.MayExist("task:ids", "T999"))
        {
            // 一定不存在，直接返回，避免查询数据库
            return;
        }
        // 可能存在，继续查询数据库...
    }
}
```