c# - 来自属性的 Json.Net 自定义序列化

Question

我已经很好地阅读了 json.net 上的文档，但我的想法已经用完了。我有一种情况，我的 child 提到了那里的 parent 。所以

public class ObjA
{
  public int Id {get;set}
  public string OtherStuff {get;set}
  public ObjB MyChild {get;set}
}

public class ObjB
{
  public int Id {get;set}
  public string OtherStuff {get;set}
  public ObjA MyParent {get;set}
}

这不会序列化。所以我可以做 [JsonIgnore]，但我宁愿做的是 [JsonIdOnly]，其中 ObjB，而不是序列化 MyParent 或跳过 MyParent 完全显示 MyParentId:123 的 json 属性。所以

{OjbA:{
    Id:123,
    OtherStuff:some other stuff,
    MyChild:{
        Id:456,
        OtherStuff:Some other stuff,
        MyParentId:123,
        }
    }
 }

我知道我可以为一个类型编写自定义转换器。问题是我希望只有在指定时才会发生这种情况，否则我将无法序列化 ObjA。换句话说，只有当我用属性装饰它时，我才需要它发生。所以

public class ObjB
{
  public int Id {get;set}
  public string OtherStuff {get;set}
  [JsonIdOnly]
  public ObjA MyParent {get;set}
}

Answer 1

如果您不关心您的 JSON 中有一些额外的簿记信息，则将 JsonSerializerSettings 中的 PreserveReferenceHandling 选项设置为 All (或 Objects)，正如@Athari 建议的那样。这是使其工作的最简单方法。如果这样做，您的 JSON 将如下所示:

{
  "$id": "1",
  "Id": 123,
  "OtherStuff": "other stuff A",
  "MyChild": {
    "$id": "2",
    "Id": 456,
    "OtherStuff": "other stuff B",
    "MyParent": {
      "$ref": "1"
    }
  }
}

也就是说，有一种方法可以使用自定义 JsonConverter 来完成您最初想要的操作。您可以做的是制作一个转换器，该转换器将接受任何具有 Id 属性的对象。然后，对于那些您希望它仅序列化为 Id 的地方，您可以使用 [JsonConverter] 属性修饰这些属性。自定义转换器将用于这些情况，但不会用于其他情况。转换器可能如下所示:

class IdOnlyConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType.IsClass;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        writer.WriteStartObject();
        writer.WritePropertyName("Id");
        writer.WriteValue(GetId(value));
        writer.WriteEndObject();
    }

    private int GetId(object obj)
    {
        PropertyInfo prop = obj.GetType().GetProperty("Id", typeof(int));
        if (prop != null && prop.CanRead)
        {
            return (int)prop.GetValue(obj, null);
        }
        return 0;
    }

    public override bool CanRead 
    { 
        get { return false; } 
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

要使用转换器，您需要按照概述的方式设置您的类。请注意 MyParent 是如何用属性修饰的，以告诉 Json.Net 使用该属性的自定义转换器。

public class ObjA
{
    public int Id { get; set; }
    public string OtherStuff { get; set; }
    public ObjB MyChild { get; set; }
}

public class ObjB
{
    public int Id { get; set; }
    public string OtherStuff { get; set; }
    [JsonConverter(typeof(IdOnlyConverter))]
    public ObjA MyParent { get; set; }
}

序列化时，您需要将 JsonSerializerSettings 的 ReferenceLoopHandling 选项设置为 Serialize 以告诉 Json.Net 在以下情况下不要抛出错误检测到引用循环，并继续序列化(因为我们的转换器将处理它)。

总而言之，下面是一些示例代码，演示了转换器的运行情况:

class Program
{
    static void Main(string[] args)
    {
        ObjA a = new ObjA();
        a.Id = 123;
        a.OtherStuff = "other stuff A";

        ObjB b = new ObjB();
        b.Id = 456;
        b.OtherStuff = "other stuff B";
        b.MyParent = a;

        a.MyChild = b;

        JsonSerializerSettings settings = new JsonSerializerSettings
        {
            ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize,
            Formatting = Newtonsoft.Json.Formatting.Indented
        };

        string json = JsonConvert.SerializeObject(a, settings);
        Console.WriteLine(json);
    }
}

这是上面的输出:

{
  "Id": 123,
  "OtherStuff": "other stuff A",
  "MyChild": {
    "Id": 456,
    "OtherStuff": "other stuff B",
    "MyParent": {
      "Id": 123
    }
  }
}