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.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

using System.Text.Json.Nodes;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

#nullable enable

​

//https://stackoverflow.com/questions/77629944/can-i-force-system-text-json-jsonserializer-to-work-non-recursively

​

    [JsonConverter(typeof(WholeConverter))]

    public class Whole {

        public List<Node> allPossibleNodes = new List<Node>();

    }

​

    public class Node {

        [JsonIgnore]

        public List<Node> neighbors = new List<Node>();

    }

    class WholeConverter : JsonConverter<Whole>

    {

        struct WholeDto

        {

            [JsonPropertyOrder(1)]

            public List<Node>? allPossibleNodes { get; set; }

            [JsonPropertyOrder(2)]

            public IEnumerable<NeighborItem>? neighborTable { get; set; }

        }

        record struct NeighborItem(Node node, List<Node> neighbors);

        public override Whole? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

        {

            var dto = JsonSerializer.Deserialize<WholeDto>(ref reader, options);

            foreach (var item in dto.neighborTable ?? Enumerable.Empty<NeighborItem>().Where(i => i.node != null))

                item.node.neighbors = item.neighbors;

            var whole = new Whole();

            if (dto.allPossibleNodes != null)

                whole.allPossibleNodes = dto.allPossibleNodes;

            return whole;

        }

​

        public override void Write(Utf8JsonWriter writer, Whole value, JsonSerializerOptions options) =>

            JsonSerializer.Serialize(writer,

                new WholeDto 

                { 

                    allPossibleNodes = value.allPossibleNodes,

                    neighborTable = value.allPossibleNodes.Where(n => n.neighbors.Count > 0).Select(n => new NeighborItem(n, n.neighbors)),

                },

                options);

    }

​

    class TestClass

    {

        static JsonSerializerOptions options = new () {

            WriteIndented = true,

            IncludeFields = true,

            IgnoreReadOnlyProperties = true,

            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,

            ReferenceHandler = ReferenceHandler.Preserve,

        };

​

        public static Whole CreateWhole()

        {

            var w = new Whole();

            Node? p = null; //previous

            for (int i = 0; i < 3; i++) {

                var n = new Node();

                w.allPossibleNodes.Add(n);

                if (p != null) {

                    n.neighbors.Add(p);

                    p.neighbors.Add(n);

                }

                p = n;

            }

            return w;

        }

​

        public static void Test()

        {

            var whole = CreateWhole();

            var json = JsonSerializer.Serialize(whole, options);

            Console.WriteLine(json);

            var whole2 = JsonSerializer.Deserialize<Whole>(json, options)!;

            var json2 = JsonSerializer.Serialize(whole2, options);

            // Assert that the re-serialized JSON is consistent with first serialization.

            Assert.That(json == json2);

            // Assert that the node and neighbor lists are consistent.

            Assert.That(whole.allPossibleNodes.Count == whole2.allPossibleNodes.Count);

            Assert.That(whole.allPossibleNodes.Select(n => n.neighbors.Count).SequenceEqual(whole2.allPossibleNodes.Select(n => n.neighbors.Count)));

            Assert.That(whole.allPossibleNodes.SelectMany(n => n.neighbors).Select(n => whole.allPossibleNodes.IndexOf(n))

                        .SequenceEqual(whole2.allPossibleNodes.SelectMany(n => n.neighbors).Select(n => whole2.allPossibleNodes.IndexOf(n))));

        }   

    }

​

    public class Program

    {

        public static void Main()

        {

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

            Console.WriteLine("System.Text.Json version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​