C#：如何为TItem、Id及参数数组生成缓存固定键？

我之前也踩过GetHashCode的坑！它完全不适合用来生成缓存键——毕竟GetHashCode的设计初衷是给哈希表做快速索引用的，不是生成稳定、跨场景的唯一标识。尤其是对于object[]这种引用类型，默认的GetHashCode是基于对象实例的引用，哪怕两个数组内容完全一样，只要是不同的实例，哈希值就可能不一样；甚至同一个程序重启后，同一个对象的GetHashCode都可能变化。

要生成稳定的缓存键，核心思路是把所有参与标识的参数（类型、Id、args）都转换成稳定的字符串表示，再组合起来。下面是我常用的实现方案，保证相同参数每次生成的键完全一致：

实现思路 #

1. 包含类型信息：用TItem的完整类型名（FullName）来区分不同类型的缓存项，避免不同类型的对象因为Id和args相同而混淆缓存。
2. 稳定处理值类型：对于int Id和args里的值类型，用InvariantCulture转字符串，避免不同地区的格式差异（比如日期、数字的格式）。
3. 统一处理引用类型：对于args里的引用类型，用稳定的JSON序列化（保证属性顺序、忽略无意义的格式差异）来生成唯一表示；如果是自定义类型，也可以重写ToString()返回稳定标识。
4. 可选：缩短键长度：如果组合后的字符串太长，可以用SHA256生成哈希值，转成十六进制字符串作为最终键（几乎不会有冲突）。

完整代码示例 #

using System;
using System.Globalization;
using System.Text;
using System.Text.Json;

public static class CacheKeyGenerator
{
    // 配置稳定的JSON序列化选项，确保相同内容生成相同的JSON字符串
    private static readonly JsonSerializerOptions _stableJsonOptions = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        WriteIndented = false,
        DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull,
        PropertyOrdering = JsonPropertyOrder.Alphabetical, // 强制属性按字母顺序序列化
        DictionaryKeyPolicy = JsonNamingPolicy.CamelCase
    };

    public static string GenerateCacheKey<TItem>(int id, params object[] args)
    {
        var keyBuilder = new StringBuilder();
        
        // 1. 添加类型完整名称，区分不同类型的缓存项
        keyBuilder.Append(typeof(TItem).FullName);
        keyBuilder.Append("|");
        
        // 2. 添加Id，用固定文化格式避免差异
        keyBuilder.Append(id.ToString(CultureInfo.InvariantCulture));
        
        // 3. 添加参数的稳定表示
        if (args != null && args.Length > 0)
        {
            keyBuilder.Append("|");
            for (int i = 0; i < args.Length; i++)
            {
                if (i > 0)
                    keyBuilder.Append(",");
                
                keyBuilder.Append(GetStableStringRepresentation(args[i]));
            }
        }
        
        // 可选：如果键太长，用SHA256哈希缩短（取消注释即可）
        // return GenerateSha256Hash(keyBuilder.ToString());
        return keyBuilder.ToString();
    }

    private static string GetStableStringRepresentation(object obj)
    {
        if (obj == null)
            return "null";
        
        // 处理值类型和字符串，用不变文化保证格式一致
        if (obj is ValueType || obj is string)
        {
            return Convert.ToString(obj, CultureInfo.InvariantCulture) ?? "null";
        }
        
        // 处理其他引用类型，用稳定JSON序列化生成唯一标识
        return JsonSerializer.Serialize(obj, _stableJsonOptions);
    }

    private static string GenerateSha256Hash(string input)
    {
        using var sha256 = System.Security.Cryptography.SHA256.Create();
        byte[] inputBytes = Encoding.UTF8.GetBytes(input);
        byte[] hashBytes = sha256.ComputeHash(inputBytes);
        
        // 转成十六进制字符串，保证长度固定且唯一
        StringBuilder sb = new StringBuilder();
        foreach (byte b in hashBytes)
        {
            sb.Append(b.ToString("x2"));
        }
        return sb.ToString();
    }
}

使用示例 #

// 生成User类型、Id=123、参数为"admin"和DateTime(2024,5,20)的缓存键
string key = CacheKeyGenerator.GenerateCacheKey<User>(123, "admin", new DateTime(2024,5,20));

注意事项 #

• 如果args里包含自定义类型，要么确保它的ToString()返回稳定的唯一标识，要么依赖JSON序列化（此时要保证自定义类型的属性都是可序列化的）。
• 如果你担心组合后的字符串太长（比如args里有复杂对象），就用SHA256哈希的方式，生成的键长度固定（64个十六进制字符），而且几乎不会出现冲突。
• 永远不要用GetHashCode()生成缓存键，它的行为不稳定，很容易导致缓存命中失败或者缓存污染。

内容的提问来源于stack exchange，提问作者Cedric Arnould