将JSON.NET与OrderedDictionary一起使用

Question

我有一个带有int键和System.Drawing.Rectangle值的OrderedDictionary。JSON.NET不会序列化OrderedDictionary。。。它返回一个空对象。我写了一个自定义转换器，但我想知道是否有更简单的方法。考虑到JSON.NET可能会使用类型化枚举器作为触发器，使用其内置代码对Dictionary<TKey, TValue>进行序列化和反序列化，我尝试了以下操作：

class Program
{
    static void Main(string[] args)
    {
        var test = new OrderedDictionary<int, Rectangle>();
        test.Add(1, new Rectangle(0, 0, 50, 50));
        test.Add(42, new Rectangle(1, 1, 1, 1));
        string s = JsonConvert.SerializeObject(test);
        var deserialized = JsonConvert.DeserializeObject<OrderedDictionary<int, Rectangle>>(s);
        var someRect = deserialized[(object)1]; // someRect is null
        var someOtherRect = (Rectangle)deserialized["1"]; // InvalidCastException
    }
}
public class OrderedDictionary<TKey, TValue> : OrderedDictionary, IEnumerable<KeyValuePair<TKey, TValue>>
{
    IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
    {
        foreach (TKey key in Keys)
        {
            yield return new KeyValuePair<TKey, TValue>(key, (TValue)this[key]);
        }
    }
}

序列化非常有效。但是，当我进行反序列化时，字典中的键变成了字符串，而Rectangle s是不能强制转换为Rectangle的JObject s。有什么东西可以添加到我的OrderedDictionary<>类中，从而允许使用JSON.NET进行正确的反序列化吗？谢谢

Answer 1

您的问题是，尽管您添加了枚举器，但像索引器这样的东西不能被覆盖。因此，您得到的是非通用OrderedDictionary的默认实现，它不会给您一个类型化的结果。

因此，您需要一个完全实现泛型接口的facade，而不是继承。

你需要验证我的类（我刚刚完成了测试）。我还欺骗了Keys和Values属性（它们不经常使用）以及其他一些ICollection方法。只是懒惰：）

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Drawing;
using Newtonsoft.Json;
using Xunit;
namespace XUnitTestProject1
{
    public class UnitTest1
    {
        [Fact]
        public void TestJsonRectange()
        {
            var test = new OrderedDictionary<int, Rectangle>();
            test.Add(1, new Rectangle(0, 0, 50, 50));
            test.Add(42, new Rectangle(1, 1, 1, 1));
            string json = JsonConvert.SerializeObject(test);
            var deserialized = JsonConvert.DeserializeObject<OrderedDictionary<int, Rectangle>>(json);
            object someRect = deserialized[1];
            Assert.NotNull(someRect);
            Assert.True(someRect is Rectangle);
        }
        [Fact]
        public void TestJsonString()
        {
            var test = new OrderedDictionary<string, string>();
            test.Add("1", "11");
            test.Add("42", "4242");
            string json = JsonConvert.SerializeObject(test);
            var deserialized = JsonConvert.DeserializeObject<OrderedDictionary<string, string>>(json);
            object something = deserialized["1"];
            Assert.NotNull(something);
            Assert.True(something is string);
        }
        public class OrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>
        {
            private readonly OrderedDictionary dic = new OrderedDictionary();
            public TValue this[TKey key] { get { return (TValue)dic[key]; } set { dic[key] = value; } }
            public void Add(KeyValuePair<TKey, TValue> item)
            {
                dic.Add(item.Key, item.Value);
            }
            public void Add(TKey key, TValue value)
            {
                dic.Add(key, value);
            }
            public void Clear() { dic.Clear(); }

            public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) { }

            public int Count { get { return dic.Count; } }
            public bool IsReadOnly { get { return false; } }
            public bool Contains(TKey key) { return dic.Contains(key); }
            public bool ContainsKey(TKey key) { return dic.Contains(key); }
            public bool Remove(TKey key) { dic.Remove(key); return true; }
            public bool TryGetValue(TKey key, out TValue value) { value = default(TValue); return false; }
            bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
            {
                throw new NotImplementedException();
            }
            bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) { return false; }
            public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
            {
                foreach (DictionaryEntry entry in dic)
                    yield return new KeyValuePair<TKey, TValue>((TKey)entry.Key, (TValue)entry.Value);
            }
            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
            private static readonly TKey[] keys = new TKey[0];
            private static readonly TValue[] values = new TValue[0];
            ICollection<TKey> IDictionary<TKey, TValue>.Keys { get { return keys; } }
            ICollection<TValue> IDictionary<TKey, TValue>.Values { get { return values; } }
        }
    }
}