自定义 JsonConverter WriteJson 不会改变 Sub-properties 的序列化

Question

我一直觉得 JSON 序列化程序实际上遍历了整个 object 的树，并在每个 interface-typed object 上执行自定义 JsonConverter 的 WriteJson 函数它遇到了 - 不是这样。

我有以下 classes 和接口：

public interface IAnimal
{
    string Name { get; set; }
    string Speak();
    List<IAnimal> Children { get; set; }
}

public class Cat : IAnimal
{
    public string Name { get; set; }
    public List<IAnimal> Children { get; set; }        

    public Cat()
    {
        Children = new List<IAnimal>();
    }

    public Cat(string name="") : this()
    {
        Name = name;
    }

    public string Speak()
    {
        return "Meow";
    }       
}

 public class Dog : IAnimal
 {
    public string Name { get; set; }
    public List<IAnimal> Children { get; set; }

    public Dog()
    {
        Children = new List<IAnimal>();   
    }

    public Dog(string name="") : this()
    {
        Name = name;
    }

    public string Speak()
    {
        return "Arf";
    }

}

为了避免JSON中的$type属性，我写了一个自定义的JsonConverterclass，它的WriteJson是

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
    JToken t = JToken.FromObject(value);

    if (t.Type != JTokenType.Object)
    {
        t.WriteTo(writer);                
    }
    else
    {
        IAnimal animal = value as IAnimal;
        JObject o = (JObject)t;

        if (animal != null)
        {
            if (animal is Dog)
            {
                o.AddFirst(new JProperty("type", "Dog"));
                //o.Find
            }
            else if (animal is Cat)
            {
                o.AddFirst(new JProperty("type", "Cat"));
            }

            foreach(IAnimal childAnimal in animal.Children)
            {
                // ???
            }

            o.WriteTo(writer);
        }
    }
}

在这个例子中，是的，狗可以养猫 children 和 vice-versa。在转换器中，我想插入 "type" 属性以便将其保存到序列化中。我有以下设置。（Zoo 只有一个名称和一个 IAnimal 列表。出于简洁和懒惰的考虑，我没有在此处包括它；））

Zoo hardcodedZoo = new Zoo()
            {   Name = "My Zoo",               
                Animals = new List<IAnimal> { new Dog("Ruff"), new Cat("Cleo"),
                    new Dog("Rover"){
                        Children = new List<IAnimal>{ new Dog("Fido"), new Dog("Fluffy")}
                    } }
            };

            JsonSerializerSettings settings = new JsonSerializerSettings(){
                ContractResolver = new CamelCasePropertyNamesContractResolver() ,                    
                Formatting = Formatting.Indented
            };
            settings.Converters.Add(new AnimalsConverter());            

            string serializedHardCodedZoo = JsonConvert.SerializeObject(hardcodedZoo, settings);

serializedHardCodedZoo 序列化后输出如下：

{
  "name": "My Zoo",
  "animals": [
    {
      "type": "Dog",
      "Name": "Ruff",
      "Children": []
    },
    {
      "type": "Cat",
      "Name": "Cleo",
      "Children": []
    },
    {
      "type": "Dog",
      "Name": "Rover",
      "Children": [
        {
          "Name": "Fido",
          "Children": []
        },
        {
          "Name": "Fluffy",
          "Children": []
        }
      ]
    }
  ]
}

类型属性出现在 Ruff、Cleo 和 Rover 上，但不出现在 Fido 和 Fluffy 上。我想 WriteJson 不是递归调用的。我怎样才能得到那个类型属性呢？

顺便说一句，为什么它不像我期望的那样 camel-case IAnimals？

Answer 1

您的转换器未应用于您的子对象的原因是 JToken.FromObject() 在内部使用了序列化程序的新实例，它不知道您的转换器。有一个允许您传入序列化器的重载，但是如果您在这里这样做，您将遇到另一个问题：因为您在一个转换器中并且您正在使用 JToken.FromObject() 来尝试序列化父对象，您将进入无限递归循环。（JToken.FromObject() 调用序列化程序，后者调用您的转换器，后者调用 JToken.FromObject()，等等）

要解决此问题，您必须手动处理父对象。使用一些反射来枚举父属性，您可以毫不费力地做到这一点：

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
    JObject jo = new JObject();
    Type type = value.GetType();
    jo.Add("type", type.Name);

    foreach (PropertyInfo prop in type.GetProperties())
    {
        if (prop.CanRead)
        {
            object propVal = prop.GetValue(value, null);
            if (propVal != null)
            {
                jo.Add(prop.Name, JToken.FromObject(propVal, serializer));
            }
        }
    }
    jo.WriteTo(writer);
}

Fiddle: https://dotnetfiddle.net/sVWsE4

Answer 2

这里有一个想法，而不是对每个属性进行反射，遍历正常序列化的 JObject，然后更改您感兴趣的属性的标记。

这样您仍然可以利用所有“'JsonIgnore'”属性和其他有吸引力的内置功能。

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
    JToken jToken = JToken.FromObject(value);

    if (jToken.Type == JTokenType.Object)
    {
        JObject jObject = (JObject)jToken;
        ...
        AddRemoveSerializedProperties(jObject, val);
        ...
    }
    ...
}

然后

private void AddRemoveSerializedProperties(JObject jObject, MahMan baseContract)
   {
       jObject.AddFirst(....);

        foreach (KeyValuePair<string, JToken> propertyJToken in jObject)
        {
            if (propertyJToken.Value.Type != JTokenType.Object)
                continue;

            JToken nestedJObject = propertyJToken.Value;
            PropertyInfo clrProperty = baseContract.GetType().GetProperty(propertyJToken.Key);
            MahMan nestedObjectValue = clrProperty.GetValue(baseContract) as MahMan;
            if(nestedObj != null)
                AddRemoveSerializedProperties((JObject)nestedJObject, nestedObjectValue);
        }
    }

Answer 3

我在为父类型和子类型使用两个自定义转换器时遇到了这个问题。我发现一个更简单的方法是，由于 JToken.FromObject() 的重载将 serializer 作为参数，您可以传递在 WriteJson() 中提供的序列化程序。但是，您需要从序列化程序中删除您的转换器以避免对其进行递归调用（但在之后将其添加回来）：

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
    serializer.Converters.Remove(this);
    JToken jToken = JToken.FromObject(value, serializer);
    serializer.Converters.Add(this);

    // Perform any necessary conversions on the object returned
}

Answer 4

这里有一个解决您的问题的 hacky 解决方案，可以完成工作并且看起来很整洁。

public class MyJsonConverter : JsonConverter
{
    public const string TypePropertyName = "type";
    private bool _dormant = false;

    /// <summary>
    /// A hack is involved:
    ///     " JToken.FromObject(value, serializer); " creates amn infinite loop in normal circumstances
    ///     for that reason before calling it "_dormant = true;" is called.
    ///     the result is that this JsonConverter will reply false to exactly one "CanConvert()" call.
    ///     this gap will allow to generate a a basic version without any extra properties, and then add them on the call with " JToken.FromObject(value, serializer); ".
    /// </summary>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        _dormant = true;
        JToken t = JToken.FromObject(value, serializer);
        if (t.Type == JTokenType.Object && value is IContent)
        {
            JObject o = (JObject)t;
            o.AddFirst(new JProperty(TypePropertyName, value.GetType().Name));
            o.WriteTo(writer);
        }
        else
        {
            t.WriteTo(writer);
        }
    }

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

    public override bool CanRead => false;

    public override bool CanConvert(Type objectType)
    {
        if (_dormant)
        {
            _dormant = false;
            return false;
        }
        return true;
    }
}

自定义 JsonConverter WriteJson 不会改变 Sub-properties 的序列化

Custom JsonConverter WriteJson Does Not Alter Serialization of Sub-properties

c#

serialization

json

converter

json.net