Json.NET Dictionary <string, T> с сериализацией StringComparer

У меня есть словарь Dictionary<string, Dictionary<string, object>>. И внешний словарь, и внутренний имеют набор сравнения равенств (в моем случае это StringComparer.OrdinalIgnoreCase). После того, как словарь сериализуется и десериализуется, для обоих словарей не установлено значение StringComparer.OrdinalIgnoreCase.

Если у вас есть контроль над созданием словарей в вашем коде, вы можете создать класс, унаследованный от словаря, и установить сопоставление в конструкторе по умолчанию класса. Но что, если у вас нет контроля над созданием словарей, и вы получите словарь из другого кода?

Есть ли способ сериализовать/десериализовать его корректно с помощью компаратора?

Ответ 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

Ответ 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);

Ответ 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" ), они будут перезаписаны. Вы можете легко адаптировать метод для исключения исключений в таких случаях (если хотите).
Мое решение не использует строгое сравнение во время десериализации, но, скорее всего, это самый простой способ получить словарь в состоянии, нечувствительном к регистру.