using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

​

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/77245610/c-sharp-newtonsoft-how-do-deserialize-interface-containing-interface-containing

​

    public class InterfaceToConcreteConverter<TInterface, TConcrete> : JsonConverter where TConcrete : TInterface

    {

        static InterfaceToConcreteConverter()

        {

            // TConcrete should be a subtype of an abstract type, or an implementation of an interface.  If they

            // are identical an infinite recursion could result, so throw an exception.

            if (typeof(TInterface) == typeof(TConcrete))

                throw new InvalidOperationException(string.Format("typeof({0}) == typeof({1})", typeof(TInterface), typeof(TConcrete)));

        }

​

        public override bool CanConvert(Type objectType) =>objectType == typeof(TInterface);

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) => serializer.Deserialize(reader, typeof(TConcrete));

        public override bool CanWrite => false;

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => throw new NotImplementedException();

    }

  public interface IA

  {

    IB b { get; set; }

  }

​

  public class A : IA

  {

    public A() { }

​

    public IB b { get; set; }

  }

​

  public interface IB

  {

    IC c { get; set; }

  }

​

​

  public class B : IB

  {

    public B() { }

​

    public B( IC pC )

    {

      c = pC;

    }

​

    public IC c { get; set; }

  }

​

  public interface IC

  {

    int v { get; set; }

  }

​

  public class C : IC

  {

    public C() { }

​

    public C( int pV )

    {

      v = pV;

    }

​

    public int v { get; set; }

  }

​

    public static class JsonExtensions

    {

        public static JsonSerializerSettings DefaultSettings { get; } =

            new JsonSerializerSettings

            {

                Converters = { new InterfaceToConcreteConverter<IA, A>(), 

                              new InterfaceToConcreteConverter<IB, B>(),

                              new InterfaceToConcreteConverter<IC, C>(),}

            };

    }

​

​

    class TestClass

    {

        public static void Test()

        {

            IA a = new A();

            a.b = new B();

            a.b.c = new C();

            a.b.c.v = 1;

            var settings = new JsonSerializerSettings

            {

                Converters = { new InterfaceToConcreteConverter<IA, A>(), 

                              new InterfaceToConcreteConverter<IB, B>(),

                              new InterfaceToConcreteConverter<IC, C>(),}

            };

            string aSer = JsonConvert.SerializeObject( a, settings );

​

            A aDeser = JsonConvert.DeserializeObject<A>( aSer, JsonExtensions.DefaultSettings );

            var json2 = JsonConvert.SerializeObject( aDeser, settings );

            Assert.AreEqual(aSer, json2);

            Console.WriteLine("Round-tripped JSON for {0}:", aDeser);

            Console.WriteLine(json2);

            Assert.Catch(() =>new InterfaceToConcreteConverter<IA, IA>());

            Assert.Catch(() =>new InterfaceToConcreteConverter<IA, IA>());

            try

            {

                new InterfaceToConcreteConverter<IA, IA>();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Caught expected exception:\n {0}", ex);

            };

        }   

    }

​

    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;

            }

        }

    }

​