CSharp · Console
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();
}
}