How to ignore empty object literals in the produced JSON?

Question

I'm using Json.NET to convert a complex C# object graph to JSON. Due to ignoring properties which have default values in the object, I usually get empty object literals in the output, which I'd like to omit.

For example:

public class Sample {
  public int Value { get; set; }
  public string Name { get; set; }
}

public class ParentSample {
  // this property should never be null, hence the initializer
  public Sample Sample { get; } = new Sample();
}

..

var obj = new ParentSample();
// settings for indentation and excluding default values omitted for clarity
var output = JsonConvert.SerializeObject(obj, ... );
// output will be 
// {
//   Sample: {}
// }
//
// I'd like it to be 
// {}

I'm aware of some type specific solutions like adding a ShouldSerializeSample boolean method to the ParentSample type and check if all properties are default there. However I'd like a general solution in the form of a custom contract resolver for example.

Answer 1

In the comments it looks like you have decided to resort to using Regex to get rid of the empty objects. One problem with that idea is it probably will not handle the situation where you have what I will call "recursive empty objects". In other words something like this:

{
    "foo":
    {
        "bar": {},
        "baz": {}
    }
}

If you manage to remove the deepest level empty objects bar and baz with Regex (while also realizing that you need to remove the comma between them to keep the JSON valid), you will still have an empty object left: foo.

{
    "foo":
    {
    }
}

I think a better solution is to load your data into a JToken hierarchy and then use a recursive method to remove all the empty children before writing it out to JSON. Something like this should work for your needs:

using System;
using Newtonsoft.Json.Linq;

public static class JsonHelper
{
    public static string SerializeToMinimalJson(object obj)
    {
        return JToken.FromObject(obj).RemoveEmptyChildren().ToString();
    }

    public static JToken RemoveEmptyChildren(this JToken token)
    {
        if (token.Type == JTokenType.Object)
        {
            JObject copy = new JObject();
            foreach (JProperty prop in token.Children<JProperty>())
            {
                JToken child = prop.Value;
                if (child.HasValues)
                {
                    child = child.RemoveEmptyChildren();
                }
                if (!child.IsEmptyOrDefault())
                {
                    copy.Add(prop.Name, child);
                }
            }
            return copy;
        }
        else if (token.Type == JTokenType.Array)
        {
            JArray copy = new JArray();
            foreach (JToken item in token.Children())
            {
                JToken child = item;
                if (child.HasValues)
                {
                    child = child.RemoveEmptyChildren();
                }
                if (!child.IsEmptyOrDefault())
                {
                    copy.Add(child);
                }
            }
            return copy;
        }
        return token;
    }

    public static bool IsEmptyOrDefault(this JToken token)
    {
        return (token.Type == JTokenType.Array && !token.HasValues) ||
               (token.Type == JTokenType.Object && !token.HasValues) ||
               (token.Type == JTokenType.String && token.ToString() == String.Empty) ||
               (token.Type == JTokenType.Boolean && token.Value<bool>() == false) ||
               (token.Type == JTokenType.Integer && token.Value<int>() == 0) ||
               (token.Type == JTokenType.Float && token.Value<double>() == 0.0) || 
               (token.Type == JTokenType.Null);
    }

}

You can then serialize your object(s) like this:

var json = JsonHelper.SerializeToMinimalJson(obj);

Fiddle: https://dotnetfiddle.net/awRPMR

EDIT

If you want to honor the [DefaultValue] attribute with this method, you can do so by modifying the SerializeToMinimalJson() method to create an instance of the JsonSerializer, setting the DefaultValueHandling property on it, and then passing it to JToken.FromObject() as shown below. (It has to be done this way because JTokens do not have references back to the original objects from which they were created using FromObject(), so there's no way to get the values of the [DefaultValue] attributes after that.)

public static string SerializeToMinimalJson(object obj)
{
    var serializer = new JsonSerializer();
    serializer.NullValueHandling = NullValueHandling.Ignore;
    serializer.DefaultValueHandling = DefaultValueHandling.Ignore;
    return JToken.FromObject(obj, serializer).RemoveEmptyChildren().ToString();
}

If you do that, you may also want to change the IsEmptyOrDefault() method so that it does not remove values that are the "default default". You can reduce it to this:

public static bool IsEmptyOrDefault(this JToken token)
{
    return (token.Type == JTokenType.Array && !token.HasValues) ||
           (token.Type == JTokenType.Object && !token.HasValues);
}

Fiddle: https://dotnetfiddle.net/0yVRI5

Answer 2

You can give a JsonSerializerSettings to the method using NullValueHandling.Ignore:

var output = JsonConvert.SerializeObject(obj, new JsonSerializerSettings
{
    NullValueHandling = NullValueHandling.Ignore
});

If this settings doesn't give what you need, check: the documentation. There you can find all the properties and a description.

Edit: Using the child (Sample) as struct it works with DefaultValueHandling.Ignore. But @Zoltán Tamási will use a regex due to the class complexity.

Answer 3

I implemented a slightly different solution which uses a generic method, reflection and some default Newtonsoft.Json ShouldSerialize functionality. Not elegant but conceptually simple for my particular need. Below is the LinqPad code snippet.

void Main()
{
    Person person = new Person();
    person.MyAddress = new Address();
    var ret = person.ShouldSerializeMyAddress();

    var json = JsonConvert.SerializeObject(person, Newtonsoft.Json.Formatting.Indented, new JsonSerializerSettings
    {
        NullValueHandling = NullValueHandling.Ignore
    });
    json.Dump();    
}

public static class JsonExtensions
{
    public static bool ShouldSerialize(this object self)
    {
        if (self == null)
            return false;

        var methods = self.GetType().GetMethods().Where(p => p.Name.StartsWith("ShouldSerialize"));
        return methods.Any(p => p.Invoke(self, null) is bool value && value);
    }
}

public class Person
{   
    public Address MyAddress { get; set; }  
    public bool ShouldSerializeMyAddress()
    {
        return MyAddress.ShouldSerialize();         
    }
}

public class Address
{
    public string Street { get; set; }
    public bool ShouldSerializeStreet()
    {
        return false;  // or whatever your property serialization criteria should be
    }
    public string City { get; set; }
    public bool ShouldSerializeCity()
    {
        return false;
    }
    public string State { get; set; }
    public bool ShouldSerializeState()
    {
        return false;
    }
    public string Zip { get; set; }
    public bool ShouldSerializeZip()
    {
        return false;
    }
}