如何使 Json.NET 序列化和反序列化也实现 IDictionary<string, object> 的自定义动态类型的声明属性？

Question

我有一个从DynamicObject 类型派生的自定义类型。此类型具有在类型中声明的固定属性。因此，除了他们想要的任何动态属性之外，它还允许用户提供一些必需的属性。当我使用JsonConvert.DeserializeObject<MyType>(json) 方法反序列化此类型的数据时，它不会设置声明的属性，但可以通过动态对象上的对象索引器属性访问这些属性。这告诉我它只是将对象视为字典，不会尝试调用已声明的属性设置器，也不会使用它们来推断属性类型信息。

有没有人遇到过这种情况？知道如何指示JsonConvert 类在反序列化对象数据时考虑声明的属性吗？

我尝试使用自定义JsonConverter，但这需要我编写复杂的 JSON 读写方法。我希望通过覆盖JsonContractResolver或JsonConverter等找到一种注入财产合同信息的方法。

//#define IMPLEMENT_IDICTIONARY

using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using Newtonsoft.Json;

namespace ConsoleApp1
{
    class Program
    {
        public class MyDynamicObject : DynamicObject
#if IMPLEMENT_IDICTIONARY
            , IDictionary<string, object>
#endif
        {
            private Dictionary<string, object> m_Members;

            public MyDynamicObject()
            {
                this.m_Members = new Dictionary<string, object>();
            }


#if IMPLEMENT_IDICTIONARY
            public int Count { get { return this.m_Members.Count; } }

            public ICollection<string> Keys => this.m_Members.Keys;

            public ICollection<object> Values => this.m_Members.Values;

            bool ICollection<KeyValuePair<string, object>>.IsReadOnly => false;

            /// <summary>
            /// Gets or sets the specified member value.
            /// </summary>
            /// <param name="memberName">Name of the member in question.</param>
            /// <returns>A value for the specified member.</returns>
            public object this[string memberName]
            {
                get
                {
                    object value;
                    if (this.m_Members.TryGetValue(memberName, out value))
                        return value;
                    else
                        return null;
                }
                set => this.m_Members[memberName] = value;
            }
#endif


            public override bool TryGetMember(GetMemberBinder binder, out object result)
            {
                this.m_Members.TryGetValue(binder.Name, out result);
                return true;
            }

            public override bool TrySetMember(SetMemberBinder binder, object value)
            {
                this.m_Members[binder.Name] = value;
                return true;
            }

            public override bool TryDeleteMember(DeleteMemberBinder binder)
            {
                return this.m_Members.Remove(binder.Name);
            }

            public override IEnumerable<string> GetDynamicMemberNames()
            {
                var names = base.GetDynamicMemberNames();
                return this.m_Members.Keys;
            }

#if IMPLEMENT_IDICTIONARY
            bool IDictionary<string, object>.ContainsKey(string memberName)
            {
                return this.m_Members.ContainsKey(memberName);
            }

            public void Add(string memberName, object value)
            {
                this.m_Members.Add(memberName, value);
            }

            public bool Remove(string memberName)
            {
                return this.m_Members.Remove(memberName);
            }

            public bool TryGetValue(string memberName, out object value)
            {
                return this.m_Members.TryGetValue(memberName, out value);
            }

            public void Clear()
            {
                this.m_Members.Clear();
            }

            void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> member)
            {
                ((IDictionary<string, object>)this.m_Members).Add(member);
            }

            bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> member)
            {
                return ((IDictionary<string, object>)this.m_Members).Contains(member);
            }

            public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
            {
                ((IDictionary<string, object>)this.m_Members).CopyTo(array, arrayIndex);
            }

            bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> member)
            {
                return ((IDictionary<string, object>)this.m_Members).Remove(member);
            }

            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
            {
                return this.m_Members.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return this.m_Members.GetEnumerator();
            }
#endif
        }

        public class ProxyInfo
        {
            public string Server;
            public int Port;
        }

        public class CustomDynamicObject : MyDynamicObject
        {
            //[JsonProperty] // NOTE: Cannot do this.
            public string Name { get; set; }

            //[JsonProperty]  // NOTE: Cannot do this.
            public ProxyInfo Proxy { get; set; }
        }


        static void Main(string[] args)
        {
            dynamic obj = new CustomDynamicObject()
            {
                Name = "Test1",
                Proxy = new ProxyInfo() { Server = "http://test.com/",  Port = 10102 }
            };
            obj.Prop1 = "P1";
            obj.Prop2 = 320;

            string json = JsonConvert.SerializeObject(obj);  // Returns: { "Prop1":"P1", "Prop2":320 }

            // ISSUE #1: It did not serialize the declared properties. Only the dynamically added properties are serialized.
            //           Following JSON was expected. It produces correct JSON if I mark the declared properties with
            //           JsonProperty attribute, which I cannot do in all cases.
            string expectedJson = "{ \"Prop1\":\"P1\", \"Prop2\":320, \"Name\":\"Test1\", \"Proxy\":{ \"Server\":\"http://test.com/\", \"Port\":10102 } }";


            CustomDynamicObject deserializedObj = JsonConvert.DeserializeObject<CustomDynamicObject>(expectedJson);

            // ISSUE #2: Deserialization worked in this case, but does not work once I re-introduce the IDictionary interface on my base class.
            //           In that case, it does not populate the declared properties, but simply added all 4 properties to the underlying dictionary.
            //           Neither does it infer the ProxyInfo type when deserializing the Proxy property value and simply bound the JObject token to
            //           the dynamic object.
        }
    }
}

我原以为它会像处理常规类型一样使用反射来解析属性及其类型信息。但它似乎只是将对象视为常规字典。

注意：

• 我无法删除 IDictionary<string, object> 接口，因为我的 API 中的一些用例依赖于对象作为字典，而不是动态的。

• 将[JsonProperty] 添加到所有声明的要序列化的属性是不切实际的，因为它的派生类型是由其他开发人员创建的，他们不需要明确关心持久性机制。

关于如何使它正常工作的任何建议？

Answer 1

这里有几个问题：

1. 您需要按照AlbertK 的this answer 中的说明正确覆盖DynamicObject.GetDynamicMemberNames() 到Serialize instance of a class deriving from DynamicObject class，Json.NET 才能序列化您的动态属性。

   （这已在您的问题的编辑版本中得到修复。）

2. 除非您使用[JsonProperty] 明确标记它们（如this answer 到C# How to serialize (JSON, XML) normal properties on a class that inherits from DynamicObject 中所述），否则不会显示已声明的属性，但您的类型定义是只读的并且不能修改。

   这里的问题似乎是JsonSerializerInternalWriter.SerializeDynamic() 只序列化JsonProperty.HasMemberAttribute == true 的声明属性。 （我不知道为什么要在那里进行此检查，在合约解析器中设置CanRead 或Ignored 似乎更有意义。）

3. 你希望你的类实现IDictionary<string, object>，但如果你这样做了，它会破坏反序列化；声明的属性不再填充，而是添加到字典中。

   这里的问题似乎是当传入类型为任何TKey 和TValue 实现IDictionary<TKey, TValue> 时，DefaultContractResolver.CreateContract() 返回JsonDictionaryContract 而不是JsonDynamicContract。

假设您已修复问题 #1，则可以使用 custom contract resolver 处理问题 #2 和 #3，如下所示：

public class MyContractResolver : DefaultContractResolver
{
    protected override JsonContract CreateContract(Type objectType)
    {
        // Prefer JsonDynamicContract for MyDynamicObject
        if (typeof(MyDynamicObject).IsAssignableFrom(objectType))
        {
            return CreateDynamicContract(objectType);
        }
        return base.CreateContract(objectType);
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        var properties = base.CreateProperties(type, memberSerialization);
        // If object type is a subclass of MyDynamicObject and the property is declared
        // in a subclass of MyDynamicObject, assume it is marked with JsonProperty 
        // (unless it is explicitly ignored).  By checking IsSubclassOf we ensure that 
        // "bookkeeping" properties like Count, Keys and Values are not serialized.
        if (type.IsSubclassOf(typeof(MyDynamicObject)) && memberSerialization == MemberSerialization.OptOut)
        {
            foreach (var property in properties)
            {
                if (!property.Ignored && property.DeclaringType.IsSubclassOf(typeof(MyDynamicObject)))
                {
                    property.HasMemberAttribute = true;
                }
            }
        }
        return properties;
    }
}

然后，要使用合约解析器，cache 在某处进行性能：

static IContractResolver resolver = new MyContractResolver();

然后做：

var settings = new JsonSerializerSettings
{
    ContractResolver = resolver,
};
string json = JsonConvert.SerializeObject(obj, settings);

小提琴样本here.

Answer 2

我不知道 ProxyInfo 类里面有什么。但是，当对 Name 和 Proxy 属性都使用字符串时，反序列化可以正常工作。请检查以下工作示例：

    class Program
    {
        static void Main(string[] args)
        {
            // NOTE: This is how I load the JSON data into the new type.
            var obj = JsonConvert.DeserializeObject<MyCustomDynamicObject>("{name:'name1', proxy:'string'}");
            var proxy = obj.Proxy;
            var name = obj.Name;
        }
    }

    public class MyDynamicObject : DynamicObject
    {
        // Implements the functionality to store dynamic properties in 
        // dictionary.
        // NOTE: This base class does not have any declared properties.
    }

    // NOTE: This is the actual concrete type that has declared properties
    public class MyCustomDynamicObject : MyDynamicObject
    {
        public string Name { get; set; }
        public string Proxy { get; set; }
    }