Convert a flagged enum to another one

Question

I have a general enum, let's say G that has some flagged values (One = 0 / Two = 1 / Three = 2 / Four = 4 / Five = 8, and so on).

I then have another enum (let's say B) that "extends" G with this kind of pattern : One = G.One / Two = G.Two / Three = G.Three / Four = G.Four (and that's all, no Five in this one).

I finally have have a last enum (let's say C) that also "extends" G with the same pattern type but other values : Three = G.Three / Four = G.Four / Five = G.Five (no One and Two in this one).

I'd like to find a generic function to convert B into C or C into B. For example, if I have "A valsAsA = A.One | A.Three | A.Four", I'd like a function like this : "B valsAsB = convert(valsAsA);" that would gives me "B.Three | A.Four".

This should be really generic because I have not only A and B enums, but also C, D, E... with different possible enum values, but always values from the generic enum.

Is it possible without checking all possibilities and adapting the function each time I add a new enum ?

An example:

    public enum General : int
    {
        One = 0,
        Two = 1,
        Three = 2,
        Four = 4,
        Five = 8
    }

    public enum A : int
    {
        One = General.One,
        Two = General.Two,
        Three = General.Three,
        Four = General.Four,
    }

    public enum B : int
    {
        Three = General.Three,
        Four = General.Four,
        Five = General.Five
    }

    public enum C : int
    {
        One = General.One,
        Three = General.Three,
        Five = General.Five
    }

    public class Test
    {
        public void testConvert()
        {
            A valAsA = A.One | A.Three | A.Four;
            B valAsB = convertFct(valAsA); // Should give me "B.Three | B.Four"
            C valAsC = convertFct(valAsA); // Should give me "C.One | C.Three"
        }
    }

I tested that :

A valAsA = A.One | A.Three | A.Four; 
C valAsC = (C)valAsA;
C valAsCReal = C.One | C.Three; // expected result

with no luck.. valAsC = 6 while valAsCReal = 2...

Thank you very much

Answer 1

Doing this with generics is a little tricky because it is not possible to set up a type constraint that allows enumerations in general (see this question). The best you can do is constraint to struct, IConvertible and do a runtime check, as I do in this example.

If you can cope with that part of the ugliness, the rest is fairly simple:

First, write two methods to convert to and from a General. Since your enums are bit masks, the "conversion" is actually just a binary and operation against the sum of all possible values, which you can obtain using GetValues.

Once you have performed the and operation, you can return an enum of the appropriate type by converting the integer using Enum.ToObject().

static public class ExtensionMethods
{
    static public General ToGeneral<T>(this T input) where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum) throw new ArgumentException("Input must be an enum.");

        return (General)((int)(object)input & Enum.GetValues(typeof(General)).Cast<int>().Sum());
    }

    static public T ToEnum<T>(this General input)
    {
        if (!typeof(T).IsEnum) throw new ArgumentException("Output type must be an enum.");

        return (T)Enum.ToObject(typeof(T), (int)input & Enum.GetValues(typeof(T)).Cast<int>().Sum());
    }
}

Once those are written, conversion to and from any enum is easy:

static public TOut Convert<TIn,TOut>(TIn input) where TIn : struct, IConvertible where TOut: struct, IConvertible
{
    var general = input.ToGeneral();
    return general.ToEnum<TOut>();
}

Test code:

public static void Main()
{
    A valAsA = A.One | A.Three | A.Four;
    B valAsB = Convert<A, B>(valAsA);  // Should give me "B.Three | B.Four"
    C valAsC = Convert<A, C>(valAsA); // Should give me "C.One | C.Three"

    Console.WriteLine("{0} should equal {1}", valAsB, (B.Three | B.Four));
    Console.WriteLine("{0} should equal {1}", valAsC, (C.One | C.Three));
}

Output:

6 should equal 6
Three should equal Three

See the code in action at DotNetFiddle

Answer 2

Damn !!! I could create this incredible function that answer to my question but please... tell me that there is something more elegant... xD

        private TRet ConvertIt<TRet, TOrig>(TOrig values) where TOrig : struct, IConvertible where TRet : struct, IConvertible
        {
            if (!typeof(TOrig).IsEnum || 
                !typeof(TRet).IsEnum ||
                !typeof(int).IsAssignableFrom(typeof(TOrig)) || 
                !typeof(int).IsAssignableFrom(typeof(TRet)))
            {
                throw new ArgumentException("TOrig and TRet must be an enumerated type extending integer");
            }

            bool retEnumHasZero = false;

            foreach (var flag in Enum.GetValues(typeof(TRet)))
            {
                if ((int)flag == 0)
                {
                    retEnumHasZero = true;
                    break;
                }
            }

            if (!retEnumHasZero)
            {
                throw new ArgumentException("TRet enum must have the 0 flag");
            }

            Dictionary<int, Enum> valsOrig = new Dictionary<int, Enum>();

            foreach (var flag in Enum.GetValues(typeof(TOrig)))
            {
                valsOrig.Add((int)flag, (Enum)flag);
            }

            object valuesAsObject = values;
            var valuesAsEnum = (Enum)valuesAsObject;


            int returnedValue = 0;

            foreach (var flag in Enum.GetValues(typeof(TRet)))
            {
                int flagAsInt = (int)flag;

                if (valsOrig.ContainsKey(flagAsInt) && valuesAsEnum.HasFlag(valsOrig[flagAsInt]))
                {
                    returnedValue |= flagAsInt;
                }
            }

            return (TRet)Enum.ToObject(typeof(TRet), returnedValue);
        }

Using the function :

A valAsA = A.One | A.Two | A.Three | A.Four;
C valAsC = ConvertIt<C, A>(valAsA);

Edit : This implementation looks better :

        private T ConvertIt<T>(Enum values) where T : struct, IConvertible
        {
            if (!typeof(T).IsEnum)
            {
                throw new ArgumentException("Type to return must be an enumerated type");
            }

            if (!Enum.IsDefined(typeof(T), 0))
            {
                throw new ArgumentException("Type to return enum must have the 0 flag");
            }

            int returnedValue = 0;

            foreach (var flag in Enum.GetValues(values.GetType()))
            {
                int flagAsInt = (int)flag;

                if (values.HasFlag((Enum)flag) && Enum.IsDefined(typeof(T), flagAsInt))
                {
                    returnedValue |= flagAsInt;
                }
            }

            return (T)Enum.ToObject(typeof(T), returnedValue);
        }

Using the function :

A valAsA = A.One | A.Two | A.Three | A.Four;
C valAsC = ConvertIt<C>(valAsA);

Finally, with the help of John Wu, here is the final function =>

        private T ConvertIt<T>(Enum input) where T : struct, IConvertible
        {
            if (!typeof(T).IsEnum)
            {
                throw new ArgumentException("Type to return must be an enumerated type");
            }

            return (T)Enum.ToObject(typeof(T), (int)(object)input & Enum.GetValues(typeof(T)).Cast<int>().Sum());
        }