using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

​

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

    // https://stackoverflow.com/questions/47357127/newtonsoft-deserialize-multiple-json-files-with-cross-references

​

    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; }

    }

​

    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 == "UnitReference") //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);

    }

​

    class TestClass

    {

        public static void Test()

        {

            var unitsJsonString = GetUnitsJson();

            var widgetsJsonString = GetWidgetsJson();

​

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

​

            var newJson = JsonConvert.SerializeObject(widgets, Formatting.Indented, settings);

            Console.WriteLine("Deserialized and re-serialized list of {0}:", typeof(Widget));

            Console.WriteLine(newJson);

            Assert.IsTrue(JToken.DeepEquals(JToken.Parse(widgetsJsonString), JToken.Parse(newJson)));

​

            var newJson2 = JsonConvert.SerializeObject(widgets, Formatting.Indented);

            Console.WriteLine("\nDeserialized and re-serialized list of {0} without using the converter:", typeof(Widget));

            Console.WriteLine(newJson2);

        }

​

        static string GetWidgetsJson()

        {

            var json = @"[

    {

    ""Name"": ""XYZ"",

    ""UnitReferenceId"": 1

    },

    {

    ""Name"": ""ABC"",

    ""UnitReferenceId"": 2

    }

   ]";

            return json;

        }

​

        static string GetUnitsJson()

        {

            var json = @"[{

    ""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

        },

    ]

}

]";

            return json;

        }

    }

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            IsTrue(value, "failed");

        }

​

        public static void IsTrue(bool value, string message)

        {

            if (value == false)

                throw new AssertionFailedException(message ?? "failed");

        }

    }

​