Question41293407 cannot-preserve-reference-to-array-or-readonly-list-or-list-created-from-a-non

CSharp · Console

/Program.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Collections.ObjectModel;

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

using System.Diagnostics;

    // https://stackoverflow.com/questions/41293407/cannot-preserve-reference-to-array-or-readonly-list-or-list-created-from-a-non

    public class ArrayReferencePreservngConverter : JsonConverter
    {
        const string refProperty = "$ref";
        const string idProperty = "$id";
        const string valuesProperty = "$values";

        public override bool CanConvert(Type objectType)
        {
			// byte [] is serialized as a Base64 string so incorporate fix by https://stackoverflow.com/users/13109224/dalecooper from https://stackoverflow.com/a/66177664
			if (objectType == typeof(byte[]))
				return false; // He would kill a Byte[] and you'll wonder, why the JSON Deserializer will return NULL on Byte[] :-)
			// Not implemented for multidimensional arrays.
            return objectType.IsArray && objectType.GetArrayRank() == 1;
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
			Debug.Assert(CanConvert(objectType));
            if (reader.TokenType == JsonToken.Null)
                return null;
            else if (reader.TokenType == JsonToken.StartArray)
            {
                // No $ref.  Deserialize as a List<T> to avoid infinite recursion and return as an array.
                var elementType = objectType.GetElementType();
                var listType = typeof(List<>).MakeGenericType(elementType);
                var list = (IList)serializer.Deserialize(reader, listType);
                if (list == null)
                    return null;
                var array = Array.CreateInstance(elementType, list.Count);
                list.CopyTo(array, 0);
                return array;
            }
            else
            {
                var obj = JObject.Load(reader);
                var refId = (string)obj[refProperty];
                if (refId != null)
                {
                    var reference = serializer.ReferenceResolver.ResolveReference(serializer, refId);
                    if (reference != null)
                        return reference;
                }
                var values = obj[valuesProperty];
                if (values == null || values.Type == JTokenType.Null)
                    return null;
                if (!(values is JArray))
                {
                    throw new JsonSerializationException(string.Format("{0} was not an array", values));
                }
                var count = ((JArray)values).Count;

                var elementType = objectType.GetElementType();
                var array = Array.CreateInstance(elementType, count);

                var objId = (string)obj[idProperty];
                if (objId != null)
                {
                    // Add the empty array into the reference table BEFORE poppulating it,
                    // to handle recursive references.
                    serializer.ReferenceResolver.AddReference(serializer, objId, array);
                }

                var listType = typeof(List<>).MakeGenericType(elementType);
                using (var subReader = values.CreateReader())
                {
                    var list = (IList)serializer.Deserialize(subReader, listType);
                    list.CopyTo(array, 0);
                }

                return array;
            }
        }

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

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            throw new NotImplementedException();
        }
    }

    class Test
    {
        public Test[] Tests;
    }

    class TestClass
    {
        public static void Test()
        {
            Console.WriteLine("Testing recursive array reference resolution... ");
            TestSelfReference();

            Console.WriteLine("Testing non-recursive array reference resolution... ");
            TestNoSelfReference();

            Console.WriteLine("Pass");
        }
		
        public static void TestSelfReference()
        {
            var o = new Test { Tests = new[] { new Test(), new Test() } };
            var arr = new[] { o, o };
            arr[0].Tests[0].Tests = arr;

            TestRoundTrip(arr);
        }

        static void TestNoSelfReference()
        {
            var o = new Test { Tests = new[] { new Test(), new Test() } };
            var arr = new[] { o, o };

            TestRoundTrip(arr);

            TestRoundTripWithoutReferencePreservation(arr);
        }

        private static void TestRoundTrip(Test[] arr)
        {
            var settings = new JsonSerializerSettings
            {
                Converters = { new ArrayReferencePreservngConverter() },
                PreserveReferencesHandling = PreserveReferencesHandling.All
            };

            var json1 = JsonConvert.SerializeObject(arr, Formatting.Indented, settings);

            Console.WriteLine("Initially serialized JSON: ");
            Console.WriteLine(json1);

            var a2 = JsonConvert.DeserializeObject<Test[]>(json1, settings);

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

            Console.WriteLine("Deserialized and re-serialized JSON: ");
            Console.WriteLine(json2);

            if (!JToken.DeepEquals(JToken.Parse(json1), JToken.Parse(json2)))
            {
                Console.WriteLine("Initial and re-serialized JSON are NOT equivalent.");
                throw new InvalidOperationException("!JToken.DeepEquals(JToken.Parse(json1), JToken.Parse(json2))");
            }
            else
            {
                Console.WriteLine("Initial and re-serialized JSON are equivalent.");
            }
        }

        private static void TestRoundTripWithoutReferencePreservation(Test[] arr)
        {
            var settings = new JsonSerializerSettings
            {
                Converters = { new ArrayReferencePreservngConverter() },
                PreserveReferencesHandling = PreserveReferencesHandling.All
            };

            // Make sure the converter properly handles the case where the reference tracking isn't present in the file.

            var jsonNoRef1 = JsonConvert.SerializeObject(arr, Formatting.Indented);

            var arrNoRef = JsonConvert.DeserializeObject<Test[]>(jsonNoRef1, settings);

            var jsonNoRef2 = JsonConvert.SerializeObject(arrNoRef, Formatting.Indented);

            if (!JToken.DeepEquals(JToken.Parse(jsonNoRef1), JToken.Parse(jsonNoRef2)))
            {
                Console.WriteLine("Initial and re-serialized JSON without refs are NOT equivalent.");
                throw new InvalidOperationException("!JToken.DeepEquals(JToken.Parse(jsonNoRef1), JToken.Parse(jsonNoRef2))");
            }
            else
            {
                Console.WriteLine("Initial and re-serialized JSON without refs are equivalent.");
            }
        }
    }
					
	public class Program
	{
		public static void Main()
		{
            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
			TestClass.Test();
		}
	}
;