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 Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

    // https://stackoverflow.com/questions/46231934/modify-add-property-via-custom-icontractresolver

    public class StringEnumContractResolver : DefaultContractResolver

    {

        readonly StringEnumConverter converter;

​

        public StringEnumContractResolver() : this(true, false) { }

​

        public StringEnumContractResolver(bool allowIntegerValue, bool camelCaseText)

        {

            this.converter = new StringEnumConverter { AllowIntegerValues = allowIntegerValue, CamelCaseText = camelCaseText };

        }

​

        protected override JsonPrimitiveContract CreatePrimitiveContract(Type objectType)

        {

            var contract = base.CreatePrimitiveContract(objectType);

            var type = Nullable.GetUnderlyingType(contract.UnderlyingType) ?? contract.UnderlyingType;

            if (type.IsEnum && contract.Converter == null)

                contract.Converter = converter;

            return contract;

        }

    }

​

    [Flags]

    public enum IntEnum : int

    {

        Zero = (1 << 0),

        One = (1 << 1),

        Two = (1 << 2),

        Seven = (1 << 7),

        Fourteen = (1 << 14),

        ThirtyOne = (1 << 31),

    };

​

    [Flags]

    public enum ByteEnum : byte

    {

        Zero = (1 << 0),

        One = (1 << 1),

        Two = (1 << 2),

        Six = (1 << 7),

        Seven = (1 << 7),

    };

​

    [Flags]

    public enum ULongEnum : ulong

    {

        Zero = ((ulong)1 << 0),

        One = ((ulong)1 << 1),

        Two = ((ulong)1 << 2),

        Seven = ((ulong)1 << 7),

        Fourteen = ((ulong)1 << 14),

        ThirtyOne = ((ulong)1 << 31),

        ThirtyTwo = ((ulong)1 << 32),

        ThirtyThree = ((ulong)1 << 33),

        Sixty = ((ulong)1 << 60),

        SixtyOne = ((ulong)1 << 61),

        SixtyTwo = ((ulong)1 << 62),

        SixtyThree = ((ulong)1 << 63),

    };

​

    public enum UnflaggedLongEnum : long

    {

        Zero = ((long)1 << 0),

        One = ((long)1 << 1),

        Two = ((long)1 << 2),

        Seven = ((long)1 << 7),

        Fourteen = ((long)1 << 14),

        ThirtyOne = ((long)1 << 31),

        ThirtyTwo = ((long)1 << 32),

        SixtyTwo = ((long)1 << 62),

        SixtyThree = ((long)1 << 63),

    };

​

    public enum UnflaggedULongEnum : ulong

    {

        Zero = ((ulong)1 << 0),

        One = ((ulong)1 << 1),

        Two = ((ulong)1 << 2),

        Seven = ((ulong)1 << 7),

        Fourteen = ((ulong)1 << 14),

        ThirtyOne = ((ulong)1 << 31),

        ThirtyTwo = ((ulong)1 << 32),

        ThirtyThree = ((ulong)1 << 33),

        Sixty = ((ulong)1 << 60),

        SixtyOne = ((ulong)1 << 61),

        SixtyTwo = ((ulong)1 << 62),

        SixtyThree = ((ulong)1 << 63),

    };

​

    [Flags]

    public enum CompositeExample : ulong

    {

        None = 0,

        Foo1 = 1,

        Foo2 = 2,

        Foo3 = 3,

        Foo4 = 4,

        Foo5 = 5,

        Foo6 = 6,

        Foo7 = 7,

        Foo8 = 8,

    };

​

    public class RootObject<TEnum>

    {

        public RootObject()

        {

            this.List = new List<TEnum>();

            this.Dictionary = new Dictionary<TEnum, string>();

        }

​

        public TEnum Property { get; set; }

​

        public object UntypedProperty { get; set; }

        public List<TEnum> List { get; set; }

​

        public Dictionary<TEnum, string> Dictionary { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            Test<UnflaggedULongEnum>();

            Test<ULongEnum>();

            Test<ByteEnum>();

            Test<IntEnum>(new[] { IntEnum.Fourteen, (IntEnum)(-1), IntEnum.Two, IntEnum.Seven | IntEnum.One | IntEnum.Two });

            Test<CompositeExample>();

​

            Console.WriteLine("\nDone.");

        }

​

        static void Test<TEnum>() where TEnum : struct, IComparable

        {

            Console.WriteLine(string.Format("\nTesting {0}", typeof(TEnum)));

​

            Test(Enum.GetValues(typeof(TEnum)).Cast<TEnum>());

            Test(Enum.GetValues(typeof(TEnum)).Cast<TEnum>().Select(e => (TEnum?)e).Concat(new[] { (TEnum?)null }));

        }

​

        public static void Test<TEnum>(IEnumerable<TEnum> values)

        {

            var root = new RootObject<TEnum>

            {

                Property = values.FirstOrDefault(),

                UntypedProperty = values.LastOrDefault(),

                List = values.ToList(),

                Dictionary = values.Distinct().Where(v => v != null).ToDictionary(v => v, v => "hello " + v.ToString()),

            };

​

            var settings = new JsonSerializerSettings

            {

                ContractResolver = new StringEnumContractResolver(),

            };

​

            var json = JsonConvert.SerializeObject(root, Formatting.Indented, settings);

​

            Console.WriteLine(json);

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            IsTrue(value, "failed");

        }

​

        public static void IsTrue(bool value, string message)

        {

            if (value == false)

                throw new AssertionFailedException(message ?? "failed");

        }

    }

​