using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

using System.Reflection;

using System.Collections.ObjectModel;

​

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

​

//https://stackoverflow.com/questions/59748093/can-system-text-json-jsonserializer-serialize-collections-on-a-read-only-propert

​

#nullable enable

​

    public class SomeItem {

        public string Label { get; set; }

    }

​

    public class SomeObjectWithItems {

​

        public string Label { get; set; }

​

        // Note this property is read-only but the collection it points to is read/write

        public ObservableCollection<SomeItem> Items { get; }

            = new ObservableCollection<SomeItem>();

    }

​

    public class SomeObjectWithItems<TCollection> : SomeObjectWithItems<TCollection, TCollection> where TCollection : ICollection<SomeItem>, new()

    {

    }

​

    public class SomeObjectWithItems<TCollection, TConcreteCollection> 

        where TCollection : IEnumerable<SomeItem>

        where TConcreteCollection : TCollection, new()

    {

        public string Label { get; set; }

​

        // Note this property is read-only but the collection it points to is read/write

        public TCollection Items { get; }

            = new TConcreteCollection();

    }

​

    public static partial class JsonExtensions

    {

        public static Action<JsonTypeInfo> CreateReadOnlyCollectionPropertySetters(Type type) => typeInfo => 

        {

            if (!type.IsAssignableFrom(typeInfo.Type))

                return;

            CreateReadOnlyCollectionPropertySetters(typeInfo);

        };

​

        public static void CreateReadOnlyCollectionPropertySetters(JsonTypeInfo typeInfo)

        {

            if (typeInfo.Kind != JsonTypeInfoKind.Object)

                return;

            // Add synthetic collection setters.

            foreach (var property in typeInfo.Properties)

            {

                if (property.Get != null && property.Set == null && property.PropertyType.GetCollectionItemType() is {} itemType)

                {

                    var method = typeof(JsonExtensions).GetMethod(nameof(JsonExtensions.CreateGetOnlyCollectionPropertySetter),

                                                                  BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)!;

                    var genericMethod = method.MakeGenericMethod(new[] { itemType });

                    var setter = genericMethod.Invoke(null, new object[] { property }) as Action<object, object?>;

                    property.Set = setter;

                }

            }

        }

        static Action<Object,Object?>? CreateGetOnlyCollectionPropertySetter<TItem>(JsonPropertyInfo property)

        {

            if (property.Get == null)

                return null;

            (var getter, var name) = (property.Get, property.Name);

            return (obj, value) =>

            {

                var oldValue = (ICollection<TItem>?)getter(obj);

                var newValue = value as ICollection<TItem>;

                if (newValue == oldValue)

                    return;

                else if (oldValue == null || oldValue.IsReadOnly)

                    throw new JsonException("Cannot populate list ${name} in ${obj}.");

                oldValue.Clear();

                if (newValue != null)

                    foreach (var item in newValue)

                        oldValue.Add(item);

            };

        }

​

        public static IEnumerable<Type> BaseTypesAndSelf(this Type type)

        {

            while (type != null)

            {

                yield return type;

                type = type.BaseType!;

            }

        }

​

        static readonly Dictionary<Type, Type> InterfaceToOpenConcreteTypes = new ()

            {

                [typeof(IEnumerable<>)] = typeof(List<>),

                [typeof(ICollection<>)] = typeof(List<>),

                [typeof(IList<>)] = typeof(List<>),

                [typeof(ISet<>)] = typeof(HashSet<>),

            };

        static readonly HashSet<Type> MutableCollectionBaseTypes = new []

            {

                typeof(List<>),

                typeof(Collection<>),

                typeof(HashSet<>),

                typeof(SortedSet<>),

                // Add others as required

            }

            .ToHashSet();

        static Type? GetCollectionItemType(this Type type) 

        {

            if (type.IsArray || type.IsPrimitive)

                return null;

            else if (type.IsInterface)

            {

                return type.IsGenericType && InterfaceToOpenConcreteTypes.TryGetValue(type.GetGenericTypeDefinition(), out var _)

                    ? type.GetGenericArguments()[0] : null;

            }

            else

            {

                return type.BaseTypesAndSelf()

                    .Where(t => t.IsGenericType && MutableCollectionBaseTypes.Contains(t.GetGenericTypeDefinition()))

                    .FirstOrDefault()?.GetGenericArguments()[0];

            }

        }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            var json = 

                """

                {

                  "Label": "First Set",

                  "Items": [

                    {

                      "Label": "Item 1"

                    },

                    {

                      "Label": "Item 2"

                    },

                    {

                      "Label": "Item 3"

                    },

                    {

                      "Label": "Item 4"

                    }

                  ]

                }

                """;

            Console.WriteLine(json);

            Console.WriteLine();

​

            Test(json);

            Console.WriteLine();

​

            TestGeneric<List<SomeItem>>(json);

            Console.WriteLine();

​

            TestGeneric<Collection<SomeItem>>(json);

            Console.WriteLine();

​

            TestGeneric<HashSet<SomeItem>>(json);

            Console.WriteLine();

            TestGeneric<IList<SomeItem>, List<SomeItem>>(json);

            Console.WriteLine();

​

            TestGeneric<ICollection<SomeItem>, List<SomeItem>>(json);

            Console.WriteLine();

​

            TestGeneric<IEnumerable<SomeItem>, List<SomeItem>>(json);

            Console.WriteLine();

​

            TestGeneric<ISet<SomeItem>, HashSet<SomeItem>>(json);

            Console.WriteLine();

        }

        static void Test(string json)

        {

            var options = new JsonSerializerOptions

            {

                TypeInfoResolver = new DefaultJsonTypeInfoResolver

                {

                    Modifiers = { 

                        JsonExtensions.CreateReadOnlyCollectionPropertySetters(typeof(SomeObjectWithItems)), 

                    },

                }

            };

            var obj = JsonSerializer.Deserialize<SomeObjectWithItems>(json, options);

            Console.WriteLine($"Item Count for '{obj?.Label}': {obj?.Items.Count}");    

            Console.WriteLine("Re-serialized {0};", obj);

            var newJson = JsonSerializer.Serialize(obj, options);

            Console.WriteLine(newJson);

            Assert.AreEqual(4, obj?.Items.Count ?? -1);

        }

        static void TestGeneric<TCollection, TConcreteCollection>(string json) 

            where TCollection : IEnumerable<SomeItem>

            where TConcreteCollection : TCollection, new()

        {

            var options = new JsonSerializerOptions

            {

                TypeInfoResolver = new DefaultJsonTypeInfoResolver

                {

                    Modifiers = { 

                        JsonExtensions.CreateReadOnlyCollectionPropertySetters(typeof(SomeObjectWithItems<TCollection, TConcreteCollection>)), 

                    },

                }

            };

            var obj = JsonSerializer.Deserialize<SomeObjectWithItems<TCollection, TConcreteCollection>>(json, options);

            Console.WriteLine($"Item Count for '{obj?.Label}': {obj?.Items.Count()}");              

            Console.WriteLine("Re-serialized {0};", obj);

            var newJson = JsonSerializer.Serialize(obj, options);

            Console.WriteLine(newJson);

            Assert.AreEqual(4, obj?.Items.Count() ?? -1);

        }

        static void TestGeneric<TCollection>(string json) where TCollection : ICollection<SomeItem>, new ()

        {

            TestGeneric<TCollection, TCollection>(json);

        }

    }

​

    public class Program

    {

        public static void Main(string[] args)

        {

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

            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;

            }

        }

    }

​