using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Reflection;

​

using System.Text.Json;

using System.Text.Json.Serialization;

​

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

​

//https://stackoverflow.com/questions/71688136/how-can-i-serialize-a-property-in-an-inherited-icollectiont-class

​

#nullable enable

​

    [System.Text.Json.Serialization.JsonConverter(typeof(ItemCollectionJsonConverter))]

    public partial class ItemCollection<T> : ICollection<T> {

        internal ItemCollection(List<T> items) { // I added this for use by the converter

            Items = items ?? throw new ArgumentNullException();

        }

        public ItemCollection() {

            Items = new List<T>();

        }

        public List<T> Items { get; set; }

        // Remainder omitted

    }

    public class ItemCollectionJsonConverter : JsonConverterFactory

    {

        public override bool CanConvert(Type typeToConvert) => GetItemCollectionValueType(typeToConvert) != null;

​

        public override JsonConverter CreateConverter(Type type, JsonSerializerOptions options)

            => (JsonConverter)Activator.CreateInstance(typeof(ItemCollectionJsonConverterInner<>).MakeGenericType(GetItemCollectionValueType(type)!))!;

​

        static Type? GetItemCollectionValueType(Type type) =>

            (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ItemCollection<>)) ? type.GetGenericArguments()[0] : null;

​

        class ItemCollectionJsonConverterInner<T> : JsonConverter<ItemCollection<T>>

        {

            class ItemCollectionDTO

            {

                public List<T>? Items { get; set; }

                // Add other properties here

            }

            public override ItemCollection<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>

                // TODO: Decide whether to throw on null

                new ItemCollection<T>((JsonSerializer.Deserialize<ItemCollectionDTO>(ref reader, options)?.Items) ?? throw new JsonException());

            public override void Write(Utf8JsonWriter writer, ItemCollection<T> value, JsonSerializerOptions options) =>

                JsonSerializer.Serialize(writer, new ItemCollectionDTO { Items = value.Items }, options);

        }

    }

​

    public partial class ItemCollection<T>

    {

        #region ICollection<T> Members

​

        public void Add(T item) => Items.Add(item);

        public void Clear() =>  Items.Clear();

        public bool Contains(T item) => Items.Contains(item);

        public void CopyTo(T[] array, int arrayIndex) => Items.CopyTo(array, arrayIndex);

        public int Count => Items.Count;

        public bool IsReadOnly => ((IList<T>)Items).IsReadOnly;

        public bool Remove(T item) => Items.Remove(item);

​

        #endregion

​

        #region IEnumerable<T> Members

​

        public IEnumerator<T> GetEnumerator() => Items.GetEnumerator();

​

        #endregion

​

        #region IEnumerable Members

​

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();

​

        #endregion

    }

​

    class TestClass

    {

        public static void Test()

        {

            var collection = new ItemCollection<string>

            {

                "a", "b", "c"

            };

            var options = new JsonSerializerOptions

            {

                WriteIndented = true,

            };

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

            Console.WriteLine(json);

            var collection2 = JsonSerializer.Deserialize<ItemCollection<string>>(json, options);

​

            Assert.IsTrue(collection.SequenceEqual(collection2!));

        }   

    }

​

    public class Program

    {

        public static void Main()

        {

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

            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;

            }

        }

    }

​