Can JavaScriptSerializer exclude properties with null/default values?

Question

I'm using JavaScriptSerializer to serialize some entity objects.

The problem is, many of the public properties contain null or default values. Is there any way to make JavaScriptSerializer exclude properties with null or default values?

I would like the resulting JSON to be less verbose.

Feign

Answer 1

The solution that worked for me:

The serialized class and properties would be decorated as follows:

[DataContract]
public class MyDataClass
{
  [DataMember(Name = "LabelInJson", IsRequired = false)]
  public string MyProperty { get; set; }
}

IsRequired was the key item.

The actual serialization could be done using DataContractJsonSerializer:

public static string Serialize<T>(T obj)
{
  string returnVal = "";
  try
  {
    DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
    using (MemoryStream ms = new MemoryStream())
    {
      serializer.WriteObject(ms, obj);
      returnVal = Encoding.Default.GetString(ms.ToArray());
    }
  }
  catch (Exception /*exception*/)
  {
    returnVal = "";
    //log error
  }
  return returnVal;
}

Feign

For the DataContractJsonSerializer you need to set EmitDefaultValue to false on the DataMember – Celebrate

this seems interesing but needs more explanation, specially the first code – Skolnik

Answer 2

FYI, if you'd like to go with the easier solution, here's what I used to accomplish this using a JavaScriptConverter implementation with the JavaScriptSerializer:

private class NullPropertiesConverter: JavaScriptConverter {
 public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer) {
  throw new NotImplementedException();
 }

 public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer) {
  var jsonExample = new Dictionary<string, object >();
  foreach(var prop in obj.GetType().GetProperties()) {
   //check if decorated with ScriptIgnore attribute
   bool ignoreProp = prop.IsDefined(typeof(ScriptIgnoreAttribute), true);

   var value = prop.GetValue(obj, BindingFlags.Public, null, null, null);
   if (value != null && !ignoreProp)
    jsonExample.Add(prop.Name, value);
  }

  return jsonExample;
 }

 public override IEnumerable<Type> SupportedTypes {
  get {
   return GetType().Assembly.GetTypes();
  }
 }
}

and then to use it:

var serializer = new JavaScriptSerializer();
serializer.RegisterConverters(new JavaScriptConverter[] {
  new NullPropertiesConverter()
});
return serializer.Serialize(someObjectToSerialize);

Motorize

Should point out that if you want fields as well the code is missing it – Tillman

If you wondered what the previous comment was talking about: #295604 – Appetency

You could also make this slightly faster by checking the ignoreProp first and not getting the value unless it is false. – Eshelman

Great solution! If you are not getting any results, remember to have {get;set;} on your object properties for reflection to return them in GetProperties(), – Jasminjasmina

Answer 3

For the benefit of those who find this on google, note that nulls can be skipped natively during serialization with Newtonsoft.Json

var json = JsonConvert.SerializeObject(
            objectToSerialize,
            new JsonSerializerSettings {NullValueHandling = NullValueHandling.Ignore});

Barbaresi

Answer 4

You can implement a JavaScriptConverter and register it using the RegisterConverters method of JavaScriptSerializer.

Veliavelick

Answer 5

Json.NET has options to automatically exclude null or default values.

Jodyjoe

OP was asking about JavaScriptSerializer, not json.net. – Clavier

@JustinR. looks like he is the author of Json.NET and that's probably why – Sanguinolent

Answer 6

This code is block null and default(0) values for numeric types

private class NullPropertiesConverter: JavaScriptConverter {
 public override object Deserialize(IDictionary < string, object > dictionary, Type type, JavaScriptSerializer serializer) {
  throw new NotImplementedException();
 }

 public override IDictionary < string, object > Serialize(object obj, JavaScriptSerializer serializer) {
  var jsonExample = new Dictionary < string,
   object > ();
  foreach(var prop in obj.GetType().GetProperties()) {
   //this object is nullable 
   var nullableobj = prop.PropertyType.IsGenericType && prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable < > );
   //check if decorated with ScriptIgnore attribute
   bool ignoreProp = prop.IsDefined(typeof(ScriptIgnoreAttribute), true);

   var value = prop.GetValue(obj, System.Reflection.BindingFlags.Public, null, null, null);
   int i;
   //Object is not nullable and value=0 , it is a default value for numeric types 
   if (!(nullableobj == false && value != null && (int.TryParse(value.ToString(), out i) ? i : 1) == 0) && value != null && !ignoreProp)
    jsonExample.Add(prop.Name, value);
  }

  return jsonExample;
 }

 public override IEnumerable < Type > SupportedTypes {
  get {
   return GetType().Assembly.GetTypes();
  }
 }
}

Nephritis

Answer 7

Without changing toe DataContractSerializer

You can use ScriptIgnoreAttribute

[1] http://msdn.microsoft.com/en-us/library/system.web.script.serialization.scriptignoreattribute.aspx

Destinydestitute

ScriptIgnore is useful if you want to always ignore a property, but not if you want to only ignore properties with null values but include them if they have a real value. – Bagdad