26

I have some C# code using ASP.Net MVC, which is making use of Json.Net to serialize some DTOs. In order to reduce payload, I have made use of the [JsonProperty(PropertyName = "shortName")] attribute to use shorter property names during serialization.

This works great when the client is another .Net app or service, as the deserialization puts the object hierarchy back together, using the longer more friendly names, while keeping actual transfer payload low.

The problem comes into play when the client is javascript/ajax through a browser. It makes the request, and gets the json ... but that json is using the shortened less-friendly names.

How can I make the json.net serialization engine ignore the [JsonProperty(PropertyName = "shortName")] attribute programmatically? Ideally, my MVC service is going to sit there running and normally serialize using the shortened property names. When my code detects a particular parameter, I'd like to get the data serialized using the longer names and ignore the [JsonProperty()] attribute.

Any suggestions?

Thanks,

Kevin

Kevin
  • 271
  • 1
  • 3
  • 4
  • just remove the `JsonProperty` and return an anonymous object according to the parameter you passed. something like `new{UserName=uname}` – L.B Dec 16 '13 at 22:57
  • I think the best approach would be to make a custom serializer (with json.NET, not from scratch) and remove the annotations. Make short names vs long names a setting of the serializer and just tell it which you want at the time of serialization. json.NET has no support for using/ignoring annotations at run time. If they are there at compile time, they will be used (baring some major hacking). – evanmcdonnal Dec 16 '13 at 23:03
  • I appreciate the comments there. @evanmcdonnal: if we went with a custom serializer, would we need to do this on a DTO-specific level (attached to every DTO?) We have many DTOs spread accross many solutions through our many development teams. Ideally we could find a relatively elegant way to attach into the serialization process without having to touch and maintain this through all DTOs accross the board. – Kevin Dec 17 '13 at 14:36
  • This can be done using a custom contract resolver. See my answer below. – Brian Rogers Dec 17 '13 at 16:45
  • @Kevin that really depends, you could do it in a general way without making any changes to the DTO's. In my code base there is some abstraction on top of json.NET. If I were to do the same I would be making my changes at that level and I would do something in the serializer like get the property name using reflection then take a substring of that to get the short name. Of course there's the minor trade off of losing control over the short names, but it would be a simple general solution. – evanmcdonnal Dec 17 '13 at 17:46

2 Answers2

61

This can be done pretty easily using a custom contract resolver. Here's all the code you would need:

class LongNameContractResolver : DefaultContractResolver
{
    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        // Let the base class create all the JsonProperties 
        // using the short names
        IList<JsonProperty> list = base.CreateProperties(type, memberSerialization);

        // Now inspect each property and replace the 
        // short name with the real property name
        foreach (JsonProperty prop in list)
        {
            prop.PropertyName = prop.UnderlyingName;
        }

        return list;
    }
}

Here's a quick demo using the resolver:

class Program
{
    static void Main(string[] args)
    {
        Foo foo = new Foo
        {
            CustomerName = "Bubba Gump Shrimp Company",
            CustomerNumber = "BG60938"
        };

        Console.WriteLine("--- Using JsonProperty names ---");
        Console.WriteLine(Serialize(foo, false));
        Console.WriteLine();
        Console.WriteLine("--- Ignoring JsonProperty names ---");
        Console.WriteLine(Serialize(foo, true));
    }

    static string Serialize(object obj, bool useLongNames)
    {
        JsonSerializerSettings settings = new JsonSerializerSettings();
        settings.Formatting = Formatting.Indented;
        if (useLongNames)
        {
            settings.ContractResolver = new LongNameContractResolver();
        }

        return JsonConvert.SerializeObject(obj, settings);
    }
}

class Foo
{
    [JsonProperty("cust-num")]
    public string CustomerNumber { get; set; }
    [JsonProperty("cust-name")]
    public string CustomerName { get; set; }
}

Output:

--- Using JsonProperty names ---
{
  "cust-num": "BG60938",
  "cust-name": "Bubba Gump Shrimp Company"
}

--- Ignoring JsonProperty names ---
{
  "CustomerNumber": "BG60938",
  "CustomerName": "Bubba Gump Shrimp Company"
}
Brian Rogers
  • 118,414
  • 30
  • 277
  • 278
2

Just want to "extend" Brian's answer with Deserializer class,

static T Deserialize<T>(string json)
{
    return JsonConvert.DeserializeObject<T>(json, new JsonSerializerSettings()
    {
        ContractResolver = new LongNameContractResolver()
    });
}
Jawad
  • 10,548
  • 3
  • 22
  • 33