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 System.Reflection;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

    //https://stackoverflow.com/questions/56214462/how-to-serialize-deserialize-json-dictionary-into-array

​

    public class CustomDictionaryConverter : JsonConverter

    {

        // Adapted from CustomDictionaryConverter from this answer https://stackoverflow.com/a/40265708

        // To https://stackoverflow.com/questions/40257262/serializing-dictionarystring-string-to-array-of-name-value

        // By Brian Rogers https://stackoverflow.com/users/10263/brian-rogers

​

        sealed class InconvertibleDictionary : Dictionary<object, object>

        {

            public InconvertibleDictionary(DictionaryEntry entry)

                : base(1)

            {

                this[entry.Key] = entry.Value;

            }

        }

​

        public override bool CanConvert(Type objectType)

        {

            return typeof(IDictionary).IsAssignableFrom(objectType) && objectType != typeof(InconvertibleDictionary);

        }

​

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

        {

            // Lazy evaluation of the enumerable prevents materialization of the entire collection of dictionaries at once.

            serializer.Serialize(writer,  Entries(((IDictionary)value)).Select(p => new InconvertibleDictionary(p)));

        }

​

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

        {

            if (reader.MoveToContentAndAssert().TokenType == JsonToken.Null)

                return null;

            var dictionary = existingValue ?? serializer.ContractResolver.ResolveContract(objectType).DefaultCreator();

            switch (reader.TokenType)

            {

                case JsonToken.StartObject:

                    serializer.Populate(reader, dictionary);

                    return dictionary;

​

                case JsonToken.StartArray:

                    {

                        while (true)

                        {

                            switch (reader.ReadToContentAndAssert().TokenType)

                            {

                                case JsonToken.EndArray:

                                    return dictionary;

​

                                case JsonToken.StartObject:

                                    serializer.Populate(reader, dictionary);

                                    break;

​

                                default:

                                    throw new JsonSerializationException(string.Format("Unexpected token {0}", reader.TokenType));

                            }

                        }

                    }

​

                default:

                    throw new JsonSerializationException(string.Format("Unexpected token {0}", reader.TokenType));

            }

        }

​

        static IEnumerable<DictionaryEntry> Entries(IDictionary dict)

        {

            foreach (DictionaryEntry entry in dict)

                yield return entry;

        }

    }

​

    public static partial class JsonExtensions

    {

        public static JsonReader ReadToContentAndAssert(this JsonReader reader)

        {

            return reader.ReadAndAssert().MoveToContentAndAssert();

        }

​

        public static JsonReader MoveToContentAndAssert(this JsonReader reader)

        {

            if (reader == null)

                throw new ArgumentNullException();

            if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.

                reader.ReadAndAssert();

            while (reader.TokenType == JsonToken.Comment) // Skip past comments.

                reader.ReadAndAssert();

            return reader;

        }

​

        public static JsonReader ReadAndAssert(this JsonReader reader)

        {

            if (reader == null)

                throw new ArgumentNullException();

            if (!reader.Read())

                throw new JsonReaderException("Unexpected end of JSON stream.");

            return reader;

        }

    }

​

    public enum DeploymentEnvironment { DEV = 1, TST = 2 }

    public enum TargetApplication { Apollo = 1, Gemini = 2 }

    public enum DbKeyType { DmkPassword = 1, SymmetricKeySource = 2 }

​

    public class DeploymentSettings

    {

        [JsonProperty("defaultSettings")]

        public DefaultSettings DefaultSettings { get; set; }

        public DeploymentSettings()

        {

            DefaultSettings = new DefaultSettings();

        }

    }

​

    public partial class DefaultSettings

    {

        [JsonProperty("applications")]

        public Dictionary<TargetApplication, ApplicationContainer> Applications { get; set; }

​

        public DefaultSettings()

        {

            Applications = new Dictionary<TargetApplication, ApplicationContainer>();

        }

    }

​

    public partial class ApplicationContainer

    {

        [JsonProperty("environments")]

        public Dictionary<DeploymentEnvironment, EnvironmentContainer> Environments { get; set; }

        public ApplicationContainer()

        {

            Environments = new Dictionary<DeploymentEnvironment, EnvironmentContainer>();

        }

    }

​

    public partial class EnvironmentContainer

    {

        [JsonProperty("dbKeyTypes")]

        public Dictionary<DbKeyType, string> DbKeyTypes { get; set; }

​

        public EnvironmentContainer()

        {

            DbKeyTypes = new Dictionary<DbKeyType, string>();

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var json = GetJson();

​

            var settings = new JsonSerializerSettings

            {

                Converters = { new CustomDictionaryConverter(), new StringEnumConverter() }

            };

​

            var ds = JsonConvert.DeserializeObject<DeploymentSettings>(json, settings);

​

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

​

            Console.WriteLine("Re-serialized {0}:", ds);

            Console.WriteLine(json2);

​

            Assert.IsTrue(JToken.DeepEquals(JToken.Parse(json), JToken.Parse(json2)));

        }

​

        static string GetJson()

        {

            var json = @"{

 ""defaultSettings"": {

  ""applications"": [

   {

     ""Apollo"": {

      ""environments"": [

        {

          ""DEV"": {

            ""dbKeyTypes"": [

              {

                ""DmkPassword"": ""AEikOooIuGxXC9UBJQ3ckDj7Q126tB06""

              },

              {

                ""SymmetricKeySource"": ""bTU7XOAYA2FFifmiBUggu99yHxX3Ftds""

              }

            ]

          }

        },

        {

          ""TST"": {

            ""dbKeyTypes"": [

              {

                ""DmkPassword"": ""AEikOooIuGxXC9UBJQ3ckDj7Q126tB06""

              },

              {

                ""SymmetricKeySource"": ""bTU7XOAYA2FFifmiBUggu99yHxX3Ftds""

              }

            ]

          }

        }

      ]

    }

  },

  {

    ""Gemini"": {

      ""environments"": [

        {

          ""DEV"": {

            ""dbKeyTypes"": [

              {

                ""DmkPassword"": ""AEikOooIuGxXC9UBJQ3ckDj7Q126tB06""

              },

              {

                ""SymmetricKeySource"": ""bTU7XOAYA2FFifmiBUggu99yHxX3Ftds""

              }

            ]

          }

        },

        {

          ""TST"": {

            ""dbKeyTypes"": [

              {

                ""DmkPassword"": ""AEikOooIuGxXC9UBJQ3ckDj7Q126tB06""

              },

              {

                ""SymmetricKeySource"": ""bTU7XOAYA2FFifmiBUggu99yHxX3Ftds""

              }

            ]

          }

        }

      ]

    }

   }

  ]

 }

}";

            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;

            }

        }

    }

​