using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

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/77482312/system-text-json-how-can-i-enforce-default-camelcase-jsonnamingpolicy-when-seri

​

#nullable enable

​

    [JsonConverter(typeof(FooModelJsonConverter))]

    public class FooModel

    {

​

        public enum State { STARTED, RUNNING, COMPLETED, FAILED };

​

        public Guid Id { get; set; }

        public string? AnotherId { get; set; }

        public string? Name { get; set; }

​

        [JsonConverter(typeof(JsonStringEnumConverter))]

        public State Status { get; set; }

​

        [JsonIgnore]

        public int? MajorVersion { get; set; } = 1;

        [JsonIgnore]

        public int? MinorVersion { get; set; } = 0;

​

    }

​

    public class FooModelJsonConverter: JsonConverter<FooModel>

    {

        public override FooModel Read(

            ref Utf8JsonReader reader,

            Type typeToConvert,

            JsonSerializerOptions options

        )

        {

​

            return

                JsonSerializer.Deserialize<FooModel>(ref reader, options)

                ?? throw new JsonException("FooModel could not be deserialized as it was null!");

​

        }

​

        public override void Write(

            Utf8JsonWriter writer,

            FooModel fooModel,

            JsonSerializerOptions options

        ) {

​

            writer.WriteStartObject();

​

            var majorVersion = fooModel.MajorVersion;

            var minorVersion = fooModel.MinorVersion;

​

            if (majorVersion == null || minorVersion == null)

                throw new JsonException(

                    $"Expected a 'Major' & 'Minor' attribute but one (or both) of them is null => MajorVersion: {majorVersion}\nMinorVersion: {minorVersion}!"

                );

​

            switch (majorVersion)

            {

                case 1:

                    writer.WritePropertyName(TryParseCamelCase(nameof(fooModel.Id), options, true));

                    JsonSerializer.Serialize(writer, fooModel.Id, options);

                    switch (minorVersion)

                    {

                        case 0:

                            break;

                        case 1:

                            break;

                        case 2:

                            break;

                        case 3:

                            writer.WritePropertyName(TryParseCamelCase(nameof(fooModel.AnotherId), options, true));

                            JsonSerializer.Serialize(writer, fooModel.AnotherId, options);

                            break;

                        default:

                            throw new JsonException($"Unexpected 'Minor' version attribute: {minorVersion}");

                    }

                    writer.WritePropertyName(TryParseCamelCase(nameof(fooModel.Name), options, true));

                    JsonSerializer.Serialize(writer, fooModel.Name, options);

                    writer.WritePropertyName(TryParseCamelCase(nameof(fooModel.Status), options, true));

                    JsonSerializer.Serialize(writer, fooModel.Status, options);

                    break;

                default:

                    throw new JsonException($"Unexpected 'Major' version attribute: {majorVersion}");

            }

​

            writer.WriteEndObject();

​

        }

​

        public static string TryParseCamelCase(string propertyName, JsonSerializerOptions options, bool disabled = false)

        {

​

            var namingPolicy = options.PropertyNamingPolicy;

​

            if (!disabled)

                return namingPolicy != null ? namingPolicy.ConvertName(propertyName) : propertyName;

            else

                return propertyName;

​

        }

​

    }

​

    class TestClass

    {

        public static void Test()

        {

            var foo = new FooModel

            {

                MinorVersion = 3,

                Name = "my name",

                AnotherId = "another id",

                Status = FooModel.State.RUNNING,

            };

            var options = new JsonSerializerOptions

            {

                Converters = { new FooModelJsonConverter() },

            };

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

            Console.WriteLine(json);

​

            //UNCOMMENT to get a StackOverflowException().

            //var foo2 = JsonSerializer.Deserialize<FooModel>(json, options);

            //foo2.Dump();

        }   

    }

​

    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;

            }

        }

    }

​