Как десериализовать словарь с помощью NodaTime.Instant с использованием Json.net без исключения?

Ответ 1

Вам нужно добавить больше конвертеров JSON.NET для сериализации времени NodaTime.Instance, как показано ниже.

public void DeserializeDictionaryThowsException()
{
    var dtzProvider = DateTimeZoneCache.GetSystemDefault();
    JsonConverter[] converters = { NodaConverters.IntervalConverter, 
                                   NodaConverters.InstantConverter,
                                   NodaConverters.LocalDateConverter,
                                   NodaConverters.LocalDateTimeConverter,
                                   NodaConverters.LocalTimeConverter,
                                   NodaConverters.OffsetConverter,
                                   NodaConverters.DurationConverter,
                                   NodaConverters.RoundtripPeriodConverter,
                                   NodaConverters.OffsetDateTimeConverter,
                                   NodaConverters.CreateDateTimeZoneConverter(dtzProvider),
                                   NodaConverters.CreateZonedDateTimeConverter(dtzProvider)
                                 };

    var dictionary = new Dictionary<Instant, int>() { { Instant.FromUtc(2012, 1, 2, 3, 4, 5), 0 } };
    var json = JsonConvert.SerializeObject(dictionary, Formatting.None, converters);
    Assert.AreEqual("{\"2012-01-02T03:04:05Z\":0}", json);
    var result = JsonConvert.DeserializeObject<Dictionary<Instant, int>>(json, converters);
}

Ответ 2

Эта проблема привязана к https://github.com/nodatime/nodatime.serialization/issues/2

У меня есть работа, модифицированная из http://stackoverflow.com/q/6845364/634824. Это ни в коем случае не выполняется, и не было полностью протестировано.

public class DictionaryWithNodaTimeKeyConverter : JsonConverter
{
    private static IDateTimeZoneProvider dtzProvider = DateTimeZoneProviders.Tzdb;
    private JsonSerializerSettings _settings;

    public DictionaryWithNodaTimeKeyConverter(IDateTimeZoneProvider dtzProvider)
        : base()
    {
        _settings = new JsonSerializerSettings().ConfigureForNodaTime(dtzProvider);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        IDictionary dictionary = (IDictionary)value;
        writer.WriteStartObject();

        foreach (object key in dictionary.Keys)
        {
            writer.WritePropertyName(ConvertToPropertyKey(key));
            serializer.Serialize(writer, dictionary[key]);
        }

        writer.WriteEndObject();
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
        {
            return null;
        }

        Type keyType = objectType.GetGenericArguments()[0];
        Type valueType = objectType.GetGenericArguments()[1];

        Type intermediateDictionaryType = typeof(Dictionary<,>).MakeGenericType(typeof(string), valueType);
        IDictionary intermediateDictionary = (IDictionary)Activator.CreateInstance(intermediateDictionaryType);
        serializer.Populate(reader, intermediateDictionary);

        IDictionary finalDictionary = (IDictionary)Activator.CreateInstance(objectType);
        foreach (DictionaryEntry pair in intermediateDictionary)
        {
            object parsedObject;
            if (TryConvertKey(pair.Key.ToString(), keyType, out parsedObject))
            {
                finalDictionary.Add(parsedObject, pair.Value);
            }
        }

        return finalDictionary;
    }

    public override bool CanConvert(Type objectType)
    {
        bool canConvert = objectType.IsA(typeof(IDictionary<,>));

        if (canConvert)
        {
            Type keyType = objectType.GetGenericArguments()[0];
            canConvert = canConvert && IsNodaTimeType(keyType);
        }

        return canConvert;
    }

    private bool IsNodaTimeType(Type type)
    {
        return type.IsA(typeof(Instant))
                || type.IsA(typeof(OffsetDateTime))
                || type.IsA(typeof(DateTimeZone))
                || type.IsA(typeof(ZonedDateTime))
                || type.IsA(typeof(LocalDateTime))
                || type.IsA(typeof(LocalDate))
                || type.IsA(typeof(LocalTime))
                || type.IsA(typeof(Offset))
                || type.IsA(typeof(Duration))
                || type.IsA(typeof(Period));
        // Interval is not Support because Interval is serialized as a compound object.
    }

    private string ConvertToPropertyKey(object property)
    {
        if (!IsNodaTimeType(property.GetType()))
        {
            throw new InvalidOperationException();
        }

        string result = JsonConvert.SerializeObject(property, _settings);
        if (!string.IsNullOrWhiteSpace(result))
        {
            // Remove the "" from JsonConvert
            int first = result.IndexOf('"');
            int last = result.LastIndexOf('"');
            if (first != -1 && last != -1 && first < last)
            {
                result = result.Substring(first + 1, last - (first + 1));
            }
        }

        return result;
    }

    private bool TryConvertKey(string text, Type keyType, out object value)
    {
        if (!IsNodaTimeType(keyType))
        {
            throw new InvalidOperationException();
        }

        value = keyType.CreateDefault();

        try
        {
            value = JsonConvert.DeserializeObject($"\"{text}\"", keyType, _settings);
            return true;
        }
        catch
        {
            return false;
        }
    }
}

Я также определил некоторые расширения

public static class TypeExtensions
{
    public static bool IsA(this Type type, Type typeToBe)
    {
        if (!typeToBe.IsGenericTypeDefinition)
            return typeToBe.IsAssignableFrom(type);

        List<Type> toCheckTypes = new List<Type> { type };
        if (typeToBe.IsInterface)
            toCheckTypes.AddRange(type.GetInterfaces());

        Type basedOn = type;
        while (basedOn.BaseType != null)
        {
            toCheckTypes.Add(basedOn.BaseType);
            basedOn = basedOn.BaseType;
        }

        return toCheckTypes.Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeToBe);
    }

    public static object CreateDefault(this Type type)
    {
        return type.IsValueType ? Activator.CreateInstance(type) : null;
    }
}

Чтобы использовать его:

IDateTimeZoneProvider provider = DateTimeZoneProviders.Tzdb;
JsonConverter[] converters = { NodaConverters.IntervalConverter, NodaConverters.InstantConverter, new DictionaryWithNodaTimeKeyConverter(provider) };

var dictionary = new Dictionary<Instant, int> {
    { Instant.FromUtc(2012, 1, 2, 3, 4, 5), 0 }
};

var json = JsonConvert.SerializeObject(dictionary, Formatting.None, converters);
Console.WriteLine(json);
var result = JsonConvert.DeserializeObject<Dictionary<Instant, int>>(json, converters);