Can Newtonsoft Json.NET skip serializing empty lists?

I am trying to serialize some legacy objects that "lazy creates" various lists. I can not change the legacy behavior.

I have boiled it down to this simple example:

public class Junk
{
    protected int _id;

    [JsonProperty( PropertyName = "Identity" )]
    public int ID 
    { 
        get
        {
            return _id;
        }

        set
        {
            _id = value;
        }
    }

    protected List<int> _numbers;
    public List<int> Numbers
    {
        get
        {
            if( null == _numbers )
            {
                _numbers = new List<int>( );
            }

            return _numbers;
        }

        set
        {
            _numbers = value;
        }
    }
}

class Program
{
    static void Main( string[] args )
    {
        Junk j = new Junk( ) { ID = 123 };

        string newtonSoftJson = JsonConvert.SerializeObject( j, Newtonsoft.Json.Formatting.Indented );

        Console.WriteLine( newtonSoftJson );

    }
}

The current results are: { "Identity": 123, "Numbers": [] }

I would like to get: { "Identity": 123 }

That is, I would like to skip any lists, collections, arrays, or such things that are empty.

In case you didn't find a solution to this, the answer is remarkably simple when you manage to track it down.

If you are permitted to extend the original class then add a ShouldSerializePropertyName function to it. This should return a Boolean indicating whether or not that property should be serialized for the current instance of the class. In your example this might look like this (not tested but you should get the picture):

public bool ShouldSerializeNumbers()
{
    return _numbers.Count > 0;
}

This approach works for me (albeit in VB.NET). If you're not allowed to modify the original class then the IContractResolver approach described on the the linked page is the way to go.

Regarding David Jones' suggestion to use IContractResolver, this works for me to cover all IEnumerables variations without explicitly modifying the class that needs to be serialized:

public class ShouldSerializeContractResolver : DefaultContractResolver
{
    public static readonly ShouldSerializeContractResolver Instance = new ShouldSerializeContractResolver();

		protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) {
			JsonProperty property = base.CreateProperty(member, memberSerialization);

			if (property.PropertyType != typeof(string)) {
				if (property.PropertyType.GetInterface(nameof(IEnumerable)) != null)
					property.ShouldSerialize =
						instance => (instance?.GetType().GetProperty(property.PropertyName).GetValue(instance) as IEnumerable<object>)?.Count() > 0;
			}
			return property;
		}
}

Then I build it into my settings object:

static JsonSerializerSettings JsonSettings = new JsonSerializerSettings
{
    Formatting = Formatting.Indented,
    NullValueHandling = NullValueHandling.Ignore,
    DefaultValueHandling = DefaultValueHandling.Ignore,
    ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
    ContractResolver = ShouldSerializeContractResolver.Instance,
};

and use it like this:

JsonConvert.SerializeObject(someObject, JsonSettings);

Bryan you are most the way there you don't need the overhead of the instance variable and you need to trap both field & member instances plus I would not run the count operation which requires the enumerable to exhaust the entire collection you can simply run the MoveNext() function.

public class IgnoreEmptyEnumerableResolver : CamelCasePropertyNamesContractResolver
{
	protected override JsonProperty CreateProperty(MemberInfo member,
		MemberSerialization memberSerialization)
	{
		var property = base.CreateProperty(member, memberSerialization);

		if (property.PropertyType != typeof(string) &&
			typeof(IEnumerable).IsAssignableFrom(property.PropertyType))
		{
			property.ShouldSerialize = instance =>
			{
				IEnumerable enumerable = null;
				// this value could be in a public field or public property
				switch (member.MemberType)
				{
					case MemberTypes.Property:
						enumerable = instance
							.GetType()
							.GetProperty(member.Name)
							?.GetValue(instance, null) as IEnumerable;
						break;
					case MemberTypes.Field:
						enumerable = instance
							.GetType()
							.GetField(member.Name)
							.GetValue(instance) as IEnumerable;
						break;
				}

				return enumerable == null ||
					   enumerable.GetEnumerator().MoveNext();
				// if the list is null, we defer the decision to NullValueHandling
			};
		}

		return property;
	}
}

Just to be pendantic commonorgarden, I structured the if test to be:

public bool ShouldSerializecommunicationmethods()
{
    if (communicationmethods != null && communicationmethods.communicationmethod != null && communicationmethods.communicationmethod.Count > 0)
        return true;
    else
        return false;
}

As an empty list will often be null too. Thanks for posting the solution. ATB.