C# 实现接口幂等性的四种方案

public class IdempotentService
{
    private static readonly ConcurrentDictionary<string, string> Cache = new ConcurrentDictionary<string, string>();

    public string ProcessRequestWithUniqueId(string requestId, string input)
    {
        // 检查请求是否已处理
        if (Cache.TryGetValue(requestId, out string result))
        {
            return result; // 返回之前处理的结果
        }

        // 模拟处理过程
        result = "Processed: " + input;
        // 保存处理结果
        Cache[requestId] = result;
        return result;
    }
}

// 使用示例
var service = new IdempotentService();
string requestId = Guid.NewGuid().ToString(); // 生成唯一ID
string input = "Hello, World!";
string result = service.ProcessRequestWithUniqueId(requestId, input);
Console.WriteLine(result); // 输出：Processed: Hello, World!
// 再次使用相同的requestId调用，将返回相同的结果
string result2 = service.ProcessRequestWithUniqueId(requestId, "Different Input");
Console.WriteLine(result2); // 输出：Processed: Hello, World!（与第一次调用相同）
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

public class DatabaseIdempotentService
{
    // 假设有一个方法用于将数据插入数据库
    public bool InsertData(string data)
    {
        try
        {
            // 模拟数据库插入操作，如果数据已存在，则抛出异常
            if (DataExists(data))
            {
                throw new Exception("Data already exists");
            }
            // 模拟成功插入数据
            Console.WriteLine($"Data inserted: {data}");
            return true;
        }
        catch (Exception)
        {
            // 插入失败（可能是重复数据）
            return false;
        }
    }

    // 模拟检查数据是否存在的方法
    private bool DataExists(string data)
    {
        // 实际开发中，这里应该是查询数据库的操作
        return false; // 示例中始终返回false，表示数据不存在
    }
}

// 使用示例
var dbService = new DatabaseIdempotentService();
string data = "Some unique data";
bool result = dbService.InsertData(data); // 尝试插入数据，返回true表示成功，
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.

public class DistributedLockIdempotentService
{
    private static readonly string LockKey = "my_lock_key";
    private readonly IRedisClient _redisClient; // 假设使用StackExchange.Redis等库

    public DistributedLockIdempotentService(IRedisClient redisClient)
    {
        _redisClient = redisClient;
    }

    public string ProcessRequestWithLock(string input)
    {
        // 尝试获取分布式锁
        if (_redisClient.Lock(LockKey, TimeSpan.FromSeconds(30))) // 锁定30秒
        {
            try
            {
                // 模拟处理过程，这里应该是实际的业务逻辑
                string result = "Processed with lock: " + input;
                return result;
            }
            finally
            {
                // 释放锁
                _redisClient.Unlock(LockKey);
            }
        }
        else
        {
            // 获取锁失败，可能已经有其他请求在处理，返回默认结果或错误信息
            return "Failed to acquire lock";
        }
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.

public class StateMachineIdempotentService
{
    private enum ProcessingState
    {
        NotStarted,
        Processing,
        Completed
    }

    private static readonly ConcurrentDictionary<string, ProcessingState> States = new ConcurrentDictionary<string, ProcessingState>();

    public string ProcessRequestWithStateMachine(string requestId, string input)
    {
        // 检查当前状态
        var currentState = States.GetOrAdd(requestId, ProcessingState.NotStarted);
        switch (currentState)
        {
            case ProcessingState.NotStarted:
                // 更新状态为正在处理中
                States[requestId] = ProcessingState.Processing;
                // 模拟处理过程
                string result = "Processed with state machine: " + input;
                // 更新状态为已完成
                States[requestId] = ProcessingState.Completed;
                return result;
            case ProcessingState.Processing:
            case ProcessingState.Completed:
                // 如果已经在处理中或已完成，则直接返回之前的结果或错误信息
                return "Request already processed";
            default:
                throw new InvalidOperationException("Unknown state");
        }
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.