using System;

using System.Collections.Generic;       

using System.Reflection;

public class ValueTranslation<T>

    {

        public string Text { get; set; }

        public T Value { get; set; }

    }

public class Program

{

    public static void Main()

    {

        Type t = typeof(Program.Sample);

        var fields = t.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static);

        var val = fields[0].GetValue(null);

        var name = fields[0].Name;

        List<ValueTranslation<BitMask>> list = new List<ValueTranslation<BitMask>>();

        list.Add(new ValueTranslation<BitMask>

        {

             Text = name,

             Value = (BitMask)val

        });

        Console.WriteLine("Hello World "+ list[0].Value);

    }

​

​

    public static class Sample

    {

    public static readonly BitMask ViewApvWellBeingDepartmentCompareReport = new BitMask(0x0000000000200000, 3);

    }

}

​

​

​

[CLSCompliant(false)]

    public struct BitMask

    {

        public BitMask(ulong value, int bank)

        {

            _value = value;

            _bank = bank;

        }

​

        public static implicit operator ulong(BitMask b)

        {

            return b._value;

        }

        public static BitMask operator &(BitMask a, BitMask b)

        {

            AssertBankMatch(a, b);

​

            return new BitMask(a._value & b._value, a._bank);

        }

        public static BitMask operator |(BitMask a, BitMask b)

        {

            AssertBankMatch(a, b);

​

            return new BitMask(a._value | b._value, a._bank);

        }

        public static BitMask operator ^(BitMask a, BitMask b)

        {

            AssertBankMatch(a, b);

​

            return new BitMask(a._value ^ b._value, b._bank);

        }

        public static bool operator ==(BitMask a, BitMask b)

        {

            return a.Equals(b);

        }

        public static bool operator !=(BitMask a, BitMask b)

        {

            return !a.Equals(b);

        }

        public bool Equals(BitMask rhs)

        {

            return (_value == rhs._value) && (_bank == rhs._bank);

        }

        public override bool Equals(object obj)

        {

            return Equals((BitMask)obj);

        }

        public override int GetHashCode()

        {

            return ToString().GetHashCode();

        }

        public override string ToString()

        {

            return string.Concat(_bank, "_", _value);

        }

        public IEnumerable<BitMask> GetConstituents()

        {

            var l = 1UL;

            for (int i = 0; i < 64; i++)

            {

                if ((_value & l) > 0)

                {

                    yield return new BitMask(l, _bank);

                }

​

                l = l << 1;

            }

        }

        public IEnumerable<string> GetValueList()

        {

            var l = 1UL;

            for (int i = 0; i < 64; i++)

            {

                if ((_value & l) > 0)

                {

                    yield return l.ToString();

                }

​

                l = l << 1;

            }

        }

​

        public static BitMask Parse(string s)

        {

            if (string.IsNullOrEmpty(s))

            {

                return Empty;

            }

​

            var tokens = s.Split('_');

            if (tokens.Length != 2)

            {

                throw new FormatException("The string is not in b format parsable as an BitMask");

            }

​

            BitMask b = new BitMask();

            if (!int.TryParse(tokens[0], out b._bank))

            {

                throw new FormatException("The string is not in b format parsable as an BitMask");

            }

​

            if (!ulong.TryParse(tokens[1], out b._value))

            {

                throw new FormatException("The string is not in b format parsable as an BitMask");

            }

​

            return b;

        }

        private static void AssertBankMatch(BitMask a, BitMask b)

        {

            if (a._bank != b._bank)

            {

                throw new InvalidOperationException("Cannot operate on BitMasks in different banks");

            }

        }

​

        public int Bank 

        {

            get { return _bank; }

            set { _bank = value; }

        }

        private int _bank;

        public ulong Value

        {

            get { return _value; }

            set { _value = value; }

        }

        private ulong _value;

​

        public static readonly BitMask Empty = new BitMask(0, -1);

    }