Newtonsoft deserialize multiple JSON files with cross references

Question

I have two JSON files (that I can't change the format for) in the following format:

Main file -

[
   {
      "Name":"XYZ",
      "UnitReferenceId":1
   },
   {
      "Name":"ABC",
      "UnitReferenceId":2
   }
]

The lookup/reference JSON file -

[
   {
      "UnitReferenceId":1,
      "Units":[
         {
            "Unit":"mg",
            "Scale":1
         },
         {
            "Unit":"gm",
            "Scale":1000
         },
         {
            "Unit":"kg",
            "Scale":1000000
         }
      ]
   },
   {
      "UnitReferenceId":2,
      "Units":[
         {
            "Unit":"mm",
            "Scale":1
         },
         {
            "Unit":"m",
            "Scale":1000
         },
         {
            "Unit":"km",
            "Scale":1000000
         }
      ]
   }
]

How would I go about deserializing that into C# classes using Newtonsoft JSON into something like:

public class Widget
{
    public string Name {get; set;}
    public UnitReference UnitReference { get; set; }
}

public class UnitReference
{
    public long UnitReferenceId { get; set; }
    public List<Unit> Units { get; set; }
}
public class Unit
{
    [JsonProperty("Unit")]
    public string UnitValue { get; set; }
    public long Scale { get; set; }
}

Any help would be greatly appreciated!

Answer 1

You can do this by reading your two JSON files as follows:

1. First read the lookup/reference JSON file for UnitReference as a List<UnitReference>, then convert to a Dictionary<long, UnitReference> lookup table.

2. Next, read the main file using a custom JsonConverter for Widget that is passed the Dictionary<long, UnitReference> lookup table and can translate between UnitReferenceId and UnitReference during reading and writing.

Thus your classes would look like the following:

public class UnitReference
{
    readonly long unitReferenceId;

    public UnitReference(long unitReferenceId)
    {
        this.unitReferenceId = unitReferenceId;
    }

    public long UnitReferenceId { get { return unitReferenceId; } }

    public List<Unit> Units { get; set; }
}

public class Unit
{
    [JsonProperty("Unit")]
    public string UnitValue { get; set; }
    public long Scale { get; set; }
}

public class Widget
{
    public string Name { get; set; }

    public UnitReference UnitReference { get; set; }
}

(My only modification was to make UnitReferenceId be read-only so that it safely could be used as a dictionary key.)

Then, define the following converter:

public class WidgetConverter : CustomPropertyConverterBase<Widget>
{
    readonly IDictionary<long, UnitReference> units;

    public WidgetConverter(IDictionary<long, UnitReference> units)
    {
        this.units = units;
    }

    protected override void ReadCustomProperties(JObject obj, Widget value, JsonSerializer serializer)
    {
        var id = (long?)obj.GetValue("UnitReferenceId", StringComparison.OrdinalIgnoreCase);
        if (id != null)
            value.UnitReference = units[id.Value];
    }

    protected override bool ShouldSerialize(JsonProperty property, object value)
    {
        if (property.UnderlyingName == nameof(Widget.UnitReference))
            return false;
        return base.ShouldSerialize(property, value);
    }

    protected override void WriteCustomProperties(JsonWriter writer, Widget value, JsonSerializer serializer)
    {
        if (value.UnitReference != null)
        {
            writer.WritePropertyName("UnitReferenceId");
            writer.WriteValue(value.UnitReference.UnitReferenceId);
        }
    }
}

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();

        ReadCustomProperties(jObj, value, serializer);

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

        return value;
    }

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

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(value.GetType());
        writer.WriteStartObject();
        foreach (var property in contract.Properties.Where(p => ShouldSerialize(p, value)))
        {
            var propertyValue = property.ValueProvider.GetValue(value);
            if (propertyValue == null && serializer.NullValueHandling == NullValueHandling.Ignore)
                continue;
            writer.WritePropertyName(property.PropertyName);
            serializer.Serialize(writer, propertyValue);
        }
        WriteCustomProperties(writer, (T)value, serializer);
        writer.WriteEndObject();
    }

    protected virtual bool ShouldSerialize(JsonProperty property, object value)
    {
        return property.Readable && !property.Ignored && (property.ShouldSerialize == null || property.ShouldSerialize(value));
    }

    protected abstract void WriteCustomProperties(JsonWriter writer, T value, JsonSerializer serializer);
}

And deserialize as follows:

var units = JsonConvert.DeserializeObject<List<UnitReference>>(unitsJsonString)
    .ToDictionary(u => u.UnitReferenceId);

var settings = new JsonSerializerSettings
{
    Converters = { new WidgetConverter(units) },
};
var widgets = JsonConvert.DeserializeObject<List<Widget>>(widgetsJsonString, settings);

Notes:

• Here I am deserializing from JSON strings for demo purposes, but you can deserialize directly from your file(s) as shown in Deserialize JSON from a file.

• The base class CustomPropertyConverterBase<T> for WidgetConverter automatically reads and writes all properties for the object being (de)serialized. WidgetConverter then overrides this behavior for the UnitReference property only, avoiding the necessity to manually serialize all the remaining properties of Widget.

Sample fiddle.