Deserialize two values into the same property

Question

I have a client which can call two different versions of a service.

One service only sends a single value:

{
  "value" : { ... }
}

The second service always returns multiple values:

{
  "values" : [ 
    { ... },
    { ... }
  ]
}

Ideally, I'd like to represent this with a single object in my client classes so the user never sees whether it's a single value or multiple values.

public class MyValues
{
  public List<Stuff> Values { get; set; }
  public Thing Other { get; set; }
}

I think that the only way I'll be able to accomplish this is with a custom JsonConverter class which I apply to MyValues, but I really only want to do something custom when I'm deserializing the property value. I can't seem to figure out if an IContractResolver would be a better way to go (e.g. somehow attach a phantom property to MyValues that deserializes value and puts it into Values.

If I create a custom converter, how to I tell it to deserialize everything else normally (e.g. if Other has an extra properties make sure they are handled appropriately, etc.)

You could write a converter and map to one or the other depending on what type it is. Similar problem: [Deserialize json property as bool or double](http://stackoverflow.com/q/39347858/1070452) — Ňɏssa Pøngjǣrdenlarp, Feb 01 '17 at 22:58

score 4 · Answer 1 · answered Feb 02 '17 at 15:17

Rather than writing a JsonConverter, you could make a set-only property Value on your MyValues, like so:

public class MyValues
{
    [JsonProperty]
    Stuff Value
    {
        set
        {
            (Values = Values ?? new List<Stuff>(1)).Clear();
            Values.Add(value);
        }
    }

    public List<Stuff> Values { get; set; }
    public Thing Other { get; set; }
}

It could be public or private if marked with [JsonProperty]. In this case Json.NET will call the Value setter if the singleton "value" property is encountered in the JSON, and call the Values setter if the array "values" property is encountered. Since the property is set-only only the array property will be re-serialized.

This is a great simple solution to my problem. The only reason I'm not marking it as the answer is that the question is slightly more geared towards making a JsonConverter. This also solves my problem perfectly well. — Ben Randall, Feb 03 '17 at 00:34

score 1 · Accepted Answer · answered Feb 02 '17 at 15:26

To make a custom JsonConverter that has special processing for a few properties of a type but uses default processing for the remainder, you can load the JSON into a JObject, detach and process the custom properties, then populate the remainder from the JObject with JsonSerializer.Populate(), like so:

class MyValuesConverter : CustomPropertyConverterBase<MyValues>
{
    protected override void ProcessCustomProperties(JObject obj, MyValues value, JsonSerializer serializer)
    {
        // Remove the value property for manual deserialization, and deserialize
        var jValue = obj.GetValue("value", StringComparison.OrdinalIgnoreCase).RemoveFromLowestPossibleParent();
        if (jValue != null)
        {
            (value.Values = value.Values ?? new List<Stuff>()).Clear();
            value.Values.Add(jValue.ToObject<Stuff>(serializer));
        }
    }
}

public abstract class CustomPropertyConverterBase<T> : JsonConverter where T : class
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(T).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;
        var jObj = JObject.Load(reader);
        var contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(objectType);
        var value = existingValue as T ?? (T)contract.DefaultCreator();

        ProcessCustomProperties(jObj, value, serializer);

        // Populate the remaining properties.
        using (var subReader = jObj.CreateReader())
        {
            serializer.Populate(subReader, value);
        }

        return value;
    }

    protected abstract void ProcessCustomProperties(JObject obj, T value, JsonSerializer serializer);

    public override bool CanWrite { get { return false; } }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

public static class JsonExtensions
{
    public static JToken RemoveFromLowestPossibleParent(this JToken node)
    {
        if (node == null)
            return null;
        var contained = node.AncestorsAndSelf().Where(t => t.Parent is JContainer && t.Parent.Type != JTokenType.Property).FirstOrDefault();
        if (contained != null)
            contained.Remove();
        // Also detach the node from its immediate containing property -- Remove() does not do this even though it seems like it should
        if (node.Parent is JProperty)
            ((JProperty)node.Parent).Value = null;
        return node;
    }
}

Deserialize two values into the same property

2 Answers2

Linked

Related