using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

using System.Reflection;

using System.Runtime.Serialization;

​

using System.Text.Json;

using System.Text.Json.Serialization;

​

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

​

//https://stackoverflow.com/questions/59059989/system-text-json-how-do-i-specify-a-custom-name-for-an-enum-value

​

    [Flags]

    public enum Example 

    {

      Trick = (1<<0),

      Treat = (1<<1),

      [EnumMember(Value = "Trick-Or-Treat")]

       TrickOrTreat = (1<<2),

    }

​

    public class RootObject

    {

        public Example? Example { get; set; }

    }

​

#nullable enable

​

    public class JsonEnumMemberStringEnumConverter : JsonConverterFactory

    {

        private readonly JsonNamingPolicy? namingPolicy;

        private readonly bool allowIntegerValues;

        private readonly JsonStringEnumConverter baseConverter;

​

        public JsonEnumMemberStringEnumConverter() : this(null, true) { }

​

        public JsonEnumMemberStringEnumConverter(JsonNamingPolicy? namingPolicy = null, bool allowIntegerValues = true)

        {

            this.namingPolicy = namingPolicy;

            this.allowIntegerValues = allowIntegerValues;

            this.baseConverter = new JsonStringEnumConverter(namingPolicy, allowIntegerValues);

        }

        public override bool CanConvert(Type typeToConvert) => baseConverter.CanConvert(typeToConvert);

​

        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)

        {

            var query = from field in typeToConvert.GetFields(BindingFlags.Public | BindingFlags.Static)

                        let attr = field.GetCustomAttribute<EnumMemberAttribute>()

                        where attr != null && attr.Value != null

                        select (field.Name, attr.Value);

            var dictionary = query.ToDictionary(p => p.Item1, p => p.Item2);

            if (dictionary.Count > 0)

                return new JsonStringEnumConverter(new DictionaryLookupNamingPolicy(dictionary, namingPolicy), allowIntegerValues).CreateConverter(typeToConvert, options);

            else

                return baseConverter.CreateConverter(typeToConvert, options);

        }

    }

    public class JsonNamingPolicyDecorator : JsonNamingPolicy 

    {

        readonly JsonNamingPolicy? underlyingNamingPolicy;

        public JsonNamingPolicyDecorator(JsonNamingPolicy? underlyingNamingPolicy) => this.underlyingNamingPolicy = underlyingNamingPolicy;

        public override string ConvertName (string name) => underlyingNamingPolicy?.ConvertName(name) ?? name;

    }

​

    internal class DictionaryLookupNamingPolicy : JsonNamingPolicyDecorator 

    {

        readonly Dictionary<string, string> dictionary;

        public DictionaryLookupNamingPolicy(Dictionary<string, string> dictionary, JsonNamingPolicy? underlyingNamingPolicy) : base(underlyingNamingPolicy) => this.dictionary = dictionary ?? throw new ArgumentNullException();

        public override string ConvertName (string name) => dictionary.TryGetValue(name, out var value) ? value : base.ConvertName(name);

    }

​

    class TestClass

    {

        public static void Test()

        {

            var values = Enum.GetValues(typeof(Example)).Cast<Example>().Concat(new [] { Example.Trick | Example.TrickOrTreat, Example.Treat | Example.TrickOrTreat, Example.Trick | Example.Treat | Example.TrickOrTreat }).ToArray();

            TestRoundTrip(values, null);

            TestRoundTrip(values, JsonNamingPolicy.CamelCase);

            TestRoundTrip(values, new TestNamingPolicy());

​

            TestSimple(null);

            TestSimple(JsonNamingPolicy.CamelCase);

            TestSimple(new TestNamingPolicy());

​

            Console.WriteLine("\nJson.NET output: ");

            var settings = new Newtonsoft.Json.JsonSerializerSettings

            {

                Converters = { new Newtonsoft.Json.Converters.StringEnumConverter(new TestNamingStrategy()) },

                Formatting = Newtonsoft.Json.Formatting.Indented,

            };

            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(values, settings));

        }   

​

        static void TestSimple(JsonNamingPolicy? namingPolicy)

        {

            var options = new JsonSerializerOptions

            {

                Converters = { new JsonEnumMemberStringEnumConverter(namingPolicy) },

                WriteIndented = false,

            };

            Assert.IsTrue(JsonSerializer.Serialize(Example.TrickOrTreat, options) == "\"Trick-Or-Treat\"");

            var test = new RootObject { Example = Example.TrickOrTreat };

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

            Assert.IsTrue(json.Contains("Trick-Or-Treat"));

        }

        public static void TestRoundTrip<T>(IEnumerable<T> values, JsonNamingPolicy? namingPolicy)

        {

            var options = new JsonSerializerOptions

            {

                Converters = { new JsonEnumMemberStringEnumConverter(namingPolicy) },

                WriteIndented = true,

            };

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

            Console.WriteLine(json);

            var newValues = JsonSerializer.Deserialize<T []>(json, options);

            Assert.That(values.SequenceEqual(newValues!));

        }   

    }

​

    public class TestNamingStrategy : Newtonsoft.Json.Serialization.NamingStrategy

    {

        protected override string ResolvePropertyName(string name) => "enum_" + name;

    }

​

    public class TestNamingPolicy : JsonNamingPolicy

    {

        public override string ConvertName (string name) => "enum_" + name;

    }

​

    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;

            }

        }

    }

​