using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Buffers;

using System.Diagnostics;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Nodes;

​

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

​

//https://stackoverflow.com/questions/76583494/how-to-deserialize-json-array-of-objects-into-object-with-properties-in-c-sharp

// It seems converters cannot be written in .NET 4.x, see

// https://github.com/dotnet/docs/issues/22427 

//      Utf8JsonReader is obsolete #22427" -

// https://github.com/dotnet/runtime/issues/9871

//      Test build break when building release/uwp6.1 #9871 

// https://github.com/dotnet/runtime/issues/43253

//       System.Text.JSON.Serialization.JsonConverter issues with VB #43253 

//https://github.com/dotnet/runtime/issues?q=is%3Aissue++%22Types+with+embedded+references+are+not+supported+in+this+version%22+

​

​

    public class ObjectAsNameValueArrayConverter<T> : DefaultConverterFactory<T>

    {

        struct NameValuePair

        {

            public NameValuePair(string name, JsonNode value) { this.name = name; this.value = value; }

            public string name { get; set; }

            public JsonNode value { get; set;}

        }

        protected override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions modifiedOptions)

        {

            if (reader.TokenType == JsonTokenType.StartArray)

            {

                var array = JsonSerializer.Deserialize<List<NameValuePair>>(ref reader, modifiedOptions);

                var obj = new JsonObject(array.Select(p => new KeyValuePair<string, JsonNode>(p.name, p.value)));

                return obj.Deserialize<T>(modifiedOptions);

            }

            else

            {

                return base.Read(ref reader, typeToConvert, modifiedOptions);

            }

        }

        protected override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions modifiedOptions) 

        {

            var node = JsonSerializer.SerializeToNode(value, modifiedOptions);

            if (node is JsonObject obj)

                JsonSerializer.Serialize(writer, obj.Select(p => new NameValuePair(p.Key, p.Value)));

            else if (node != null)

                node.WriteTo(writer);

            else

                writer.WriteNullValue();

        }

    }

​

    public abstract class DefaultConverterFactory<T> : JsonConverterFactory

    {

        // Adapted from this answer https://stackoverflow.com/a/65430421/3744182

        // To https://stackoverflow.com/questions/65430420/how-to-use-default-serialization-in-a-custom-system-text-json-jsonconverter

        class DefaultConverter : JsonConverter<T> 

        {

            readonly JsonSerializerOptions modifiedOptions;

            readonly DefaultConverterFactory<T> factory;

​

            public DefaultConverter(JsonSerializerOptions modifiedOptions, DefaultConverterFactory<T> factory) 

            {

                this.modifiedOptions = modifiedOptions;

                this.factory = factory;

            }

​

            public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) { factory.Write(writer, value, modifiedOptions); }

            public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { return factory.Read(ref reader, typeToConvert, modifiedOptions); }

            public override bool CanConvert(Type typeToConvert) { return typeof(T).IsAssignableFrom(typeToConvert); }

        }

​

        protected virtual JsonSerializerOptions ModifyOptions(JsonSerializerOptions options)  { return options.CopyAndRemoveConverter(this.GetType()); }

​

        protected virtual T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions modifiedOptions) { return (T)JsonSerializer.Deserialize(ref reader, typeToConvert, modifiedOptions); }

​

        protected virtual void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions modifiedOptions) { JsonSerializer.Serialize(writer, value, modifiedOptions); }

​

        public override bool CanConvert(Type typeToConvert) { return typeof(T) == typeToConvert; }

​

        public sealed override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options) { return new DefaultConverter(ModifyOptions(options), this); }

    }

​

    public static class JsonSerializerExtensions

    {

        public static JsonSerializerOptions CopyAndRemoveConverter(this JsonSerializerOptions options, Type converterType)

        {

            var copy = new JsonSerializerOptions(options);

            for (var i = copy.Converters.Count - 1; i >= 0; i--)

                if (copy.Converters[i].GetType() == converterType)

                    copy.Converters.RemoveAt(i);

            return copy;

        }

    }

​

    //

​

    public class DateTimeConverterForCustomStandardFormatR : JsonConverter<DateTime>

    {

        static readonly DateTime UnixEpoch = new DateTime(621355968000000000L, DateTimeKind.Utc);

        // Adapted from this answer https://stackoverflow.com/a/66312313

        // By https://stackoverflow.com/users/827918/cdev

        // To https://stackoverflow.com/questions/66310421/deserialise-json-timestamp-with-system-text-json

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

        {

            return UnixEpoch.AddMilliseconds(reader.GetInt64());

        }

​

        public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)

        {

            //Span<T> may not be available in .NET 4.8

            // The "R" standard format will always be 29 bytes.

            //Span<byte> utf8Date = new byte[29];

            //

            //bool result = System.Buffers.Text.Utf8Formatter.TryFormat(value, utf8Date, out _, new StandardFormat('R'));

            //Debug.Assert(result);

            //https://learn.microsoft.com/en-us/dotnet/api/system.convert.toint64?view=net-7.0#system-convert-toint64(system-double)

            //Returns value, rounded to the nearest 64-bit signed integer.

            long ms = Convert.ToInt64((value - UnixEpoch).TotalMilliseconds);

            writer.WriteNumberValue(ms);

        }

    }

​

    public class MyViews

    {

        [JsonPropertyName("points")]

        [System.Text.Json.Serialization.JsonConverter(typeof(ObjectAsNameValueArrayConverter<Point>))]

        public Point Point { get; set; }

    }

​

    public class Point

    {

        public string title { get; set; }

        public string category { get; set; }

        //https://stackoverflow.com/questions/58154707/nullable-reference-types-in-net-framework-projects-not-working-with-intellisens

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

        public DateTime? created { get; set; } // Changed from DateTime.  You may need another converter for it.

        public int? version { get; set; }    

    }

​

    class TestClass

    {

        public static void Test()

        {

            var json = GetJson();

            var myViews = JsonSerializer.Deserialize<MyViews>(json);

            myViews.Dump();

            var json2 = JsonSerializer.Serialize(myViews, new JsonSerializerOptions { WriteIndented = true });

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

            Console.WriteLine(json2);

        }   

        static string GetJson() 

        {

            return @"{

    ""points"": [{

            ""name"": ""title"",

            ""value"": ""Test""

        }, {

            ""name"": ""category"",

            ""value"": null

        }, {

            ""name"": ""created"",

            ""value"": 1550743894373

        }, {

            ""name"": ""version"",

            ""value"": 1

    }]

}";

        }

    }

​

    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

            {

                Console.WriteLine("Convert.ToInt64(0.999) = {0}", Convert.ToInt64(0.999));

                Console.WriteLine("(long)(0.999) = {0}\n", (long)(0.999));

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​