使用非默认构造函数会破坏 Json.net 中的反序列化顺序

Usage of non-default constructor breaks order of deserialization in Json.net(使用非默认构造函数会破坏 Json.net 中的反序列化顺序)
本文介绍了使用非默认构造函数会破坏 Json.net 中的反序列化顺序的处理方法,对大家解决问题具有一定的参考价值,需要的朋友们下面随着跟版网的小编来一起学习吧!


使用 Json.net 反序列化具有父子关系的对象图时,使用非默认构造函数会破坏反序列化的顺序,使得子对象在其父对象之前被反序列化(构造和分配属性),从而导致空引用.

When deserializing an object graph with parent child relationships using Json.net, the use of non-default constructors breaks the order of deserialization such that child objects are deserialized (constructed and properties assigned) before their parents, leading to null references.


From experimentation it appears that all non-default-constructor objects are instantiated only after all default-constructor objects, and oddly it seems in the reverse order to the serialization (children before parents).


This causes 'child' objects that should have references to their parents (and are correctly serialized) to instead be deserialized with null values.


This seems like a very common scenario, so I wonder if I have missed something?


Is there a setting to change this behaviour? Is it somehow by design for other scenarios? Are there workarounds besides creating default constructors across the board?

使用 LINQPad 或 DotNetFiddle 的简单示例:

A simple example with LINQPad or DotNetFiddle:

void Main()
    var root = new Root();
    var middle = new Middle(1);
    var child = new Child();

    root.Middle = middle;
    middle.Root = root;
    middle.Child = child;
    child.Middle = middle;

    var json = JsonConvert.SerializeObject(root, new JsonSerializerSettings
        Formatting = Newtonsoft.Json.Formatting.Indented,
        ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
        PreserveReferencesHandling = PreserveReferencesHandling.All,        
        TypeNameHandling = TypeNameHandling.All,


    //I have tried many different combinations of settings, but they all
    //seem to produce the same effect: 
    var deserialized = JsonConvert.DeserializeObject<Root>(json);


public class Root
    public Root(){"Root".Dump();}

    public Middle Middle {get;set;}

public class Middle
    //Uncomment to see correct functioning:
    //public Middle(){"Middle".Dump();}

    public Middle(int foo){"Middle".Dump();}

    public Root Root {get;set;}

    public Child Child {get;set;}

public class Child
    public Child(){"Child".Dump();}

    public Middle Middle {get;set;}

JSON 输出:

  "$id": "1",
  "$type": "Root",
  "Middle": {
    "$id": "2",
    "$type": "Middle",
    "Root": {
      "$ref": "1"
    "Child": {
      "$id": "3",
      "$type": "Child",
      "Middle": {
        "$ref": "2"

Middle 的输出具有非默认构造函数:

Output with Middle having non-default constructor:

Child.Middle = null

Middle 的输出具有默认构造函数:

Output with Middle having default constructor:

Child.Middle = Middle


您需要使用与序列化相同的设置进行反序列化.话虽如此,您似乎在 Json.NET 中遇到了错误或限制.

You need to use the same settings for deserialization as you did for serialization. That being said, you appear to have encountered a bug or limitation in Json.NET.

发生这种情况的原因如下.如果您的 Middle 类型没有公共无参数构造函数,但有一个带参数的公共构造函数,JsonSerializerInternalReader.CreateObjectUsingCreatorWithParameters()将调用该构造函数,按名称将构造函数参数与 JSON 属性匹配,并对缺失的属性使用默认值.然后,任何剩余的未使用的 JSON 属性都将设置为类型.这启用了只读属性的反序列化.例如.如果我将只读属性 Foo 添加到您的 Middle 类:

It is happening for the following reason. If your Middle type does not have a public parameterless constructor, but does have a single public constructor with parameters, JsonSerializerInternalReader.CreateObjectUsingCreatorWithParameters() will call that constructor, matching the constructor arguments to the JSON properties by name and using default values for missing properties. Then afterwards any remaining unused JSON properties will be set into the type. This enables deserialization of read-only properties. E.g. if I add a read-only property Foo to your Middle class:

public class Middle
    readonly int foo;

    public int Foo { get { return foo; } }

    public Middle(int Foo) { this.foo = Foo; "Middle".Dump(); }

    public Root Root { get; set; }

    public Child Child { get; set; }

Foo 的值将被成功反序列化.(JSON 属性名称与构造函数参数名称的匹配显示在 here文档,但没有得到很好的解释.)

The value of Foo will be successfully deserialized. (The matching of JSON property names to constructor argument names is shown here in the documentation, but not well explained.)

但是,此功能似乎会干扰 PreserveReferencesHandling.All.由于 CreateObjectUsingCreatorWithParameters() 完全反序列化正在构造的对象的所有子对象,以便将必要的那些传递给它的构造函数,如果子对象有一个 "$ref" 给它,该引用将不会被解析,因为该对象尚未被构造.

However, it appears this functionality interferes with PreserveReferencesHandling.All. Since CreateObjectUsingCreatorWithParameters() fully deserializes all child objects of the object being constructed in order to pass those necessary into its constructor, if a child object has a "$ref" to it, that reference will not be resolved, since the object will not have been constructed yet.

作为一种解决方法,您可以将 private 构造函数添加到您的 Middle 类型并设置 ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor:

As a workaround, you could add a private constructor to your Middle type and set ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor:

public class Middle
    private Middle() { "Middle".Dump(); }

    public Middle(int Foo) { "Middle".Dump(); }

    public Root Root { get; set; }

    public Child Child { get; set; }


var settings = new JsonSerializerSettings
    Formatting = Newtonsoft.Json.Formatting.Indented,
    ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
    PreserveReferencesHandling = PreserveReferencesHandling.All,
    ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
var deserialized = JsonConvert.DeserializeObject<Root>(json, settings);

当然,如果你这样做,你将失去反序列化 Middle 的只读属性(如果有的话)的能力.

Of course, if you do this, you loose the ability to deserialize read-only properties of Middle, if there are any.

您可能希望报告有关此问题的问题.理论上,以更高的内存使用为代价,在使用参数化构造函数反序列化类型时,Json.NET 可以:

You might want to report an issue about this. In theory, at the expense of higher memory usage, when deserializing a type with a parameterized constructor, Json.NET could:

  • 将所有子 JSON 属性加载到中间 JToken 中.
  • 仅反序列化那些需要作为构造函数参数的参数.
  • 构造对象.
  • 将对象添加到 JsonSerializer.ReferenceResolver.
  • 反序列化并设置剩余的属性.

但是,如果任何构造函数参数本身对被反序列化的对象有一个 "$ref",这似乎不容易修复.

However, if any of the constructor arguments thenselves have a "$ref" to the object being deserialized, this doesn't appear easily fixable.

这篇关于使用非默认构造函数会破坏 Json.net 中的反序列化顺序的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持跟版网!



Force JsonConvert.SerializeXmlNode to serialize node value as an Integer or a Boolean(强制 JsonConvert.SerializeXmlNode 将节点值序列化为整数或布尔值)
Using JSON to Serialize/Deserialize TimeSpan(使用 JSON 序列化/反序列化 TimeSpan)
Could not determine JSON object type for type quot;Classquot;(无法确定类型“Class的 JSON 对象类型.)
How to deserialize a JSONP response (preferably with JsonTextReader and not a string)?(如何反序列化 JSONP 响应(最好使用 JsonTextReader 而不是字符串)?)
how to de-serialize JSON data in which Timestamp it-self contains fields?(如何反序列化时间戳本身包含字段的JSON数据?)
JSON.Net custom contract serialization and Collections(JSON.Net 自定义合约序列化和集合)