using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Reflection;

​

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

​

#nullable enable

​

//https://stackoverflow.com/questions/76269101/how-to-implement-custom-jsonconverter-based-on-property-names

​

    public static partial class JsonExtensions

    {

        public static Action<JsonTypeInfo> AddMemberAwareDoubleConverters { get; } = static typeInfo => 

        {

            if (typeInfo.Kind != JsonTypeInfoKind.Object)

                return;

            foreach (var property in typeInfo.Properties)

                if (property.CustomConverter == null && property.GetMemberInfo() is {} memberInfo)

                    if (property.PropertyType == typeof(double)) 

                        property.CustomConverter = new MemberAwareDoubleConverter(memberInfo);

                    else if (property.PropertyType == typeof(double?))

                        property.CustomConverter = new MemberAwareNullableDoubleConverter(memberInfo);

        };

​

        public static MemberInfo? GetMemberInfo(this JsonPropertyInfo property) => (property.AttributeProvider as MemberInfo);

    }

​

    class MemberAwareDoubleConverter : JsonConverter<double>

    {

        MemberInfo MemberInfo { get; }

        public MemberAwareDoubleConverter(MemberInfo memberInfo) => this.MemberInfo = memberInfo ?? throw new ArgumentNullException(nameof(memberInfo));

        public override void Write(Utf8JsonWriter writer, double value, JsonSerializerOptions options) =>

            writer.WriteRawValue($"{JsonSerializer.Serialize(value)} /* double from {MemberInfo.Name} */", true);

        public override double Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => 

            // TODO: Handle "NaN", "Infinity", "-Infinity"

            reader.GetDouble();

    }

​

    class MemberAwareNullableDoubleConverter : JsonConverter<double?>

    {

        public override bool HandleNull => true;

        MemberInfo MemberInfo { get; }

        public MemberAwareNullableDoubleConverter(MemberInfo memberInfo) => this.MemberInfo = memberInfo ?? throw new ArgumentNullException(nameof(memberInfo));

​

        public override void Write(Utf8JsonWriter writer, double? value, JsonSerializerOptions options) =>

            writer.WriteRawValue($"{JsonSerializer.Serialize(value)} /* double? from {MemberInfo.Name} */", true);

        public override double? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => 

            // TODO: Handle "NaN", "Infinity", "-Infinity"

            reader.TokenType switch

            {

                JsonTokenType.Number => reader.GetDouble(),

                JsonTokenType.Null => null,

                _ => throw new JsonException(),

            };

    }

​

    public class Root

    {

        public double RootDoubleValue { get; set; }

        public double? RootNullableValue { get; set; }

        public List<Item> Items { get; set; } = new ();

    }

​

    public record Item(double ItemDoubleValue, double? ItemNullableValue);

​

    class TestClass

    {

        public static void Test()

        {

            var root = new Root

            {

                RootDoubleValue = 101.01,

                RootNullableValue = 202.02,

                Items = { new(2101.01, null) },

            };

            var options = new JsonSerializerOptions

            {

                TypeInfoResolver = new DefaultJsonTypeInfoResolver

                {

                    Modifiers = { JsonExtensions.AddMemberAwareDoubleConverters },

                },

                // Others as required

                WriteIndented = true,

                ReadCommentHandling = JsonCommentHandling.Skip,

            };

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

            Console.WriteLine(json);

            var root2 = JsonSerializer.Deserialize<Root>(json, options);

            var json2 = JsonSerializer.Serialize(root2, options);

            Assert.AreEqual(json, json2);

        }   

    }

​

    public static class ObjectExtensions

    {

        public static T ThrowOnNull<T>(this T? value) where T : class => value ?? throw new ArgumentNullException();

    }

​

    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

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​