using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Reflection;

using System.Diagnostics;

using System.ComponentModel;

using System.Globalization;

using System.IO;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Converters;

​

    public static class SerializationExtensions

    {

        static bool EnumTypeIsSigned(this Type tEnum)

        {

            var underlyingType = Enum.GetUnderlyingType(tEnum);

            if (underlyingType == typeof(long) || underlyingType == typeof(int) || underlyingType == typeof(short) || underlyingType == typeof(sbyte))

                return true;

            if (underlyingType == typeof(ulong) || underlyingType == typeof(uint) || underlyingType == typeof(ushort) || underlyingType == typeof(byte))

                return false;

            throw new ArgumentException(tEnum.Name + " is not an enum type");

        }

​

        static bool IsSigned<TEnum>(this TEnum value) where TEnum : struct, IConvertible, IComparable, IFormattable

        {

            return typeof(TEnum).EnumTypeIsSigned();

        }

​

        public static void WriteEnum<TEnum>(this BinaryWriter writer, TEnum value) where TEnum : struct, IConvertible, IComparable, IFormattable

        {

            if (value.IsSigned())

            {

                var underlyingValue = checked(value.ToInt64(NumberFormatInfo.InvariantInfo));

                writer.Write(underlyingValue);

            }

            else

            {

                var underlyingValue = checked(value.ToUInt64(NumberFormatInfo.InvariantInfo));

                writer.Write(underlyingValue);

            }

        }

​

        public static TEnum ReadEnum<TEnum>(this BinaryReader reader) where TEnum : struct, IConvertible, IComparable, IFormattable

        {

            if (typeof(TEnum).EnumTypeIsSigned())

            {

                var underlyingValue = reader.ReadInt64();

                return checked((TEnum)Enum.ToObject(typeof(TEnum), underlyingValue));

            }

            else

            {

                var underlyingValue = reader.ReadUInt64();

                return checked((TEnum)Enum.ToObject(typeof(TEnum), underlyingValue));

            }

        }

    }

​

    [Flags]

    public enum SByteEnum : sbyte

    {

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

        One = ((sbyte)1 << 1),

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

        Six = ((sbyte)1 << 6),

    };

​

    [Flags]

    public enum ShortEnum : short

    {

        Zero = (1 << 0),

        One = (1 << 1),

        Two = (1 << 2),

        Seven = (1 << 7),

        Fourteen = (1 << 14),

    };

​

    [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 LongEnum : 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),

    };

​

    [Flags]

    public enum ByteEnum : byte

    {

        Zero = (1 << 0),

        One = (1 << 1),

        Two = (1 << 2),

        Six = (1 << 7),

        Seven = (1 << 7),

    };

​

    [Flags]

    public enum UShortEnum : ushort

    {

        Zero = (1 << 0),

        One = (1 << 1),

        Two = (1 << 2),

        Seven = (1 << 7),

        Fourteen = (1 << 14),

        Fifteen = (1 << 15),

    };

​

    [Flags]

    public enum UIntEnum : uint

    {

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

        One = ((uint)1 << 1),

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

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

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

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

    };

​

    [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 TestClass

    {

        public static void Test()

        {

            byte [] data;

​

            List<Enum> values = new List<Enum>();

​

            using (var ms = new MemoryStream())

            {

                using (var writer = new BinaryWriter(ms))

                {

                    writer.WriteEnum(SByteEnum.Six);

                    values.Add(SByteEnum.Six);

                    writer.WriteEnum(ByteEnum.Six);

                    values.Add(ByteEnum.Six);

                    writer.WriteEnum(ShortEnum.Fourteen);

                    values.Add(ShortEnum.Fourteen);

                    writer.WriteEnum(UShortEnum.Fourteen);

                    values.Add(UShortEnum.Fourteen);

                    writer.WriteEnum(IntEnum.ThirtyOne);

                    values.Add(IntEnum.ThirtyOne);

                    writer.WriteEnum(UIntEnum.ThirtyOne);

                    values.Add(UIntEnum.ThirtyOne);

                    writer.WriteEnum(LongEnum.SixtyThree);

                    values.Add(LongEnum.SixtyThree);

                    writer.WriteEnum(ULongEnum.SixtyThree);

                    values.Add(ULongEnum.SixtyThree);

                    writer.WriteEnum(UnflaggedLongEnum.SixtyThree);

                    values.Add(UnflaggedLongEnum.SixtyThree);

                    writer.WriteEnum(UnflaggedULongEnum.SixtyThree);

                    values.Add(UnflaggedULongEnum.SixtyThree);

                }

                data = ms.ToArray();

            }

​

            using (var ms = new MemoryStream(data))

            {

                using (var reader = new BinaryReader(ms))

                {

                    int count = 0;

                    TestRead<SByteEnum>(reader, values[count++]);

                    TestRead<ByteEnum>(reader, values[count++]);

                    TestRead<ShortEnum>(reader, values[count++]);

                    TestRead<UShortEnum>(reader, values[count++]);

                    TestRead<IntEnum>(reader, values[count++]);

                    TestRead<UIntEnum>(reader, values[count++]);

                    TestRead<LongEnum>(reader, values[count++]);

                    TestRead<ULongEnum>(reader, values[count++]);

                    TestRead<UnflaggedLongEnum>(reader, values[count++]);

                    TestRead<UnflaggedULongEnum>(reader, values[count++]);

                }

            }

            Console.WriteLine("The following enums were serialized and deserialized successfully: ");

            Console.WriteLine(JsonConvert.SerializeObject(values, new StringEnumConverter()));

        }

​

        static void TestRead<TEnum>(BinaryReader reader, Enum oldValue) where TEnum : struct, IConvertible, IComparable, IFormattable

        {

            var newValue = reader.ReadEnum<TEnum>();

            if (!newValue.Equals(oldValue))

                throw new InvalidOperationException("Incorrect deserialized values");

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            TestClass.Test();

        }

    }

​