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

​

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/56308478/pass-constructor-arguments-when-deserializing-into-a-listof-t#56308478

​

    public class Document

    {

        public Document() { this.MyObjects = new List<Child>(); }

​

        public List<Child> MyObjects { get; set; }

    }

​

    public class Child

    {

        readonly Document parent;

​

        public Child(Document parent)

        {

            this.parent = parent;

        }

​

        public string Foo { get; set; }

        public string Bar { get; set; }

​

        public Document GetParent() { return parent; }

    }

​

    public class DocumentContractResolver : DefaultContractResolver

    {

        ThreadLocal<Stack<Document>> ActiveDocuments = new ThreadLocal<Stack<Document>>(() => new Stack<Document>());

​

        protected override JsonContract CreateContract(Type objectType)

        {

            var contract = base.CreateContract(objectType);

            CustomizeDocumentContract(contract);

            CustomizeMyObjectContract(contract);

            return contract;

        }

​

        void CustomizeDocumentContract(JsonContract contract)

        {

            if (typeof(Document).IsAssignableFrom(contract.UnderlyingType))

            {

                contract.OnDeserializingCallbacks.Add((o, c) => ActiveDocuments.Value.Push((Document)o));

                contract.OnDeserializedCallbacks.Add((o, c) => ActiveDocuments.Value.Pop());

            }

        }

​

        void CustomizeMyObjectContract(JsonContract contract)

        {

            if (typeof(Child) == contract.UnderlyingType)

            {

                contract.DefaultCreator = () => new Child(ActiveDocuments.Value.Peek());

                contract.DefaultCreatorNonPublic = false;

            }

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var inputDoc = new Document();

            inputDoc.MyObjects.Add(new Child(inputDoc) { Foo = "foo", Bar = "bar" });

​

            var contractResolver = new DocumentContractResolver(); // Cache statically somewhere

            var settings = new JsonSerializerSettings

            {

                ContractResolver = contractResolver,

            };

            var jsonString = JsonConvert.SerializeObject(inputDoc, Formatting.Indented, settings);

            Console.WriteLine(jsonString);

            var document = JsonConvert.DeserializeObject<Document>(jsonString, settings);

​

            Assert.IsTrue(document.MyObjects.All(o => o.GetParent() == document));

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

            Console.WriteLine(json2);

​

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

        }   

    }

​

    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;

            }

        }

    }

​