questions/46774119/store-retrieve-child-parent-relationship-with-jsonconverter | C# Online Compiler

questions/46774119/store-retrieve-child-parent-relationship-with-jsonconverter by dbc_MinLength

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.Collections.ObjectModel;

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


    // https://stackoverflow.com/questions/46774119/store-retrieve-child-parent-relationship-with-jsonconverter#comment80586813_46774119

    public interface IHasParent<TParent> where TParent : class
    {
        TParent Parent { get; }

        void OnParentChanging(TParent newParent);
    }

    public class ChildCollection<TParent, TChild> : Collection<TChild>
        where TChild : IHasParent<TParent>
        where TParent : class
    {
        readonly TParent parent;

        public ChildCollection(TParent parent)
        {
            this.parent = parent;
        }

        protected override void ClearItems()
        {
            foreach (var item in this)
            {
                if (item != null)
                    item.OnParentChanging(null);
            }
            base.ClearItems();
        }

        protected override void InsertItem(int index, TChild item)
        {
            if (item != null)
                item.OnParentChanging(parent);
            base.InsertItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            var item = this[index];
            if (item != null)
                item.OnParentChanging(null);
            base.RemoveItem(index);
        }

        protected override void SetItem(int index, TChild item)
        {
            var oldItem = this[index];
            if (oldItem != null)
                oldItem.OnParentChanging(null);
            if (item != null)
                item.OnParentChanging(parent);
            base.SetItem(index, item);
        }
    }

    public class MyObject : IHasParent<MyObject>
    {
        readonly ChildCollection<MyObject, MyObject> childObjects;

        public MyObject() { this.childObjects = new ChildCollection<MyObject, MyObject>(this); }

        public string Name { get; set; }

        public IList<MyObject> ChildObjects { get { return childObjects; } }

        #region IHasParent<MyObject> Members

        [JsonIgnore]
        public MyObject Parent { get; private set; }

        public void OnParentChanging(MyObject newParent)
        {
            Parent = newParent;
        }

        #endregion

        // Added to suppress serialization of empty ChildObjects collections to JSON.
        public bool ShouldSerializeChildObjects() { return childObjects.Count > 0; }
    }

    public class RootObject
    {
        public RootObject() { this.Object = new List<MyObject>(); }

        public List<MyObject> Object { get; set; }
    }

    public static class MyObjectExtensions
    {
        public static IEnumerable<MyObject> Descendants(this RootObject obj)
        {
            if (obj == null)
                return new MyObject[0];
            return obj.Object.SelectMany(o => RecursiveEnumerableExtensions.Traverse(o, (o2) => (o2 == null ? new MyObject[0] : o2.ChildObjects)));
        }

        public static IEnumerable<MyObject> DescendantsAndSelf(this MyObject obj)
        {
            if (obj == null)
                return new MyObject[0];
            return RecursiveEnumerableExtensions.Traverse(obj, (o) => (o == null ? new MyObject[0] : o.ChildObjects));
        }

        public static IEnumerable<MyObject> Descendants(this MyObject obj)
        {
            if (obj == null)
                return new MyObject[0];
            return RecursiveEnumerableExtensions.Traverse(obj, (o) => (o == null ? new MyObject[0] : o.ChildObjects)).Skip(1);
        }
    }

    public static class RecursiveEnumerableExtensions
    {
        // sort of adapted from http://stackoverflow.com/questions/10253161/efficient-graph-traversal-with-linq-eliminating-recursion        

        public static IEnumerable<T> Traverse<T>(
            T root,
            Func<T, IEnumerable<T>> children)
        {
            yield return root;

            var stack = new Stack<IEnumerator<T>>();
            try
            {
                stack.Push(children(root).GetEnumerator());

                while (stack.Count != 0)
                {
                    var enumerator = stack.Peek();
                    if (!enumerator.MoveNext())
                    {
                        stack.Pop();
                        enumerator.Dispose();
                    }
                    else
                    {
                        yield return enumerator.Current;
                        stack.Push(children(enumerator.Current).GetEnumerator());
                    }
                }
            }
            finally
            {
                foreach (var enumerator in stack)
                    enumerator.Dispose();
            }
        }
    }

    class TestClass
    {
        public static void Test()
        {
            var json = GetJson();

            var root = JsonConvert.DeserializeObject<RootObject>(json);

            ValidateRoot(root);

            var newJson = JsonConvert.SerializeObject(root, Formatting.Indented);

            Console.WriteLine("\nRe-serialized JSON: ");
            Console.WriteLine(newJson);

            Assert.IsTrue(JToken.DeepEquals(JToken.Parse(json), JToken.Parse(newJson)));

            var oldChildren = root.Object.ToDictionary(o => o, o => o.ChildObjects.ToList());

            root.Object.ForEach(o => o.ChildObjects.Clear());
            
            foreach (var child in oldChildren.Values.SelectMany(c => c))
                Assert.IsTrue(child.Parent == null);
            ValidateRoot(root);

            foreach (var obj in root.Object)
                foreach (var child in oldChildren[obj])
                    obj.ChildObjects.Add(child);

            ValidateRoot(root);

            foreach (var obj in root.Descendants().Where(o => o.Parent != null).ToList())
            {
                var parent = obj.Parent;

                parent.ChildObjects.Remove(obj);
                Assert.IsTrue(obj.Parent == null);
                ValidateRoot(root);

                var temp = new MyObject() { Name = "Temp" };
                parent.ChildObjects.Add(temp);
                Assert.IsTrue(temp.Parent == parent);

                var index = parent.ChildObjects.IndexOf(temp);
                parent.ChildObjects[index] = obj;

                Assert.IsTrue(obj.Parent == parent);
                Assert.IsTrue(temp.Parent == null);
                ValidateRoot(root);
            }

            Console.WriteLine("\nAll tests passed.");
        }

        private static void ValidateRoot(RootObject root)
        {
            foreach (var obj in root.Object)
            {
                Assert.IsTrue(obj.Parent == null);
                foreach (var child in obj.Descendants())
                {
                    Assert.IsTrue(child.Parent != null);
                    Assert.IsTrue(child.ChildObjects.All(c => c.Parent == child));
                }
            }
        }

        static string GetJson()
        {
            var json = @"
{
    ""Object"": 
    [
        {
            ""Name"": ""TestA"",
            ""ChildObjects"": 
            [
                {
                    ""Name"": ""TestB"",
                    ""ChildObjects"": [
                        {
                            ""Name"": ""TestB.1""
                        }
                    ]
                },
                {
                    ""Name"": ""TestB2"",
                    ""ChildObjects"": [
                        {
                            ""Name"": ""TestB2.1""
                        },
                        {
                            ""Name"": ""TestB2.2""
                        }
                    ]
                },
            ]
        },
        {
            ""Name"": ""TestC"",
            ""ChildObjects"": [
                {
                    ""Name"": ""TestC1""
                },
                {
                    ""Name"": ""TestC2""
                },
            ]
        }
    ]
}";
            return json;
        }
    }

	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;
			}
		}
	}

    public class AssertionFailedException : System.Exception
    {
        public AssertionFailedException() : base() { }

        public AssertionFailedException(string s) : base(s) { }
    }

    public static class Assert
    {
        public static void IsTrue(bool value)
        {
            IsTrue(value, "failed");
        }

        public static void IsTrue(bool value, string message)
        {
            if (value == false)
                throw new AssertionFailedException(message ?? "failed");
        }
    }

​x
 
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.Collections.ObjectModel;
​
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;    
​
​
    // https://stackoverflow.com/questions/46774119/store-retrieve-child-parent-relationship-with-jsonconverter#comment80586813_46774119
​
    public interface IHasParent<TParent> where TParent : class
    {
        TParent Parent { get; }
​
        void OnParentChanging(TParent newParent);
    }
​
    public class ChildCollection<TParent, TChild> : Collection<TChild>
        where TChild : IHasParent<TParent>
        where TParent : class
    {
        readonly TParent parent;
​
        public ChildCollection(TParent parent)
        {
            this.parent = parent;
        }
​
        protected override void ClearItems()
        {
            foreach (var item in this)
            {
                if (item != null)
                    item.OnParentChanging(null);
            }
            base.ClearItems();
        }
​
        protected override void InsertItem(int index, TChild item)
        {
            if (item != null)
                item.OnParentChanging(parent);
            base.InsertItem(index, item);
        }
​
        protected override void RemoveItem(int index)
        {
            var item = this[index];
            if (item != null)
                item.OnParentChanging(null);
            base.RemoveItem(index);
        }
​
        protected override void SetItem(int index, TChild item)
        {
            var oldItem = this[index];
            if (oldItem != null)
                oldItem.OnParentChanging(null);
            if (item != null)
                item.OnParentChanging(parent);
            base.SetItem(index, item);
        }
    }
​
    public class MyObject : IHasParent<MyObject>
    {
        readonly ChildCollection<MyObject, MyObject> childObjects;
​
        public MyObject() { this.childObjects = new ChildCollection<MyObject, MyObject>(this); }
​
        public string Name { get; set; }
​
        public IList<MyObject> ChildObjects { get { return childObjects; } }
​
        #region IHasParent<MyObject> Members
​
        [JsonIgnore]
        public MyObject Parent { get; private set; }
​
        public void OnParentChanging(MyObject newParent)
        {
            Parent = newParent;
        }
​
        #endregion
​
        // Added to suppress serialization of empty ChildObjects collections to JSON.
        public bool ShouldSerializeChildObjects() { return childObjects.Count > 0; }
    }
​
    public class RootObject
    {
        public RootObject() { this.Object = new List<MyObject>(); }
​
        public List<MyObject> Object { get; set; }
    }
​
    public static class MyObjectExtensions
    {
        public static IEnumerable<MyObject> Descendants(this RootObject obj)
        {
            if (obj == null)
                return new MyObject[0];
            return obj.Object.SelectMany(o => RecursiveEnumerableExtensions.Traverse(o, (o2) => (o2 == null ? new MyObject[0] : o2.ChildObjects)));
        }
​
        public static IEnumerable<MyObject> DescendantsAndSelf(this MyObject obj)
        {
            if (obj == null)
                return new MyObject[0];
            return RecursiveEnumerableExtensions.Traverse(obj, (o) => (o == null ? new MyObject[0] : o.ChildObjects));
        }
​
        public static IEnumerable<MyObject> Descendants(this MyObject obj)
        {
            if (obj == null)
                return new MyObject[0];
            return RecursiveEnumerableExtensions.Traverse(obj, (o) => (o == null ? new MyObject[0] : o.ChildObjects)).Skip(1);
        }
    }
​
    public static class RecursiveEnumerableExtensions
    {
        // sort of adapted from http://stackoverflow.com/questions/10253161/efficient-graph-traversal-with-linq-eliminating-recursion        
​
        public static IEnumerable<T> Traverse<T>(
            T root,
            Func<T, IEnumerable<T>> children)
        {
            yield return root;
​
            var stack = new Stack<IEnumerator<T>>();
            try
            {
                stack.Push(children(root).GetEnumerator());
​
                while (stack.Count != 0)
                {
                    var enumerator = stack.Peek();
                    if (!enumerator.MoveNext())
                    {
                        stack.Pop();
                        enumerator.Dispose();
                    }
                    else
                    {
                        yield return enumerator.Current;
                        stack.Push(children(enumerator.Current).GetEnumerator());
                    }
                }
            }
            finally
            {
                foreach (var enumerator in stack)
                    enumerator.Dispose();
            }
        }
    }
​
    class TestClass
    {
        public static void Test()
        {
            var json = GetJson();
​
            var root = JsonConvert.DeserializeObject<RootObject>(json);
​
            ValidateRoot(root);
​
            var newJson = JsonConvert.SerializeObject(root, Formatting.Indented);
​
            Console.WriteLine("\nRe-serialized JSON: ");
            Console.WriteLine(newJson);
​
            Assert.IsTrue(JToken.DeepEquals(JToken.Parse(json), JToken.Parse(newJson)));
​
            var oldChildren = root.Object.ToDictionary(o => o, o => o.ChildObjects.ToList());
​
            root.Object.ForEach(o => o.ChildObjects.Clear());
            
            foreach (var child in oldChildren.Values.SelectMany(c => c))
                Assert.IsTrue(child.Parent == null);
            ValidateRoot(root);
​
            foreach (var obj in root.Object)
                foreach (var child in oldChildren[obj])
                    obj.ChildObjects.Add(child);
​
            ValidateRoot(root);
​
            foreach (var obj in root.Descendants().Where(o => o.Parent != null).ToList())
            {
                var parent = obj.Parent;
​
                parent.ChildObjects.Remove(obj);
                Assert.IsTrue(obj.Parent == null);
                ValidateRoot(root);
​
                var temp = new MyObject() { Name = "Temp" };
                parent.ChildObjects.Add(temp);
                Assert.IsTrue(temp.Parent == parent);
​
                var index = parent.ChildObjects.IndexOf(temp);
                parent.ChildObjects[index] = obj;
​
                Assert.IsTrue(obj.Parent == parent);
                Assert.IsTrue(temp.Parent == null);
                ValidateRoot(root);
            }
​
            Console.WriteLine("\nAll tests passed.");
        }
​
        private static void ValidateRoot(RootObject root)
        {
            foreach (var obj in root.Object)
            {
                Assert.IsTrue(obj.Parent == null);
                foreach (var child in obj.Descendants())
                {
                    Assert.IsTrue(child.Parent != null);
                    Assert.IsTrue(child.ChildObjects.All(c => c.Parent == child));
                }
            }
        }
​
        static string GetJson()
        {
            var json = @"
{
    ""Object"": 
    [
        {
            ""Name"": ""TestA"",
            ""ChildObjects"": 
            [
                {
                    ""Name"": ""TestB"",
                    ""ChildObjects"": [
                        {
                            ""Name"": ""TestB.1""
                        }
                    ]
                },
                {
                    ""Name"": ""TestB2"",
                    ""ChildObjects"": [
                        {
                            ""Name"": ""TestB2.1""
                        },
                        {
                            ""Name"": ""TestB2.2""
                        }
                    ]
                },
            ]
        },
        {
            ""Name"": ""TestC"",
            ""ChildObjects"": [
                {
                    ""Name"": ""TestC1""
                },
                {
                    ""Name"": ""TestC2""
                },
            ]
        }
    ]
}";
            return json;
        }
    }
​
    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;
            }
        }
    }
​
    public class AssertionFailedException : System.Exception
    {
        public AssertionFailedException() : base() { }
​
        public AssertionFailedException(string s) : base(s) { }
    }
​
    public static class Assert
    {
        public static void IsTrue(bool value)
        {
            IsTrue(value, "failed");
        }
​
        public static void IsTrue(bool value, string message)
        {
            if (value == false)
                throw new AssertionFailedException(message ?? "failed");
        }
    }
​

View IL Code