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

using System.Runtime.Serialization;

​

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/61102486/json-deserialization-not-deserializing-ref-property

​

namespace FSX.Client.Entities

{

    [DataContract]

    public abstract class GenericRule //: ClientEntity I had to remove this since ClientEntity was not included in the question

    {

        protected GenericRule() : this(null) { }

​

        protected GenericRule(string name)

        {

            Name = name;

        }

​

        [DataMember]

        public string Name { get; set; }

​

        [DataMember]

        public ContainerRule Parent { get; set; }

    }

​

    [DataContract]

    public abstract class ContainerRule : GenericRule

    {

        [DataMember(Name = nameof(Children))]

        protected ObservableCollection<GenericRule> _children =

            new ObservableCollection<GenericRule>();

        public IEnumerable<GenericRule> Children => _children.AsEnumerable();

        // I had to add this to create a test case

        public void AddGenericRule(GenericRule r) => _children.Add(r);

    }

​

    [DataContract]

    public abstract class ActionRule : GenericRule { }

    [DataContract]

    public class Entity 

    {

    }

    [DataContract]

    public class RuleFolder : ContainerRule { 

        private RuleFolder() { }

        public RuleFolder(Entity entity) { }

    }

​

    [DataContract]

    public class RuleSet : ContainerRule { }

​

    // I had to add this to deserialize the JSON provided

    [DataContract]

    public class SetValue : ContainerRule { }

​

    // Taken from this answer https://stackoverflow.com/a/11309106/3744182

    // To https://stackoverflow.com/questions/3330989/order-of-serialized-fields-using-json-net

    // By https://stackoverflow.com/users/381925/mattias-nordberg

    public class OrderedContractResolver : DefaultContractResolver

    {

        protected override System.Collections.Generic.IList<JsonProperty> CreateProperties(System.Type type, MemberSerialization memberSerialization)

        {

            return base.CreateProperties(type, memberSerialization).OrderBy(p => p.PropertyName).ToList();

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var settings = new JsonSerializerSettings

            {

                ContractResolver = new OrderedContractResolver(),

                ReferenceLoopHandling = ReferenceLoopHandling.Serialize,

                PreserveReferencesHandling = PreserveReferencesHandling.Objects,

                TypeNameHandling = TypeNameHandling.Objects,

                TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Full,

            };

            TestRoundTrip(settings);

            TestQuestion(settings);

        }

        static void TestRoundTrip(JsonSerializerSettings settings)

        {

            Console.WriteLine("Testing round-trip:");

            var ruleFolder1 = new RuleFolder(new Entity())

            {

                Name = "Financial"

            };

            ruleFolder1.AddGenericRule(new RuleSet { Parent = ruleFolder1, Name = "SampleRuleSet" });

            var json = JsonConvert.SerializeObject(ruleFolder1, Formatting.Indented, settings);

            Console.WriteLine(json);

            var ruleFolder2 = JsonConvert.DeserializeObject<RuleFolder>(json, settings);

            Assert.IsTrue(ruleFolder1.Children.All(c => c.Parent == ruleFolder1));

            Assert.IsTrue(ruleFolder2.Children.All(c => c.Parent == ruleFolder2));

            Console.WriteLine("Test passed.");

        }   

        static void TestQuestion(JsonSerializerSettings settings)

        {

            var json = GetQuestionJson();

            Console.WriteLine("Testing JSON from question: ");

            Console.WriteLine(json);

            var ruleFolder = JsonConvert.DeserializeObject<RuleFolder>(json, settings);

            Assert.IsTrue(ruleFolder.Children.All(c => c.Parent == ruleFolder));

            Assert.IsTrue(ruleFolder.Children.OfType<ContainerRule>().All(c => c.Children.All(c2 => c2.Parent == c)));

            Console.WriteLine("Test passed.");

        }

        static string GetQuestionJson()

        {

            var assemblyName = typeof(TestClass).Assembly.GetName().FullName;

            var json = @"{

  ""$id"": ""119"",

  ""$type"": ""FSX.Client.Entities.RuleFolder, {0}"",

  ""Children"": [

    {

      ""$id"": ""120"",

      ""$type"": ""FSX.Client.Entities.RuleSet, {0}"",

      ""Children"": [

        {

          ""$id"": ""121"",

          ""$type"": ""FSX.Client.Entities.SetValue, {0}"",

          ""Id"": ""d835028e-f630-42fa-b77d-af1b8abbc7a3"",

          ""Name"": ""iterator"",

          ""Parent"": {

            ""$ref"": ""120""

          }

        },        

        {

          ""$id"": ""138"",

          ""$type"": ""FSX.Client.Entities.SetValue, {0}"",

          ""Id"": ""0101075c-c9dc-4f9d-9681-c72cc278e69f"",

          ""Name"": ""Set_pvFv"",

          ""Parent"": {

            ""$ref"": ""120""

          }

        }        

      ],

      ""Id"": ""b87ee6b6-a461-4669-bfce-31d5ed821458"",

      ""Name"": ""SampleRuleSet"",

      ""Parent"": {

        ""$ref"": ""119""

      }

    }

  ],

  ""Id"": ""5d950d31-1eec-4beb-ab11-21c20b183f81"",

  ""Name"": ""Financial"",

  ""Parent"": null

}";

            var thisJson = json.Replace("{0}", assemblyName);

            return thisJson;

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.CodeBase.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

}

​