JSON.Net 使用 [JsonConvert()] 时抛出 StackOverflowException

Question

我写了这个简单的代码来序列化类 as flatten，但是当我使用 [JsonConverter(typeof(FJson))] 注释时，它抛出一个 WhosebugException。如果我手动调用 SerializeObject，它工作正常。

如何在注释模式下使用 JsonConvert：

class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            a.id = 1;
            a.b.name = "value";

            string json = null;

            // json = JsonConvert.SerializeObject(a, new FJson()); without [JsonConverter(typeof(FJson))] annotation workd fine
            // json = JsonConvert.SerializeObject(a); WhosebugException

            Console.WriteLine(json);
            Console.ReadLine();
        }
    }

    //[JsonConverter(typeof(FJson))] WhosebugException
    public class A
    {
        public A()
        {
            this.b = new B();
        }

        public int id { get; set; }
        public string name { get; set; }
        public B b { get; set; }
    }

    public class B
    {
        public string name { get; set; }
    }

    public class FJson : JsonConverter
    {
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            JToken t = JToken.FromObject(value);
            if (t.Type != JTokenType.Object)
            {
                t.WriteTo(writer);
                return;
            }

            JObject o = (JObject)t;
            writer.WriteStartObject();
            WriteJson(writer, o);
            writer.WriteEndObject();
        }

        private void WriteJson(JsonWriter writer, JObject value)
        {
            foreach (var p in value.Properties())
            {
                if (p.Value is JObject)
                    WriteJson(writer, (JObject)p.Value);
                else
                    p.WriteTo(writer);
            }
        }

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

        public override bool CanConvert(Type objectType)
        {
            return true; // works for any type
        }
    }

Answer 1

通过将属性放在 class A 上，它被递归调用。 WriteJson override 中的第一行再次调用 class A 上的序列化器。

JToken t = JToken.FromObject(value);

这会导致递归调用，从而导致 WhosebugException。

从你的代码来看，我认为你试图扁平化层次结构。您可以通过将转换器属性放在属性 B 上来实现这一点，这将避免递归。

//remove the converter from here
public class A
{
    public A()
    {
        this.b = new B();
    }

    public int id { get; set; }
    public string name { get; set; }
    [JsonConverter(typeof(FJson))] 
    public B b { get; set; }
}

警告：您到达此处的 Json 将有两个名为“name”的键，一个来自 class A，另一个来自 class B.

Answer 2

Json.NET 没有对调用 JToken.FromObject 生成“默认”序列化然后修改生成的 JToken 输出的转换器的方便支持 - 正是因为 WhosebugException 由于您观察到的对 JsonConverter.WriteJson() 的递归调用将会发生。

一种解决方法 是使用线程静态布尔值在递归调用中暂时禁用转换器。使用线程静态是因为在某些情况下，包括 asp.net-web-api，JSON 转换器的实例将在线程之间共享。在这种情况下，通过实例禁用转换器属性将不是线程安全的。

public class FJson : JsonConverter
{
    [ThreadStatic]
    static bool disabled;

    // Disables the converter in a thread-safe manner.
    bool Disabled { get { return disabled; } set { disabled = value; } }

    public override bool CanWrite { get { return !Disabled; } }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        JToken t;
        using (new PushValue<bool>(true, () => Disabled, (canWrite) => Disabled = canWrite))
        {
            t = JToken.FromObject(value, serializer);
        }

        if (t.Type != JTokenType.Object)
        {
            t.WriteTo(writer);
            return;
        }

        JObject o = (JObject)t;
        writer.WriteStartObject();
        WriteJson(writer, o);
        writer.WriteEndObject();
    }

    private void WriteJson(JsonWriter writer, JObject value)
    {
        foreach (var p in value.Properties())
        {
            if (p.Value is JObject)
                WriteJson(writer, (JObject)p.Value);
            else
                p.WriteTo(writer);
        }
    }

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

    public override bool CanConvert(Type objectType)
    {
        return true; // works for any type
    }
}

public struct PushValue<T> : IDisposable
{
    Action<T> setValue;
    T oldValue;

    public PushValue(T value, Func<T> getValue, Action<T> setValue)
    {
        if (getValue == null || setValue == null)
            throw new ArgumentNullException();
        this.setValue = setValue;
        this.oldValue = getValue();
        setValue(value);
    }

    #region IDisposable Members

    // By using a disposable struct we avoid the overhead of allocating and freeing an instance of a finalizable class.
    public void Dispose()
    {
        if (setValue != null)
            setValue(oldValue);
    }

    #endregion
}

完成此操作后，您可以将 [JsonConverter(typeof(FJson))] 恢复到您的 class A:

[JsonConverter(typeof(FJson))]
public class A
{
}

演示 fiddle #1 here.

第二种更简单的解决方法 为应用了 JsonConverter 的类型生成默认 JToken 表示利用了一个事实，即转换器应用于member 取代应用于 type 或设置中的转换器。来自 docs:

The priority of which JsonConverter is used is the JsonConverter defined by attribute on a member, then the JsonConverter defined by an attribute on a class, and finally any converters passed to the JsonSerializer.

因此，可以通过将它嵌套在 DTO with a single member whose value is an instance of your type and has a applied 中来为您的类型生成默认序列化，它除了退回到读写的默认序列化之外什么都不做。

以下扩展方法和转换器完成工作：

public static partial class JsonExtensions
{
    public static JToken DefaultFromObject(this JsonSerializer serializer, object value)
    {
        if (value == null)
            return JValue.CreateNull();
        var dto = Activator.CreateInstance(typeof(DefaultSerializationDTO<>).MakeGenericType(value.GetType()), value);
        var root = JObject.FromObject(dto, serializer);
        return root["Value"].RemoveFromLowestPossibleParent() ?? JValue.CreateNull();
    }

    public static object DefaultToObject(this JToken token, Type type, JsonSerializer serializer = null)
    {
        var oldParent = token.Parent;
    
        var dtoToken = new JObject(new JProperty("Value", token));
        var dtoType = typeof(DefaultSerializationDTO<>).MakeGenericType(type);
        var dto = (IHasValue)(serializer ?? JsonSerializer.CreateDefault()).Deserialize(dtoToken.CreateReader(), dtoType);
        
        if (oldParent == null)
            token.RemoveFromLowestPossibleParent();
            
        return dto == null ? null : dto.GetValue();
    }
    
    public static JToken RemoveFromLowestPossibleParent(this JToken node)
    {
        if (node == null)
            return null;
        // If the parent is a JProperty, remove that instead of the token itself.
        var contained = node.Parent is JProperty ? node.Parent : node;
        contained.Remove();
        // Also detach the node from its immediate containing property -- Remove() does not do this even though it seems like it should
        if (contained is JProperty)
            ((JProperty)node.Parent).Value = null;
        return node;
    }
    
    interface IHasValue
    {
        object GetValue();
    }

    [JsonObject(NamingStrategyType = typeof(DefaultNamingStrategy), IsReference = false)]
    class DefaultSerializationDTO<T> : IHasValue
    {
        public DefaultSerializationDTO(T value) { this.Value = value; }

        public DefaultSerializationDTO() { }
        
        [JsonConverter(typeof(NoConverter)), JsonProperty(ReferenceLoopHandling = ReferenceLoopHandling.Serialize)]
        public T Value { get; set; }
        
        object IHasValue.GetValue() { return Value; }
    }
}

public class NoConverter : JsonConverter
{
    // NoConverter taken from this answer 
    // To 
    // By https://whosebug.com/users/3744182/dbc
    public override bool CanConvert(Type objectType)  { throw new NotImplementedException(); /* This converter should only be applied via attributes */ }

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

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

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

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { throw new NotImplementedException(); }
}

然后在FJson.WriteJson()中使用如下：

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

    // Remainder as before
    if (t.Type != JTokenType.Object)
    {
        t.WriteTo(writer);
        return;
    }

    JObject o = (JObject)t;
    writer.WriteStartObject();
    WriteJson(writer, o);
    writer.WriteEndObject();
}

这种方法的优点和缺点是：

它不依赖于递归禁用转换器，因此可以正确处理递归数据模型。
不需要重新实现从对象的属性序列化对象的整个逻辑。
它序列化和反序列化中间的 JToken 表示。当尝试将默认序列化直接传入和传出传入的 JsonReader 或 JsonWriter.
时，它不适合使用

演示 fiddle #2 here.

备注

两个转换器版本都只处理写入；阅读未实现。

要解决 de 序列化期间的等效问题，请参见例如.
您编写的转换器创建 JSON 具有重复的名称：
```
{
  "id": 1,
  "name": null,
  "name": "value"
}
```
这虽然不是严格意义上的非法，但通常被认为是 bad practice，因此应该避免。

Answer 3

我不喜欢上面发布的解决方案，所以我研究了序列化程序如何实际序列化对象并尝试将其提炼到最低限度：

public override void WriteJson( JsonWriter writer, object value, JsonSerializer serializer )
{
   JsonObjectContract contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract( value.GetType() );

   writer.WriteStartObject();
   foreach ( var property in contract.Properties )
   {
      writer.WritePropertyName( property.PropertyName );
      writer.WriteValue( property.ValueProvider.GetValue(value));
   }
   writer.WriteEndObject();
}

没有堆栈溢出问题，也不需要递归禁用标志。

Answer 4

我还不能发表评论，对此深感抱歉...但我只是想对 Paul Kiar 提供的解决方案添加一些内容。他的解决方案真的帮助了我。

Paul 的代码很短，无需任何自定义对象构建即可运行。我想做的唯一补充是插入检查属性是否被忽略。如果将其设置为忽略，则跳过属性:

的写入

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        JsonObjectContract contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(value.GetType());

        writer.WriteStartObject();
        foreach (var property in contract.Properties)
        {
            if (property.Ignored)
                continue;

            writer.WritePropertyName(property.PropertyName);
            writer.WriteValue(property.ValueProvider.GetValue(value));
        }
        writer.WriteEndObject();
    }

Answer 5

阅读（和测试）Paul Kiar 和 p.kaneman 解决方案后，我认为实施 WriteJson 似乎是一项具有挑战性的任务。尽管它适用于大多数情况——但仍有一些边缘情况尚未涵盖。示例：

public bool ShouldSerialize*() 方法
null 值
值类型 (struct)
json 转换器属性
..

这是（只是）另一个尝试：

public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) {
    if (ReferenceEquals(value, null)) {
        writer.WriteNull();
        return;
    }

    var contract = (JsonObjectContract)serializer
        .ContractResolver
        .ResolveContract(value.GetType());

    writer.WriteStartObject();

    foreach (var property in contract.Properties) {
        if (property.Ignored) continue;
        if (!ShouldSerialize(property, value)) continue;

        var property_name = property.PropertyName;
        var property_value = property.ValueProvider.GetValue(value);

        writer.WritePropertyName(property_name);
        if (property.Converter != null && property.Converter.CanWrite) {
            property.Converter.WriteJson(writer, property_value, serializer);
        } else {
            serializer.Serialize(writer, property_value);
        }
    }

    writer.WriteEndObject();
}

private static bool ShouldSerialize(JsonProperty property, object instance) {
    return property.ShouldSerialize == null 
        || property.ShouldSerialize(instance);
}

JSON.Net 使用 [JsonConvert()] 时抛出 StackOverflowException

JSON.Net throws StackOverflowException when using [JsonConvert()]

c#

serialization

json

json.net