Question37076278 expandoobjectconverter + type name handling | C# Online Compiler

Question37076278 expandoobjectconverter + type name handling by dbc_MinLength

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Collections;
using System.Runtime.Serialization;
using System.Dynamic;
using System.Runtime.Serialization.Formatters;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;


namespace JsonUtilities
{
	using System.Globalization;
	
    /// <summary>
    /// Converts an ExpandoObject to and from JSON.
    /// Adapted from https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs
    /// License: https://github.com/JamesNK/Newtonsoft.Json/blob/master/LICENSE.md
    /// </summary>
    public class TypeNameHandlingExpandoObjectConverter : JsonConverter
    {
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            // can write is set to false
        }

        /// <summary>
        /// Reads the JSON representation of the object.
        /// </summary>
        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
        /// <param name="objectType">Type of the object.</param>
        /// <param name="existingValue">The existing value of object being read.</param>
        /// <param name="serializer">The calling serializer.</param>
        /// <returns>The object value.</returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            return ReadValue(reader, serializer);
        }

        private object ReadValue(JsonReader reader, JsonSerializer serializer)
        {
            if (!reader.MoveToContent())
            {
                throw JsonSerializationExceptionHelper.Create(reader, "Unexpected end when reading ExpandoObject.");
            }

            switch (reader.TokenType)
            {
                case JsonToken.StartObject:
                    return ReadObject(reader, serializer);
                case JsonToken.StartArray:
                    return ReadList(reader, serializer);
                default:
                    if (JsonTokenUtils.IsPrimitiveToken(reader.TokenType))
                    {
                        return reader.Value;
                    }

                    throw JsonSerializationExceptionHelper.Create(reader, string.Format("Unexpected token when converting ExpandoObject: {0}", reader.TokenType));
            }
        }

        private object ReadList(JsonReader reader, JsonSerializer serializer)
        {
            IList<object> list = new List<object>();

            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                    case JsonToken.Comment:
                        break;
                    default:
                        object v = ReadValue(reader, serializer);

                        list.Add(v);
                        break;
                    case JsonToken.EndArray:
                        return list;
                }
            }

            throw JsonSerializationExceptionHelper.Create(reader, "Unexpected end when reading ExpandoObject.");
        }

        private object ReadObject(JsonReader reader, JsonSerializer serializer)
        {
            if (serializer.TypeNameHandling != TypeNameHandling.None)
            {
                var obj = JObject.Load(reader);

                Type polymorphicType = null;
                var polymorphicTypeString = (string)obj["$type"];
                if (polymorphicTypeString != null)
                {
                    if (serializer.TypeNameHandling != TypeNameHandling.None)
                    {
                        string typeName, assemblyName;
                        ReflectionUtils.SplitFullyQualifiedTypeName(polymorphicTypeString, out typeName, out assemblyName);
                        polymorphicType = serializer.Binder.BindToType(assemblyName, typeName);
                    }
                    obj.Remove("$type");
                }

                if (polymorphicType == null || polymorphicType == typeof(ExpandoObject))
                {
                    using (var subReader = obj.CreateReader())
                        return ReadExpandoObject(subReader, serializer);
                }
                else
                {
                    using (var subReader = obj.CreateReader())
                        return serializer.Deserialize(subReader, polymorphicType);
                }
            }
            else
            {
	            return ReadExpandoObject(reader, serializer);
            }
        }

        private object ReadExpandoObject(JsonReader reader, JsonSerializer serializer)
        {
            IDictionary<string, object> expandoObject = new ExpandoObject();

            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                    case JsonToken.PropertyName:
                        string propertyName = reader.Value.ToString();

                        if (!reader.Read())
                        {
                            throw JsonSerializationExceptionHelper.Create(reader, "Unexpected end when reading ExpandoObject.");
                        }

                        object v = ReadValue(reader, serializer);

                        expandoObject[propertyName] = v;
                        break;
                    case JsonToken.Comment:
                        break;
                    case JsonToken.EndObject:
                        return expandoObject;
                }
            }

            throw JsonSerializationExceptionHelper.Create(reader, "Unexpected end when reading ExpandoObject.");
        }

        /// <summary>
        /// Determines whether this instance can convert the specified object type.
        /// </summary>
        /// <param name="objectType">Type of the object.</param>
        /// <returns>
        /// 	<c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
        /// </returns>
        public override bool CanConvert(Type objectType)
        {
            return (objectType == typeof(ExpandoObject));
        }

        /// <summary>
        /// Gets a value indicating whether this <see cref="JsonConverter"/> can write JSON.
        /// </summary>
        /// <value>
        /// 	<c>true</c> if this <see cref="JsonConverter"/> can write JSON; otherwise, <c>false</c>.
        /// </value>
        public override bool CanWrite
        {
            get { return false; }
        }
    }

    internal static class JsonTokenUtils
    {
        // Adapted from https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/Utilities/JsonTokenUtils.cs
        public static bool IsPrimitiveToken(this JsonToken token)
        {
            switch (token)
            {
                case JsonToken.Integer:
                case JsonToken.Float:
                case JsonToken.String:
                case JsonToken.Boolean:
                case JsonToken.Undefined:
                case JsonToken.Null:
                case JsonToken.Date:
                case JsonToken.Bytes:
                    return true;
                default:
                    return false;
            }
        }
    }

    internal static class JsonReaderExtensions
    {
        // Adapted from internal bool JsonReader.MoveToContent()
        // https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/JsonReader.cs#L1145
        public static bool MoveToContent(this JsonReader reader)
        {
            if (reader == null)
                throw new ArgumentNullException();
            JsonToken t = reader.TokenType;
            while (t == JsonToken.None || t == JsonToken.Comment)
            {
                if (!reader.Read())
                {
                    return false;
                }

                t = reader.TokenType;
            }

            return true;
        }
    }

    internal static class JsonSerializationExceptionHelper
    {
        public static JsonSerializationException Create(this JsonReader reader, string format, params object[] args)
        {
            // Adapted from https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/JsonPosition.cs

            var lineInfo = reader as IJsonLineInfo;
            var path = (reader == null ? null : reader.Path);
            var message = string.Format(CultureInfo.InvariantCulture, format, args);
            if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
            {
                message = message.Trim();
                if (!message.EndsWith(".", StringComparison.Ordinal))
                    message += ".";
                message += " ";
            }
            message += string.Format(CultureInfo.InvariantCulture, "Path '{0}'", path);
            if (lineInfo != null && lineInfo.HasLineInfo())
                message += string.Format(CultureInfo.InvariantCulture, ", line {0}, position {1}", lineInfo.LineNumber, lineInfo.LinePosition);
            message += ".";

            return new JsonSerializationException(message);
        }
    }

    internal static class ReflectionUtils
    {
        // Utilities taken from https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/Utilities/ReflectionUtils.cs
        // I couldn't find a way to access these directly.

        public static void SplitFullyQualifiedTypeName(string fullyQualifiedTypeName, out string typeName, out string assemblyName)
        {
            int? assemblyDelimiterIndex = GetAssemblyDelimiterIndex(fullyQualifiedTypeName);

            if (assemblyDelimiterIndex != null)
            {
                typeName = fullyQualifiedTypeName.Substring(0, assemblyDelimiterIndex.GetValueOrDefault()).Trim();
                assemblyName = fullyQualifiedTypeName.Substring(assemblyDelimiterIndex.GetValueOrDefault() + 1, fullyQualifiedTypeName.Length - assemblyDelimiterIndex.GetValueOrDefault() - 1).Trim();
            }
            else
            {
                typeName = fullyQualifiedTypeName;
                assemblyName = null;
            }
        }

        private static int? GetAssemblyDelimiterIndex(string fullyQualifiedTypeName)
        {
            int scope = 0;
            for (int i = 0; i < fullyQualifiedTypeName.Length; i++)
            {
                char current = fullyQualifiedTypeName[i];
                switch (current)
                {
                    case '[':
                        scope++;
                        break;
                    case ']':
                        scope--;
                        break;
                    case ',':
                        if (scope == 0)
                        {
                            return i;
                        }
                        break;
                }
            }

            return null;
        }
    }
}

namespace Main
{
	using JsonUtilities;
	
	public class Model1
	{
		public decimal A { get; set; }
	}

	public class Model2
	{
		public string C { get; set; }
	}

	public class Model3
	{
		public List<Dictionary<string, Model2>> Items { get; set; }
	}

	public class Model4
	{
		public List<Dictionary<string, Model3>> Items { get; set; }
	}

    public class TestClass
    {
        static ExpandoObject CreateExpandoObject()
        {
            var model1 = new Model1 { A = 0.001m };
            var model2 = new Model2 { C = "something" };
            var model3 = new Model3
            {
                Items = new List<Dictionary<string, Model2>>
				{
					new Dictionary<string, Model2>
					{
						{ "A Model2", new Model2 { C = "something else" } },
					}
				},
            };

            var model4 = new Model4
            {
                Items = new List<Dictionary<string, Model3>>
				{
					new Dictionary<string, Model3>
					{
						{ "A Model3", model3 },
					}
				},
            };

            IDictionary<string, object> expando = new ExpandoObject();
            expando["model1"] = model1;
            expando["model2"] = model2;
			expando["model4"] = new [] { model4 }.ToList();

            IDictionary<string, object> outerExpando = new ExpandoObject();
            outerExpando["inner"] = expando;

            return (ExpandoObject)outerExpando;
        }

        static void Test(TypeNameHandling typeNameHandling)
        {
            ConsoleAndDebug.WriteLine("Testing: TypeNameHandling." + typeNameHandling.ToString() + ":");
            ConsoleAndDebug.WriteLine("");
            var expando = CreateExpandoObject();
            var settings = new JsonSerializerSettings
            {
                Formatting = Newtonsoft.Json.Formatting.Indented,
                TypeNameHandling = typeNameHandling,
                TypeNameAssemblyFormat = FormatterAssemblyStyle.Full, // Needed on https://dotnetfiddle.net
                Converters = new [] { new TypeNameHandlingExpandoObjectConverter() },
            };
            var json = JsonConvert.SerializeObject(expando, settings);
            ConsoleAndDebug.WriteLine(json);

            var expando2 = JsonConvert.DeserializeObject<ExpandoObject>(json, settings);

            var json2 = JsonConvert.SerializeObject(expando2, settings);

            Debug.WriteLine(json2);

            if (!new ExpandoObjectComparer().Equals(expando, expando2))
            {
                throw new InvalidOperationException("!new ExpandoObjectComparer().Equals(expando, expando2)");
            }

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

            ConsoleAndDebug.WriteLine("Original and round-tripped ExpandoObjects are identical and have identically typed properties.");
        }

        public static void Test()
        {
            ConsoleAndDebug.WriteLine("");
            Test(TypeNameHandling.Objects);
            ConsoleAndDebug.WriteLine("");
            Test(TypeNameHandling.All);

            try
            {
                ConsoleAndDebug.WriteLine("");
                Test(TypeNameHandling.None);
            }
            catch (Exception ex)
            {
                ConsoleAndDebug.WriteLine("Caught expected exception: " + ex.Message);
                ConsoleAndDebug.WriteLine("Original and round-tripped ExpandoObjects were not identical as expected.");
            }

            ConsoleAndDebug.WriteLine("");
            Test(TypeNameHandling.Auto);
        }

        static string GetJson()
        {
            var json = @"{
  ""model1"": {
    ""$type"": ""MyType, MyAssembly"",
    ""A"": 5
  },
  ""model2"": {
    ""C"": ""something""
}";
            return json;
        }
	}

    public class ExpandoObjectComparer : IEqualityComparer<ExpandoObject>
    {
        #region IEqualityComparer<ExpandoObject> Members

        bool ValueComparer(object x, object y)
        {
            if (object.ReferenceEquals(x, y))
                return true;
            else if (x == null || y == null)
                return false;
            if (x is IList && y is IList)
            {
                var xList = (IList)x;
                var yList = (IList)y;

                if (xList.Count != yList.Count)
                    return false;
                for (int i = 0; i < xList.Count; i++)
                {
                    if (!ValueComparer(xList[i], yList[i]))
                        return false;
                }
                return true;
            }
            else
            {
                if (x.GetType() != y.GetType())
                    return false;
                if (x is ExpandoObject && y is ExpandoObject)
                    return Equals((ExpandoObject)x, (ExpandoObject)y);
                return JToken.DeepEquals(JToken.FromObject(x), JToken.FromObject(y));
            }
        }

        public bool Equals(ExpandoObject xExpando, ExpandoObject yExpando)
        {
            IDictionary<string, object> x = xExpando;
            IDictionary<string, object> y = yExpando;

            if (x.Count != y.Count)
                return false;
            if (x.Keys.Except(y.Keys).Any())
                return false;
            if (y.Keys.Except(x.Keys).Any())
                return false;
            foreach (var pair in x)
                if (!ValueComparer(pair.Value, y[pair.Key]))
                    return false;
            return true;
        }

        public int GetHashCode(ExpandoObject obj)
        {
            if (obj == null)
                return 0;
            IDictionary<string, object> dict = obj;
            return dict.Count.GetHashCode();
        }

        #endregion
    }
	public class Program
	{
		public static void Main()
		{
            ConsoleAndDebug.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
			
			TestClass.Test();
		}
	}

    public static class ConsoleAndDebug
    {		
        public static void Write(object s)
        {
            Console.Write(s);
            Debug.Write(s);
        }

        public static void WriteLine(object s)
        {
            Console.WriteLine(s);
            Debug.WriteLine(s);
        }
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Collections;
using System.Runtime.Serialization;
using System.Dynamic;
using System.Runtime.Serialization.Formatters;
​
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;
​
​
namespace JsonUtilities
{
    using System.Globalization;
    
    /// <summary>
    /// Converts an ExpandoObject to and from JSON.
    /// Adapted from https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/Converters/ExpandoObjectConverter.cs
    /// License: https://github.com/JamesNK/Newtonsoft.Json/blob/master/LICENSE.md
    /// </summary>
    public class TypeNameHandlingExpandoObjectConverter : JsonConverter
    {
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            // can write is set to false
        }
​
        /// <summary>
        /// Reads the JSON representation of the object.
        /// </summary>
        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
        /// <param name="objectType">Type of the object.</param>
        /// <param name="existingValue">The existing value of object being read.</param>
        /// <param name="serializer">The calling serializer.</param>
        /// <returns>The object value.</returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            return ReadValue(reader, serializer);
        }
​
        private object ReadValue(JsonReader reader, JsonSerializer serializer)
        {
            if (!reader.MoveToContent())
            {
                throw JsonSerializationExceptionHelper.Create(reader, "Unexpected end when reading ExpandoObject.");
            }
​
            switch (reader.TokenType)
            {
                case JsonToken.StartObject:
                    return ReadObject(reader, serializer);
                case JsonToken.StartArray:
                    return ReadList(reader, serializer);
                default:
                    if (JsonTokenUtils.IsPrimitiveToken(reader.TokenType))
                    {
                        return reader.Value;
                    }
​
                    throw JsonSerializationExceptionHelper.Create(reader, string.Format("Unexpected token when converting ExpandoObject: {0}", reader.TokenType));
            }
        }
​
        private object ReadList(JsonReader reader, JsonSerializer serializer)
        {
            IList<object> list = new List<object>();
​
            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                    case JsonToken.Comment:
                        break;
                    default:
                        object v = ReadValue(reader, serializer);
​
                        list.Add(v);
                        break;
                    case JsonToken.EndArray:
                        return list;
                }
            }
​
            throw JsonSerializationExceptionHelper.Create(reader, "Unexpected end when reading ExpandoObject.");
        }
​
        private object ReadObject(JsonReader reader, JsonSerializer serializer)
        {
            if (serializer.TypeNameHandling != TypeNameHandling.None)
            {
                var obj = JObject.Load(reader);
​
                Type polymorphicType = null;
                var polymorphicTypeString = (string)obj["$type"];
                if (polymorphicTypeString != null)
                {
                    if (serializer.TypeNameHandling != TypeNameHandling.None)
                    {
                        string typeName, assemblyName;
                        ReflectionUtils.SplitFullyQualifiedTypeName(polymorphicTypeString, out typeName, out assemblyName);
                        polymorphicType = serializer.Binder.BindToType(assemblyName, typeName);
                    }
                    obj.Remove("$type");
                }
​
                if (polymorphicType == null || polymorphicType == typeof(ExpandoObject))
                {
                    using (var subReader = obj.CreateReader())
                        return ReadExpandoObject(subReader, serializer);
                }
                else
                {
                    using (var subReader = obj.CreateReader())
                        return serializer.Deserialize(subReader, polymorphicType);
                }
            }
            else
            {
                return ReadExpandoObject(reader, serializer);
            }
        }
​
        private object ReadExpandoObject(JsonReader reader, JsonSerializer serializer)
        {
            IDictionary<string, object> expandoObject = new ExpandoObject();
​
            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                    case JsonToken.PropertyName:
                        string propertyName = reader.Value.ToString();
​
                        if (!reader.Read())
                        {
                            throw JsonSerializationExceptionHelper.Create(reader, "Unexpected end when reading ExpandoObject.");
                        }
​
                        object v = ReadValue(reader, serializer);
​
                        expandoObject[propertyName] = v;
                        break;
                    case JsonToken.Comment:
                        break;
                    case JsonToken.EndObject:
                        return expandoObject;
                }
            }
​
            throw JsonSerializationExceptionHelper.Create(reader, "Unexpected end when reading ExpandoObject.");
        }
​
        /// <summary>
        /// Determines whether this instance can convert the specified object type.
        /// </summary>
        /// <param name="objectType">Type of the object.</param>
        /// <returns>
        ///     <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
        /// </returns>
        public override bool CanConvert(Type objectType)
        {
            return (objectType == typeof(ExpandoObject));
        }
​
        /// <summary>
        /// Gets a value indicating whether this <see cref="JsonConverter"/> can write JSON.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this <see cref="JsonConverter"/> can write JSON; otherwise, <c>false</c>.
        /// </value>
        public override bool CanWrite
        {
            get { return false; }
        }
    }
​
    internal static class JsonTokenUtils
    {
        // Adapted from https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/Utilities/JsonTokenUtils.cs
        public static bool IsPrimitiveToken(this JsonToken token)
        {
            switch (token)
            {
                case JsonToken.Integer:
                case JsonToken.Float:
                case JsonToken.String:
                case JsonToken.Boolean:
                case JsonToken.Undefined:
                case JsonToken.Null:
                case JsonToken.Date:
                case JsonToken.Bytes:
                    return true;
                default:
                    return false;
            }
        }
    }
​
    internal static class JsonReaderExtensions
    {
        // Adapted from internal bool JsonReader.MoveToContent()
        // https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/JsonReader.cs#L1145
        public static bool MoveToContent(this JsonReader reader)
        {
            if (reader == null)
                throw new ArgumentNullException();
            JsonToken t = reader.TokenType;
            while (t == JsonToken.None || t == JsonToken.Comment)
            {
                if (!reader.Read())
                {
                    return false;
                }
​
                t = reader.TokenType;
            }
​
            return true;
        }
    }
​
    internal static class JsonSerializationExceptionHelper
    {
        public static JsonSerializationException Create(this JsonReader reader, string format, params object[] args)
        {
            // Adapted from https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/JsonPosition.cs
​
            var lineInfo = reader as IJsonLineInfo;
            var path = (reader == null ? null : reader.Path);
            var message = string.Format(CultureInfo.InvariantCulture, format, args);
            if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
            {
                message = message.Trim();
                if (!message.EndsWith(".", StringComparison.Ordinal))
                    message += ".";
                message += " ";
            }
            message += string.Format(CultureInfo.InvariantCulture, "Path '{0}'", path);
            if (lineInfo != null && lineInfo.HasLineInfo())
                message += string.Format(CultureInfo.InvariantCulture, ", line {0}, position {1}", lineInfo.LineNumber, lineInfo.LinePosition);
            message += ".";
​
            return new JsonSerializationException(message);
        }
    }
​
    internal static class ReflectionUtils
    {
        // Utilities taken from https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/Utilities/ReflectionUtils.cs
        // I couldn't find a way to access these directly.
​
        public static void SplitFullyQualifiedTypeName(string fullyQualifiedTypeName, out string typeName, out string assemblyName)
        {
            int? assemblyDelimiterIndex = GetAssemblyDelimiterIndex(fullyQualifiedTypeName);
​
            if (assemblyDelimiterIndex != null)
            {
                typeName = fullyQualifiedTypeName.Substring(0, assemblyDelimiterIndex.GetValueOrDefault()).Trim();
                assemblyName = fullyQualifiedTypeName.Substring(assemblyDelimiterIndex.GetValueOrDefault() + 1, fullyQualifiedTypeName.Length - assemblyDelimiterIndex.GetValueOrDefault() - 1).Trim();
            }
            else
            {
                typeName = fullyQualifiedTypeName;
                assemblyName = null;
            }
        }
​
        private static int? GetAssemblyDelimiterIndex(string fullyQualifiedTypeName)
        {
            int scope = 0;
            for (int i = 0; i < fullyQualifiedTypeName.Length; i++)
            {
                char current = fullyQualifiedTypeName[i];
                switch (current)
                {
                    case '[':
                        scope++;
                        break;
                    case ']':
                        scope--;
                        break;
                    case ',':
                        if (scope == 0)
                        {
                            return i;
                        }
                        break;
                }
            }
​
            return null;
        }
    }
}
​
namespace Main
{
    using JsonUtilities;
    
    public class Model1
    {
        public decimal A { get; set; }
    }
​
    public class Model2
    {
        public string C { get; set; }
    }
​
    public class Model3
    {
        public List<Dictionary<string, Model2>> Items { get; set; }
    }
​
    public class Model4
    {
        public List<Dictionary<string, Model3>> Items { get; set; }
    }
​
    public class TestClass
    {
        static ExpandoObject CreateExpandoObject()
        {
            var model1 = new Model1 { A = 0.001m };
            var model2 = new Model2 { C = "something" };
            var model3 = new Model3
            {
                Items = new List<Dictionary<string, Model2>>
                {
                    new Dictionary<string, Model2>
                    {
                        { "A Model2", new Model2 { C = "something else" } },
                    }
                },
            };
​
            var model4 = new Model4
            {
                Items = new List<Dictionary<string, Model3>>
                {
                    new Dictionary<string, Model3>
                    {
                        { "A Model3", model3 },
                    }
                },
            };
​
            IDictionary<string, object> expando = new ExpandoObject();
            expando["model1"] = model1;
            expando["model2"] = model2;
            expando["model4"] = new [] { model4 }.ToList();
​
            IDictionary<string, object> outerExpando = new ExpandoObject();
            outerExpando["inner"] = expando;
​
            return (ExpandoObject)outerExpando;
        }
​
        static void Test(TypeNameHandling typeNameHandling)
        {
            ConsoleAndDebug.WriteLine("Testing: TypeNameHandling." + typeNameHandling.ToString() + ":");
            ConsoleAndDebug.WriteLine("");
            var expando = CreateExpandoObject();
            var settings = new JsonSerializerSettings
            {
                Formatting = Newtonsoft.Json.Formatting.Indented,
                TypeNameHandling = typeNameHandling,
                TypeNameAssemblyFormat = FormatterAssemblyStyle.Full, // Needed on https://dotnetfiddle.net
                Converters = new [] { new TypeNameHandlingExpandoObjectConverter() },
            };
            var json = JsonConvert.SerializeObject(expando, settings);
            ConsoleAndDebug.WriteLine(json);
​
            var expando2 = JsonConvert.DeserializeObject<ExpandoObject>(json, settings);
​
            var json2 = JsonConvert.SerializeObject(expando2, settings);
​
            Debug.WriteLine(json2);
​
            if (!new ExpandoObjectComparer().Equals(expando, expando2))
            {
                throw new InvalidOperationException("!new ExpandoObjectComparer().Equals(expando, expando2)");
            }
​
            if (!JToken.DeepEquals(JToken.Parse(json), JToken.Parse(json2)))
            {
                throw new InvalidOperationException("!JToken.DeepEquals(JToken.Parse(json), JToken.Parse(json2))");
            }
​
            ConsoleAndDebug.WriteLine("Original and round-tripped ExpandoObjects are identical and have identically typed properties.");
        }
​
        public static void Test()
        {
            ConsoleAndDebug.WriteLine("");
            Test(TypeNameHandling.Objects);
            ConsoleAndDebug.WriteLine("");
            Test(TypeNameHandling.All);
​
            try
            {
                ConsoleAndDebug.WriteLine("");
                Test(TypeNameHandling.None);
            }
            catch (Exception ex)
            {
                ConsoleAndDebug.WriteLine("Caught expected exception: " + ex.Message);
                ConsoleAndDebug.WriteLine("Original and round-tripped ExpandoObjects were not identical as expected.");
            }
​
            ConsoleAndDebug.WriteLine("");
            Test(TypeNameHandling.Auto);
        }
​
        static string GetJson()
        {
            var json = @"{
  ""model1"": {
    ""$type"": ""MyType, MyAssembly"",
    ""A"": 5
  },
  ""model2"": {
    ""C"": ""something""
}";
            return json;
        }
    }
​
    public class ExpandoObjectComparer : IEqualityComparer<ExpandoObject>
    {
        #region IEqualityComparer<ExpandoObject> Members
​
        bool ValueComparer(object x, object y)
        {
            if (object.ReferenceEquals(x, y))
                return true;
            else if (x == null || y == null)
                return false;
            if (x is IList && y is IList)
            {
                var xList = (IList)x;
                var yList = (IList)y;
​
                if (xList.Count != yList.Count)
                    return false;
                for (int i = 0; i < xList.Count; i++)
                {
                    if (!ValueComparer(xList[i], yList[i]))
                        return false;
                }
                return true;
            }
            else
            {
                if (x.GetType() != y.GetType())
                    return false;
                if (x is ExpandoObject && y is ExpandoObject)
                    return Equals((ExpandoObject)x, (ExpandoObject)y);
                return JToken.DeepEquals(JToken.FromObject(x), JToken.FromObject(y));
            }
        }
​
        public bool Equals(ExpandoObject xExpando, ExpandoObject yExpando)
        {
            IDictionary<string, object> x = xExpando;
            IDictionary<string, object> y = yExpando;
​
            if (x.Count != y.Count)
                return false;
            if (x.Keys.Except(y.Keys).Any())
                return false;
            if (y.Keys.Except(x.Keys).Any())
                return false;
            foreach (var pair in x)
                if (!ValueComparer(pair.Value, y[pair.Key]))
                    return false;
            return true;
        }
​
        public int GetHashCode(ExpandoObject obj)
        {
            if (obj == null)
                return 0;
            IDictionary<string, object> dict = obj;
            return dict.Count.GetHashCode();
        }
​
        #endregion
    }
    public class Program
    {
        public static void Main()
        {
            ConsoleAndDebug.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
            
            TestClass.Test();
        }
    }
​
    public static class ConsoleAndDebug
    {       
        public static void Write(object s)
        {
            Console.Write(s);
            Debug.Write(s);
        }
​
        public static void WriteLine(object s)
        {
            Console.WriteLine(s);
            Debug.WriteLine(s);
        }
    }
}
​
​

View IL Code