using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Serialization;

using System.Xml;

using System.IO;

using System.Diagnostics;

using System.Collections.ObjectModel;

using System.Threading;

using System.ComponentModel;

using System.Xml.Linq;

using System.Reflection;

using System.Data;

using System.Xml.Schema;

using System.Text.RegularExpressions;

using System.Net;

using System.Xml.XPath;

using System.Globalization;

using System.ComponentModel.DataAnnotations;

using System.Collections;

using System.Runtime.InteropServices;

using System.Runtime.Serialization;

​

    // https://stackoverflow.com/questions/42990069/get-element-of-an-enum-by-sending-xmlenumattribute-c

​

    public enum myEnum

    {

        [System.Xml.Serialization.XmlEnumAttribute("01010101")]

        Item01010101,

        [System.Xml.Serialization.XmlEnumAttribute("10101500")]

        Item10101500

    }

​

    [Flags]

    public enum myFlagsEnum

    {

        [System.Xml.Serialization.XmlEnumAttribute("Flag0")]

        Zero = (1 << 0),

        [System.Xml.Serialization.XmlEnumAttribute("Flag1")]

        One = (1 << 1),

        [System.Xml.Serialization.XmlEnumAttribute("Flag2")]

        Two = (1 << 2),

        [System.Xml.Serialization.XmlEnumAttribute("Flag7")]

        Seven = (1 << 7),

        [System.Xml.Serialization.XmlEnumAttribute("Flag14")]

        Fourteen = (1 << 14),

    }

​

    public static partial class XmlEnumExtensions

    {

        public static TEnum FromReflectedXmlValue<TEnum>(this string xml) where TEnum : struct, IConvertible, IFormattable

        {

            // Adapted from https://stackoverflow.com/questions/35294530/c-sharp-getting-all-enums-value-by-attribute

            var obj = (from field in typeof(TEnum).GetFields(BindingFlags.Public | BindingFlags.Static)

                       from attr in field.GetCustomAttributes<XmlEnumAttribute>()

                       where attr != null && attr.Name == xml

                       select field.GetValue(null)).SingleOrDefault();

            if (obj != null)

                return (TEnum)obj;

​

            // OK, maybe there is no XmlEnumAttribute override so match on the name.

            return (TEnum)Enum.Parse(typeof(TEnum), xml, false);

        }

    }

​

    public static partial class XmlExtensions

    {

        static XmlExtensions()

        {

            noStandardNamespaces = new XmlSerializerNamespaces();

            noStandardNamespaces.Add("", ""); // Disable the xmlns:xsi and xmlns:xsd attributes.

        }

​

        readonly static XmlSerializerNamespaces noStandardNamespaces;

        internal const string RootNamespace = "XmlExtensions";

        internal const string RootName = "Root";

​

        public static TEnum FromXmlValue<TEnum>(this string xml) where TEnum : struct, IConvertible, IFormattable

        {

            var element = new XElement(XName.Get(RootName, RootNamespace), xml);

            return element.Deserialize<XmlExtensionsEnumWrapper<TEnum>>().Value;

        }

​

        public static T Deserialize<T>(this XContainer element, XmlSerializer serializer = null)

        {

            using (var reader = element.CreateReader())

            {

                object result = (serializer ?? new XmlSerializer(typeof(T))).Deserialize(reader);

                if (result is T)

                    return (T)result;

            }

            return default(T);

        }

​

        public static string ToXmlValue<TEnum>(this TEnum value) where TEnum : struct, IConvertible, IFormattable

        {

            var root = new XmlExtensionsEnumWrapper<TEnum> { Value = value };

            return root.SerializeToXElement().Value;

        }

​

        public static XElement SerializeToXElement<T>(this T obj)

        {

            return obj.SerializeToXElement(null, noStandardNamespaces); // Disable the xmlns:xsi and xmlns:xsd attributes by default.

        }

​

        public static XElement SerializeToXElement<T>(this T obj, XmlSerializer serializer, XmlSerializerNamespaces ns)

        {

            var doc = new XDocument();

            using (var writer = doc.CreateWriter())

                (serializer ?? new XmlSerializer(obj.GetType())).Serialize(writer, obj, ns);

            var element = doc.Root;

            if (element != null)

                element.Remove();

            return element;

        }

    }

​

    [XmlRoot(XmlExtensions.RootName, Namespace = XmlExtensions.RootNamespace)]

    [XmlType(IncludeInSchema = false)]

    public class XmlExtensionsEnumWrapper<TEnum>

    {

        [XmlText]

        public TEnum Value { get; set; }

    }

​

    class TestClass

    {

        class EnumValue<TEnum> where TEnum : struct, IConvertible, IFormattable

        {

            public TEnum ItsEnumValue;

        }

​

        public static void Test()

        {

            var obj = new EnumValue<myEnum>();

​

            obj.ItsEnumValue = "01010101".FromReflectedXmlValue<myEnum>();

            obj.ItsEnumValue = "01010101".FromXmlValue<myEnum>();

​

            TestDeserialization<myEnum>();

            TestReflection<myEnum>();

            TestDeserialization<myFlagsEnum>();

            try

            {

                TestReflection<myFlagsEnum>();

            }

            catch (Exception)

            {

                Console.WriteLine("Unable to deserialize all values of {0} using reflection.", typeof(myFlagsEnum));

            }

        }

​

       public static void TestDeserialization<TEnum>() where TEnum : struct, IConvertible, IFormattable

        {

            Console.WriteLine(string.Format("Testing {0} using deserialization...", typeof(TEnum)));

​

            foreach (TEnum val in GetAllEnums<TEnum>())

            {

                var xml = val.ToXmlValue();

​

                var val2 = xml.FromXmlValue<TEnum>();

​

                Console.WriteLine(string.Format("Enum ({0}) has XML: {1}", val, xml));

​

                Assert.IsTrue(val.Equals(val2));

​

            }

​

            Console.WriteLine(string.Format("Successfully tested {0}.", typeof(TEnum)));

        }

​

        public static void TestReflection<TEnum>() where TEnum : struct, IConvertible, IFormattable

        {

            Console.WriteLine(string.Format("Testing {0} using reflection...", typeof(TEnum)));

​

            foreach (TEnum val in GetAllEnums<TEnum>())

            {

                var xml = val.ToXmlValue();

​

                var val3 = xml.FromReflectedXmlValue<TEnum>();

​

                Assert.IsTrue(val.Equals(val3));

            }

​

            Console.WriteLine(string.Format("Successfully tested {0}.", typeof(TEnum)));

        }

​

        static IEnumerable<TEnum> GetAllEnums<TEnum>() where TEnum : struct, IConvertible, IFormattable

        {

            if (typeof(TEnum).IsDefined(typeof(FlagsAttribute), false))

                return GetAllFlagsEnums<TEnum>();

            else

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

        }

​

        static IEnumerable<TEnum> GetAllFlagsEnums<TEnum>() where TEnum : struct, IConvertible, IFormattable

        {

            // http://stackoverflow.com/questions/6117011/how-do-i-get-all-possible-combinations-of-an-enum-flags

            if (typeof(TEnum).BaseType != typeof(Enum)) 

                throw new ArgumentException("T must be an Enum type");

​

            var values = Enum.GetValues(typeof(TEnum)).Cast<TEnum>().Select(e => ToUInt64(e)).ToArray();

            var valuesInverted = values.Select(v => ~v).ToArray();

            var result = new List<TEnum>();

            ulong max = 0;

            for (int i = 0; i < values.Length; i++)

            {

                max |= values[i];

            }

​

            for (ulong i = 0; i <= max; i++)

            {

                ulong unaccountedBits = i;

                for (int j = 0; j < valuesInverted.Length; j++)

                {

                    unaccountedBits &= valuesInverted[j];

                    if (unaccountedBits == 0)

                    {

                        result.Add((TEnum)Enum.ToObject(typeof(TEnum), i));

                        break;

                    }

                }

            }

​

            //Check for zero

            try

            {

                if (string.IsNullOrEmpty(Enum.GetName(typeof(TEnum), (TEnum)Enum.ToObject(typeof(TEnum), 0))))

                {

                    result.Remove((TEnum)Enum.ToObject(typeof(TEnum), 0));

                }

            }

            catch

            {

                result.Remove((TEnum)Enum.ToObject(typeof(TEnum), 0));

            }

​

            return result;

        }

​

        static ulong ToUInt64<TEnum>(TEnum value) where TEnum : struct, IConvertible, IFormattable

        {

            // Silently convert the value to UInt64 from the other base 

            // types for enum without throwing an exception.

            // This is need since the Convert functions do overflow checks.

            TypeCode typeCode = value.GetTypeCode();

            ulong result;

​

            switch (typeCode)

            {

                case TypeCode.SByte:

                case TypeCode.Int16:

                case TypeCode.Int32:

                case TypeCode.Int64:

                    unchecked

                    {

                        result = (UInt64)value.ToInt64(CultureInfo.InvariantCulture);

                    }

                    break;

​

                case TypeCode.Byte:

                case TypeCode.UInt16:

                case TypeCode.UInt32:

                case TypeCode.UInt64:

                case TypeCode.Boolean:

                case TypeCode.Char:

                    unchecked

                    {

                        result = value.ToUInt64(CultureInfo.InvariantCulture);

                    }

                    break;

​

                default:

                    throw new InvalidOperationException();

            }

            return result;

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

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

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            if (value == false)

                throw new AssertionFailedException("failed");

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            TestClass.Test();

        }

    }