Conditional DataContract Serialization in WebApi

Question

I am trying to find the best way to conditionally include and remove properties from my datacontract serialization in my .net WebApi project. In my Api, I want to allow users to specify the fields that they want returned.

For example, assume I want my API to return an instance of the following class.

public class Car
{
    public int Id { get; set; }
    public string Year { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }
    public string Color { get; set; }
}

But instead of requesting the entire object, the API call wants the Id and Make field only. So the return JSON would be

 { "Id": 12345, "Make": "Ford"}

instead of the entire object.

Is there a way with the DataContract Serializer that I can conditionally add and remove properties from my return object?

**EDIT I have looked at the IgnoreDefault property, and I don't believe it will do exactly what I need. The problem is that I want to include and exclude properties based on an api request, not necessarily on whether or not they have data.

Is there some way to hook into the deserialization process and skip certain properties? Can I do some kind of custom contract?

Elnora

Answer 1

If you're using the DataContractSerializer (or, in this case, the DataContractJsonSerializer), you can use the DataMember(EmitDefaultValue = false)] decoration in your class. This way, you can set the properties which you don't want serialized to their default values (i.e., null for strings, 0 for ints and so on), and they won't be.

If you're using the ASP.NET Web API, then you should be aware that the default JSON serializer isn't the DataContractJsonSerializer (DCJS), but JSON.NET instead. So unless you explicitly configure your JsonMediaTypeFormatter to use DCJS, you need another attribute to get the same behavior (JsonProperty, and its DefaultValueHandling property).

The code below only serializes the two members which were assigned in this Car object, using both serializers. Notice that you can remove one of the attributes if you're only going to use one of them.

public class StackOverflow_12465285
{
    [DataContract]
    public class Car
    {
        private int savedId;
        private string savedYear;
        private string savedMake;
        private string savedModel;
        private string savedColor;

        [DataMember(EmitDefaultValue = false)]
        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
        public int Id { get; set; }
        [DataMember(EmitDefaultValue = false)]
        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
        public string Year { get; set; }
        [DataMember(EmitDefaultValue = false)]
        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
        public string Make { get; set; }
        [DataMember(EmitDefaultValue = false)]
        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
        public string Model { get; set; }
        [DataMember(EmitDefaultValue = false)]
        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
        public string Color { get; set; }

        [OnSerializing]
        void OnSerializing(StreamingContext ctx)
        {
            this.savedId = this.Id;
            this.savedYear = this.Year;
            this.savedMake = this.Make;
            this.savedModel = this.Model;
            this.savedColor = this.Color;

            // Logic to determine which ones to serialize, let's say I only want Id, Make; so make all others default.
            this.Color = default(string);
            this.Model = default(string);
            this.Year = default(string);
        }

        [OnSerialized]
        void OnSerialized(StreamingContext ctx)
        {
            this.Id = this.savedId;
            this.Year = this.savedYear;
            this.Make = this.savedMake;
            this.Model = this.savedModel;
            this.Color = this.savedColor;
        }
    }

    public static void Test()
    {
        Car car = new Car { Id = 12345, Make = "Ford", Model = "Focus", Color = "Red", Year = "2010" };
        JsonSerializer js = new JsonSerializer();
        StringBuilder sb = new StringBuilder();
        StringWriter sw = new StringWriter(sb);
        js.Serialize(sw, car);
        Console.WriteLine("Using JSON.NET: {0}", sb.ToString());

        MemoryStream ms = new MemoryStream();
        DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(Car));
        dcjs.WriteObject(ms, car);
        Console.WriteLine("Using DCJS: {0}", Encoding.UTF8.GetString(ms.ToArray()));
    }
}

Gyniatrics

This will not really work for me. I need to be able to hook in at serialization time and exclude properties. I have looked into implementing ISerializable and GetObjectData but I am not yet sure if it is compatible with the Json.net or DataContract serializer. Any other ideas? – Elnora

There are a few things you can do. One is to simply have a custom JsonConverter for your class, and that way you'll control exactly how it's converterd to/from JSON - but it's a lot of work. Another way would be to use the serialization callbacks (supported by both DCJS and JSON.NET) to make the values which you don't want to serialize their default values. I've updated the answer with this option as well. – Gyniatrics

That works, except if I actually want to display a default value. For example, if I have an int property and its real value is 0. I don't want to exclude based on value. I have got a working example using JSON.Net by writing a CustomContractResolver. All I am looking for now is a way to do something similar using DataContract Serialization for the XML version. – Elnora

In this case, you can go with the JsonConverter. You'll need to write some code, but at that point you have total control over what goes on the wire. – Gyniatrics