using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Diagnostics;

using System.IO;

using System.Reflection;

using System.ComponentModel;

using System.Data;

using System.Xml.Serialization;

using System.Runtime.Serialization;

using System.Text.RegularExpressions;

using System.Globalization;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;

​

​

    public class Parent

    {

        public Parent() { this.Props = new List<string>(); }

​

        [JsonProperty("id")]

        public int ParentId { get; set; }

​

        [JsonProperty("value")]

        public string Value { get; set; }

​

        [JsonIgnore]

        public List<string> Props { get; set; }

​

        [JsonExtensionData]

        JObject extensionData; // JObject implements IDictionary<string, JToken> and preserves document order.

​

        [OnSerializing]

        void OnSerializing(StreamingContext ctx)

        {

            VariablePropertyListExtensions.OnSerializing(Props, ref extensionData, false);

        }

​

        [OnSerialized]

        void OnSerialized(StreamingContext ctx)

        {

            VariablePropertyListExtensions.OnSerialized(Props, ref extensionData, false);

        }

​

        [OnDeserializing]

        void OnDeserializing(StreamingContext ctx)

        {

            VariablePropertyListExtensions.OnDeserializing(Props, ref extensionData, false);

        }

​

        [OnDeserialized]

        void OnDeserialized(StreamingContext ctx)

        {

            if (Props == null)

                Props = new List<string>();

            VariablePropertyListExtensions.OnDeserialized(Props, ref extensionData, false);

        }

    }

​

#if false

    public class ListSurrogateDictionary<TListValue, TKey, TValue> : IDictionary<TKey, TValue>

    {

        readonly IList<IListValue> list;

        readonly Func<int, TKey> toKey;

        readonly Func<TKey, int> fromKey;

        readonly Func<TListValue, TValue> ToValue;

        readonly Func<TValue, TListValue> fromValue;

​

        public ListSurrogateDictionary

    }

#endif

​

    public static class VariablePropertyListExtensions

    {

        public const string Prefix = "prop_";

​

        readonly static Regex regex;

​

        static VariablePropertyListExtensions()

        {

            regex = new Regex("^" + Prefix + @"\d+" + "$", RegexOptions.CultureInvariant | RegexOptions.Compiled); // Add  | RegexOptions.IgnoreCase if required

        }

​

        public static void OnSerializing<TDictionary>(IList<string> props, ref TDictionary extensionData, bool keepUnknownProperties) where TDictionary : class, IDictionary<string, JToken>, new()

        {

            Debug.Assert(keepUnknownProperties || (extensionData == null || extensionData.Count == 0));

​

            // Add the prop_ properties.

            if (props == null || props.Count < 1)

                return;

            extensionData = extensionData ?? new TDictionary();

            for (int i = 0; i < props.Count; i++)

                extensionData.Add(Prefix + (i + 1).ToString(NumberFormatInfo.InvariantInfo), (JValue)props[i]);

        }

​

        internal static void OnSerialized<TDictionary>(IList<string> props, ref TDictionary extensionData, bool keepUnknownProperties) where TDictionary : class, IDictionary<string, JToken>, new()

        {

            // Remove the prop_ properties.

            if (extensionData == null)

                return;

            foreach (var name in extensionData.Keys.Where(k => regex.IsMatch(k)).ToList())

                extensionData.Remove(name);

            // null out extension data if no longer needed

            if (!keepUnknownProperties || extensionData.Count == 0)

                extensionData = null;

        }

​

        internal static void OnDeserializing<TDictionary>(IList<string> props, ref TDictionary extensionData, bool keepUnknownProperties) where TDictionary : class, IDictionary<string, JToken>, new()

        {

            Debug.Assert(keepUnknownProperties || (extensionData == null || extensionData.Count == 0));

        }

​

        internal static void OnDeserialized<TDictionary>(IList<string> props, ref TDictionary extensionData, bool keepUnknownProperties) where TDictionary : class, IDictionary<string, JToken>, new()

        {

            props.Clear();

            if (extensionData == null)

                return;

            foreach (var item in extensionData.Where(i => regex.IsMatch(i.Key)).ToList())

            {

                props.Add(item.Value.ToObject<string>());

                extensionData.Remove(item.Key);

            }

            // null out extension data if no longer needed

            if (!keepUnknownProperties || extensionData.Count == 0)

                extensionData = null;

        }

    }

​

    public class RootObject

    {

        public Parent parent { get; set; }

    }

​

    class TestClass

    {

        static string GetJson()

        {

            var json = @"{ ""parent"": {

        ""id"": 4,

        ""prop_1"": ""A"",

        ""prop_2"": ""B"",

        ""prop_3"": ""W"",

        ""value"": ""value""

        }}";

            return json;

        }

​

        internal static void Test()

        {

            var json = GetJson();

​

            var root = JsonConvert.DeserializeObject<RootObject>(json);

​

            var json2 = JsonConvert.SerializeObject(root, Formatting.Indented);

​

            Console.WriteLine("Re-serialized JSON: ");

            Console.WriteLine(json2);

​

            if (!JToken.DeepEquals(JToken.Parse(json), JToken.Parse(json2)))

            {

                throw new InvalidOperationException("!JToken.DeepEquals(JToken.Parse(json), JToken.Parse(json2))");

            }

            else

            {

                Console.WriteLine("Original and re-serialized JSON are equivalent.");

            }

​

            var root2 = new RootObject();

            JsonConvert.PopulateObject(json, root2);

            JsonConvert.PopulateObject(json, root2);

​

            var json3 = JsonConvert.SerializeObject(root2);

​

            if (!JToken.DeepEquals(JToken.Parse(json), JToken.Parse(json3)))

            {

                throw new InvalidOperationException("!JToken.DeepEquals(JToken.Parse(json), JToken.Parse(json3))");

            }

            else

            {

                Console.WriteLine("Original and re-populated JSON are equivalent.");

            }

        }

    }

​

    public class Program

    {

        public static void Main()

        {

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

            Console.WriteLine("");

            TestClass.Test();

        }

    }