using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Threading;

using System.Collections.ObjectModel;

using System.Reflection;

using System.Text.RegularExpressions;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;            

    // https://stackoverflow.com/questions/41564842/how-to-serialize-and-deserialize-arraylist-of-arrays-by-using-json-net

​

    public class MyTestClass

    {

        public string TestString { get; set; }

        // These items SHOULD be deserialized as string []

        public ArrayList Items { get; private set; }

​

        public MyTestClass()

        {

            this.Items = new ArrayList();

            this.UnrelatedItems = new ArrayList();

        }

        // These items should NOT be deserialized as string []

        public ArrayList UnrelatedItems { get; private set; }

    }

​

    public class NestedTestClass

    {

    }

​

    public class Program

    {

        public static void Main()

        {

            var myObject = new MyTestClass();

            myObject.TestString = "hello";

            myObject.Items.Add(new string[] { "Test1", "Test2" });

            myObject.UnrelatedItems.Add(new NestedTestClass());

            var jsonResult = JsonConvert.SerializeObject(myObject);            

            Console.WriteLine("Initial JSON: ");

            Console.WriteLine(jsonResult);

            var tempMyObject = JsonConvert.DeserializeObject<MyTestClass>(jsonResult,

                                                                          new JsonSerializerSettings { Converters = { new MyTestClassConverter() } });

            var reserializedJson = JsonConvert.SerializeObject(tempMyObject, 

                                                               new JsonSerializerSettings { Formatting = Formatting.Indented, TypeNameHandling = TypeNameHandling.All });

            Console.WriteLine("Reserialized JSON: ");

            Console.WriteLine(reserializedJson);

​

            Assert.Equal(myObject.TestString, tempMyObject.TestString);

            //(tempMyObject.Items[0] as string[]) casts to null therefore it throws exception

            Assert.Equal((myObject.Items[0] as string[])[0], (tempMyObject.Items[0] as string[])[0]);

        }

    }

​

    public class MyTestClassConverter : JsonConverter

    {

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

​

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

        {

            throw new NotImplementedException();

        }

​

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

        {

            if (reader.TokenType == JsonToken.Null)

                return null;

            var root = existingValue as MyTestClass ?? (MyTestClass)serializer.ContractResolver.ResolveContract(objectType).DefaultCreator();

            var jsonObject = JObject.Load(reader);

​

            var jsonItems = jsonObject["Items"].RemoveFromLowestPossibleParent();

            if (jsonItems != null && jsonItems.Type != JTokenType.Null)

            {

                root.Items.AddRange(jsonItems.ToObject<List<string []>>());

            }

            // Populate the remaining standard properties

            using (var subReader = jsonObject.CreateReader())

            {

                serializer.Populate(subReader, root);

            }

            return root;

        }

​

        public override bool CanConvert(Type objectType)

        {

            return typeof(MyTestClass).IsAssignableFrom(objectType);

        }

    }

    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;

        }

    }

​

    public static class Assert

    {

        public static void Equal<T>(T expected, T actual)

        {

            if (null == expected)

            {

                // Two nulls are considered equal, regardless of type semantics.

                if (null != actual && !actual.Equals(expected))

                {

                    throw new InvalidOperationException("Assert Failed");

                }

            }

            else if (!expected.Equals(actual))

            {

                throw new InvalidOperationException("Assert Failed");

            }

        }

    }

​