using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

using System.Reflection;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

​

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

​

//https://stackoverflow.com/questions/75774036/make-client-agnostic-to-api-naming-case-and-format

​

// To deserialize "true" to bool use BoolConverter from

// This answer https://stackoverflow.com/a/68685773

// To https://stackoverflow.com/questions/68682450/automatic-conversion-of-numbers-to-bools-migrating-from-newtonsoft-to-system-t

​

​

#nullable enable

​

    public static partial class JsonExtensions

    {

        public static Action<JsonTypeInfo> AddAlternateNamingPolicy(JsonNamingPolicy namingPolicy) => typeInfo => 

        {

            if (typeInfo.Kind != JsonTypeInfoKind.Object)

                return;

            var allNames = typeInfo.Properties.Select(p => p.Name).ToHashSet();

            for (int i = 0, n = typeInfo.Properties.Count; i < n; i++)

            {

                var property = typeInfo.Properties[i];

                if (property.Set == null || property.IsExtensionData || !(property.GetMemberName() is {} name))

                    continue;

                var jsonpropertynameattribute = property.AttributeProvider?.GetCustomAttributes(typeof(JsonPropertyNameAttribute), true).Cast<JsonPropertyNameAttribute>().SingleOrDefault();

                if (jsonpropertynameattribute != null && jsonpropertynameattribute.Name != null)

                {

                    // TODO: decide what you want to do if there is a [JsonPropertyName(name)] attribute applied to the property:

                    // 1. Skip the property since the override name should be used as-is without applying a naming policy (the current System.Text.Json behavior).

                    // 2. Apply the namingPolicy to the original member name.

                    // 2. Apply the namingPolicy to the override name.

                }

                var alternateName = namingPolicy.ConvertName(name);

                if (alternateName == property.Name || allNames.Contains(alternateName))

                    continue;

                var alternateProperty = typeInfo.CreateJsonPropertyInfo(property.PropertyType, alternateName);

                alternateProperty.Set = property.Set;

                alternateProperty.ShouldSerialize = static (_, _) => false;

                alternateProperty.AttributeProvider = property.AttributeProvider;

                alternateProperty.CustomConverter = property.CustomConverter;

                alternateProperty.IsRequired = false;

                alternateProperty.NumberHandling = property.NumberHandling;

                typeInfo.Properties.Add(alternateProperty);

                allNames.Add(alternateName);

            }

        };

​

        public static string? GetMemberName(this JsonPropertyInfo property) => (property.AttributeProvider as MemberInfo)?.Name;

    }

​

    // SnakeCaseNamingPolicy and StringUtils taken from this answer https://stackoverflow.com/a/58576400

    // By https://stackoverflow.com/users/4913418/muhammad-hannan

    // To https://stackoverflow.com/questions/58570189/is-there-a-built-in-way-of-using-snake-case-as-the-naming-policy-for-json-in-asp

​

    public class SnakeCaseNamingPolicy : JsonNamingPolicy

    {

        public static SnakeCaseNamingPolicy Instance { get; } = new SnakeCaseNamingPolicy();

        public override string ConvertName(string name) =>

            // Conversion to other naming convention goes here. Like SnakeCase, KebabCase etc.

            name.ToSnakeCase();

    }

​

    public static class StringUtils

    {

        public static string ToSnakeCase(this string str) => 

            string.Concat(str.Select((x, i) => i > 0 && char.IsUpper(x) ? "_" + x.ToString() : x.ToString())).ToLower();

    }

​

    class Demo 

    {

        public string SomeName { get; set; } // FIXED added "public"

        public double SomeValue { get; set; } // FIXED added "public"

        public bool HasValue { get; set; } // FIXED added "public"

        [JsonIgnore] public string IgnoreMe { set => throw new Exception(); get => throw new Exception(); }

    }

​

    class TestClass

    {

        public static void Test()

        {

            foreach (var json in GetJson())

            {

                var options = new JsonSerializerOptions

                {

                    // Handle both camel case and title case by making property name deserialization case insensitive:

                    PropertyNameCaseInsensitive = true,  

                    // Handle snake case also:

                    TypeInfoResolver = new DefaultJsonTypeInfoResolver

                    {

                        Modifiers = { JsonExtensions.AddAlternateNamingPolicy(SnakeCaseNamingPolicy.Instance) },

                    },

                    // Other options as required.

                    NumberHandling = JsonNumberHandling.AllowReadingFromString, // Necessary to deserialize "5.0" to a double

                    Converters = { new BoolConverter() }, // Necessary to deserialize "true" to a bool

                };

                var demo = JsonSerializer.Deserialize<Demo>(json, options);

                Assert.That(demo?.SomeName == "X" && demo.SomeValue == 5.0 && demo.HasValue == true);

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

                Console.WriteLine("Re-serialized {0}: {1}", demo, newJson);

            }

        }

        static IEnumerable<string> GetJson() => new []

        {

            """

            { "SomeName": "X", "SomeValue": "5.0", "HasValue": "true", "IgnoreMe" : "crash" }

            """,

            """

            { "someName": "X", "someValue": "5.0", "hasValue": "true", "ignoreMe" : "crash" }

            """,

            """

            { "some_name": "X", "some_value": "5.0", "has_value": "true", "ignore_me" : "crash" }

            """,

            """

            { "SomeName": "X", "someValue": "5.0", "has_value": "true", "ignore_me" : "crash" }

            """,

        };

    }

​

    // Copied from this answer https://stackoverflow.com/a/68685773

    // To https://stackoverflow.com/questions/68682450/automatic-conversion-of-numbers-to-bools-migrating-from-newtonsoft-to-system-t

    public class BoolConverter : JsonConverter<bool>

    {

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

            writer.WriteBooleanValue(value);

​

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

            reader.TokenType switch

            {

                JsonTokenType.True => true,

                JsonTokenType.False => false,

                JsonTokenType.String => bool.TryParse(reader.GetString(), out var b) ? b : throw new JsonException(),

                JsonTokenType.Number => reader.TryGetInt64(out long l) ? Convert.ToBoolean(l) : reader.TryGetDouble(out double d) ? Convert.ToBoolean(d) : false,

                _ => throw new JsonException(),

            };

    }

​

    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;

            }

        }

    }

​