Feature Request: Obey MaxDepth in SerializeObject()

It would be helpful if MaxDepth worked on SerializeObject() as well, not just Deserialize().

Currently, you can use MaxDepth to stop the serializer from deserializing anything past a given depth on the initial object(s). But, you can’t currently tell it to only serialize down to a certain depth.

Additionally, it appears that the normal behavior of MaxDepth is to throw an exception, which is not desirable. It would help if there was a way to tell it to simply serialize/deserialize down to MaxDepth and stop. An exception is undesirable behavior in many circumstances.

A good example of where this is useful is on an Entity Framework database with LazyLoading enabled and virtual properties throughout. SerializeObject(user, new JsonSerializerSettings { MaxDepth = 0 }); would be useful for containing JSON serialization to just the user and their FK Ids. Without MaxDepth, JsonConvert is going to dutifully serialize most or all of the entire database.

I’m happy to write this feature if people are interested in it.

[PaulDMendoza]

How is this not fixed? Everyone who has set this expects a certain behavior and isn’t getting it.

[Mike-Logit]

did you find any work around for this issue.

Yes but it’s not pretty. I had to create my own JsonConverter and pass it to JsonConvert.SerializeObject.

For my use case, I wanted to log the contents of an object that contained data for executing a command or query, which I called the “Request” object:

var rawRequest = JsonConvert.SerializeObject(request, Formatting.None, new RequestJsonConverter(2));

And this is my RequestJsonConverter class:

private class RequestJsonConverter : JsonConverter
{
    private readonly int _depth;

    public RequestJsonConverter(int depth)
    {
        _depth = depth;
    }

    public override bool CanRead => false;

    public override bool CanConvert(Type objectType) => true;

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var jObject = new JObject();
        var requestProperties = value.GetType().GetProperties();
        RequestJsonConverter nextConverter = null;

        foreach (var prop in requestProperties)
        {
            if (_depth <= 0)
            {
                continue;
            }

            try
            {
                var propValue = prop.GetValue(value);
                if (!prop.PropertyType.IsPrimitive &&
                    !prop.PropertyType.IsValueType &&
                    prop.PropertyType != typeof(string))
                {
                    if (propValue is null || _depth <= 1)
                    {
                        continue;
                    }

                    nextConverter ??= new RequestJsonConverter(_depth - 1);
                    var serializedPropValue = JsonConvert.SerializeObject(propValue, Formatting.None, nextConverter);
                    jObject.Add(prop.Name, serializedPropValue);
                }
                else
                {
                    jObject.Add(prop.Name, propValue.ToSafeString());
                }
            }
            catch
            {
                // ignored - property getter might have thrown an exception so skip it.
            }
        }

        jObject.WriteTo(writer);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        => throw new NotImplementedException("Unsupported");
}