using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections.Concurrent;

using System.Runtime.Serialization;

using System.Reflection;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

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

​

using DataClasses;

​

//https://stackoverflow.com/questions/79698183/serialize-deserialize-a-referenceloop-of-iserializable-objects-with-newtonsoft-j

​

#nullable enable

​

public static class SerializationInfoExtensions

{

    static Lazy<Func<SerializationInfo, string, Type, object?>?> GetValueNoThrowFunc = new(

        () =>

        {

            var method = typeof(SerializationInfo).GetMethod("GetValueNoThrow", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, new [] { typeof(string), typeof(Type)});

            if (method == null)

                return null;

            return (Func<SerializationInfo, string, Type, object?>)Delegate.CreateDelegate(typeof(Func<SerializationInfo, string, Type, object?>), null, method);

        }

        );

    public static  object? GetValueNoThrow(this SerializationInfo info, string name, Type type)

    {

        ArgumentNullException.ThrowIfNull(info);

        ArgumentNullException.ThrowIfNull(name);

        ArgumentNullException.ThrowIfNull(type);

        var func = GetValueNoThrowFunc.Value;

        if (func != null)

            return func(info, name, type);

​

        // Fallback in case GetValueNoThrow() is removed by MSFT.

        try

        {

            return info.GetValue(name, type);

        }

        catch (SerializationException)

        {

            return null;

        }

    }

}

​

#nullable disable

​

namespace DataClasses

{

    [Serializable]

    internal sealed class User : ISerializable

    {

        private User(SerializationInfo info, StreamingContext context)

        {

            Name = (string)info.GetValue(nameof(Name), typeof(string));

            Group = (UserGroup)info.GetValueNoThrow(nameof(Group), typeof(UserGroup));

        }

​

        public string Name { get; set; }

        public UserGroup Group { get; set; }

​

        internal User()

        {}

​

        public void GetObjectData(SerializationInfo info, StreamingContext context)

        {

            info.AddValue(nameof(Name), Name);

            info.AddValue(nameof(Group), Group);

        }

    }

​

    [Serializable]

    internal sealed class UserGroup : ISerializable

    {

        private UserGroup(SerializationInfo info, StreamingContext context)

        {

            Name = (string)info.GetValue(nameof(Name), typeof(string));

            DefaultUser = (User)info.GetValueNoThrow(nameof(DefaultUser), typeof(User));

        }

​

        public string Name { get; set; }

        public User DefaultUser { get; set; }

​

        internal UserGroup()

        { }

​

        public void GetObjectData(SerializationInfo info, StreamingContext context)

        {

            info.AddValue(nameof(Name), Name);

            info.AddValue(nameof(DefaultUser), DefaultUser);

        }

    }

}

​

​

    class TestClass

    {

        public static void Test()

        {

            var user = new DataClasses.User { Name = "User" };

            var group = new DataClasses.UserGroup { Name = "Group", DefaultUser = user };

            user.Group = group;

​

            var settings = new JsonSerializerSettings

            {

                ReferenceLoopHandling = ReferenceLoopHandling.Ignore

            };

​

            var json = JsonConvert.SerializeObject(user, settings);

            var userRestored = JsonConvert.DeserializeObject<DataClasses.User>(json);

            userRestored.Dump();

        }   

    }

​

    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("{0} version: {1}", typeof(JsonSerializer).Namespace, typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​