我可以强制 Json.NET 从根目录开始树反序列化吗

Question

这是我第一次尝试序列化/反序列化树。除了Path，它工作得很好。它必须从根开始构建，但反序列化从叶子开始。

    var root = new Node(null, "rootName");
    var tree = new Tree(root);
    root.AddChild("childName");
    var str = JsonConvert.SerializeObject(tree, Newtonsoft.Json.Formatting.Indented);
    var treeRestored = JsonConvert.DeserializeObject<Tree>(str);

...

class Node
{
    public IReadOnlyList<Node> Children => _children;

    [JsonIgnore]
    public string Path { get; } // needs parent

    [JsonProperty(ReferenceLoopHandling = ReferenceLoopHandling.Ignore)]
    public Node Parent { get; private set; }

    public string Name { get; }

    public Node(Node parent, string name)
    {
        Name = name;
        Parent = parent;
        Path = (parent == null ? "" : (parent.Name + ".")) + name;
        _children = new List<Node>();
    }

    [JsonConstructor]
    private Node(string Name, List<Node> Children)
    {
        this.Name = Name;
        _children = Children;
        foreach (var child in _children)
        {
            child.Parent = this;
        }
    }

    public void AddChild(string name)
    {
        _children.Add(new Node(this, name));
    }

    private readonly List<Node> _children;
}

class Tree
{
    public Node Root;

    public Tree(Node root)
    {
        Root = root;
    }
}

所以我尝试了以下方法。我从 Parent 属性中删除了 JsonProperty，更改了序列化命令，并更改了 JSON 构造函数。

    var str = JsonConvert.SerializeObject(tree, Newtonsoft.Json.Formatting.Indented,
        new JsonSerializerSettings { PreserveReferencesHandling = PreserveReferencesHandling.Objects });

    [JsonConstructor]
    private Node(string name, Node parent)
    {
        Name = name;
        Parent = parent;
        if (Parent != null) // Rebuild path
        {
            parent._children.Add(this);
            Path = parent.Name + "." + Name;
        }
        else
        {
            Path = Name;
        }
        _children = new List<Node>();
    }

进行这些更改后，序列化字符串如下所示：

{
  "$id": "1",
  "Root": {
    "$id": "2",
    "Children": [
      {
        "$id": "3",
        "Children": [],
        "Parent": {
          "$ref": "2"
        },
        "Name": "childName"
      }
    ],
    "Parent": null,
    "Name": "rootName"
  }
}

这个 Json 字符串包含足够的信息来首先创建根，然后是子。但是 JsonConverter 仍然从叶子开始。如何更改订单？

我知道我可以使用OnDeserialized，但这是我最后的选择。

Answer 1

我认为部分问题在于您尝试使用带有PerserveReferencesHandling.Objects 的参数化构造函数，而documented 不起作用：

注意：
当通过非默认构造函数设置值时，无法保留引用。对于非默认构造函数，必须在父值之前创建子值，以便将它们传递给构造函数，从而无法跟踪引用。 ISerializable 类型是一个类的示例，其值使用非默认构造函数填充，不适用于 PreserveReferencesHandling。

我会这样做：

1. 从私有[JsonConstructor] 中删除参数，并使该构造函数简单地将子项初始化为一个空列表。

   [JsonConstructor]
   private Node()
   {
       _children = new List<Node>();
   }
   

2. 为Name 和Parent 添加私有设置器并用[JsonProperty] 标记它们，以便Json.Net 可以使用私有设置器：

   [JsonProperty]  // allow Json.Net to use private setter
   public Node Parent { get; private set; }
   
   [JsonProperty]  // allow Json.Net to use private setter
   public string Name { get; private set; }
   

3. 不要将Path 存储在您的对象中；而是按需计算。这只是一行代码，而且速度很快，因为它向上链。

   [JsonIgnore]
   public string Path
   {
       get { return Parent != null ? Parent.Path + "." + Name : Name; }
   }
   

4. （可选，但推荐）让你的AddChild 方法返回它创建的Node——这将使它在创建树时更容易使用。否则，您总是必须搜索子节点列表才能找到刚刚添加的节点。

   public Node AddChild(string name)
   {
       Node node = new Node(this, name);
       _children.Add(node);
       return node;
   }
   

这是您的班级在进行所有更改后的样子：

class Node
{
    public IReadOnlyList<Node> Children => _children;

    [JsonIgnore]
    public string Path
    {
        get { return Parent != null ? Parent.Path + "." + Name : Name; }
    }

    [JsonProperty]  // allow Json.Net to use private setter
    public Node Parent { get; private set; }

    [JsonProperty]  // allow Json.Net to use private setter
    public string Name { get; private set; }

    public Node(Node parent, string name)
    {
        Name = name;
        Parent = parent;
        _children = new List<Node>();
    }

    [JsonConstructor]
    private Node()
    {
        _children = new List<Node>();
    }

    public Node AddChild(string name)
    {
        Node node = new Node(this, name);
        _children.Add(node);
        return node;
    }

    private readonly List<Node> _children;
}

---

如果即时计算Path 过于昂贵，您可以尝试以下想法：

1. 使用惰性求值。第一次访问时计算路径，然后将结果缓存到本地，方便后续检索：

    private string _path;
   
    [JsonIgnore]
    public string Path
    {
        get 
        { 
            if (_path == null)
            {
                _path = Parent != null ? Parent.Path + "." + Name : Name;
            }
            return _path; 
        }
    }
   

2. 反序列化后立即遍历树并为每个节点请求Path，强制计算并缓存它。然后会为每个节点缓存。

    void PrecachePaths(Node node)
    {
        var path = node.Path;
        foreach (Node child in node.Children)
        {
            PrecachePaths(child);
        }
    }
   
    var treeRestored = JsonConvert.DeserializeObject<Tree>(str);
    PrecachePaths(treeRestored.Root);