Json.NET Dictionary<string，使用StringComparer序列化的T>

Question

我有一本字典Dictionary<string, Dictionary<string, object>>。外部字典和内部字典都有一个相等比较器集(在我的例子中是StringComparer.OrdinalIgnoreCase)。在对字典进行序列化和反序列化之后，两个字典的比较器都没有设置为StringComparer.OrdinalIgnoreCase。

如果您可以在代码中控制字典的创建，则可以创建一个从字典继承的类，并在该类的默认构造函数中设置比较器。但是，如果您无法控制字典的创建，而是从其他代码中获取字典，该怎么办？

有没有办法用比较器正确地序列化/反序列化它？

Answer 1

一个简单的想法是创建一个Dictionary<string, string>的子类，在默认情况下将比较器设置为StringComparer.OrdinalIgnoreCase，然后反序列化到它而不是普通字典中。例如：

class CaseInsensitiveDictionary<V> : Dictionary<string, V>
{
    public CaseInsensitiveDictionary() : base(StringComparer.OrdinalIgnoreCase)
    {
    }
}

class Program
{
    static void Main(string[] args)
    {
        string json = @"
        {
            ""Foo"" : 
            {
                ""fiZZ"" : 1,
                ""BUzz"" : ""yo""
            },
            ""BAR"" :
            {
                ""dIt"" : 3.14,
                ""DaH"" : true
            }
        }";

        var dict = JsonConvert.DeserializeObject<CaseInsensitiveDictionary<CaseInsensitiveDictionary<object>>>(json);

        Console.WriteLine(dict["foo"]["fizz"]);
        Console.WriteLine(dict["foo"]["buzz"]);
        Console.WriteLine(dict["bar"]["dit"]);
        Console.WriteLine(dict["bar"]["dah"]);
    }
}

输出：

1
yo
3.14
True

Answer 2

最好创建一个根据需要创建字典对象的转换器。这正是Newtonsoft.Json.Converters.CustomCreationConverter<T>设计的目的。

这里有一个可以创建需要自定义比较器的字典的实现。

public class CustomComparerDictionaryCreationConverter<T> : CustomCreationConverter<IDictionary>
{
    private IEqualityComparer<T> comparer;
    public CustomComparerDictionaryCreationConverter(IEqualityComparer<T> comparer)
    {
        if (comparer == null)
            throw new ArgumentNullException("comparer");
        this.comparer = comparer;
    }

    public override bool CanConvert(Type objectType)
    {
        return HasCompatibleInterface(objectType)
            && HasCompatibleConstructor(objectType);
    }

    private static bool HasCompatibleInterface(Type objectType)
    {
        return objectType.GetInterfaces()
            .Where(i => HasGenericTypeDefinition(i, typeof(IDictionary<,>)))
            .Where(i => typeof(T).IsAssignableFrom(i.GetGenericArguments().First()))
            .Any();
    }

    private static bool HasGenericTypeDefinition(Type objectType, Type typeDefinition)
    {
        return objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeDefinition;
    }

    private static bool HasCompatibleConstructor(Type objectType)
    {
        return objectType.GetConstructor(new Type[] { typeof(IEqualityComparer<T>) }) != null;
    }

    public override IDictionary Create(Type objectType)
    {
        return Activator.CreateInstance(objectType, comparer) as IDictionary;
    }
}

但是请注意，此转换器将应用于键与T协变的所有字典类型，而与值类型无关。

然后使用它：

var converters = new JsonConverter[]
{
    new CustomComparerDictionaryCreationConverter<string>(StringComparer.OrdinalIgnoreCase),
};
var dict = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, object>>>(jsonString, converters);

Answer 3

创建一个扩展方法，该方法将值从区分大小写的字典复制到新的不区分大小写的字典。

public static Dictionary<string, T> ToCaseInsensitive<T>(this Dictionary<string, T> caseSensitiveDictionary)
{
    var caseInsensitiveDictionary = new Dictionary<string, T>(StringComparer.OrdinalIgnoreCase);
    caseSensitiveDictionary.Keys.ToList()
        .ForEach(k => caseInsensitiveDictionary[k] = caseSensitiveDictionary[k]);

    return caseInsensitiveDictionary;
}

用法：

var newDictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(value)
.ToCaseInsensitive();

虽然这对我来说很有效(我喜欢这个解决方案，因为它很简单)，但请注意以下警告：

• 如果字典中有重复的键(如"cat“和"CAT")，则复制
• 会产生较小的开销，其中一个键将被覆盖。在这种情况下(如果您愿意)，您可以轻松地调整该方法以抛出异常。
• 我的解决方案在反序列化期间并不严格使用比较器，但这很可能是使字典进入不区分大小写状态的最简单方法。