Generic Enum parser with some exception rule

Question

Let's say I have an enum like

enum A
{
    AA,
    BB,
    CC,
    DD
}

I want to parse string values into Enum types, like "abc" -> AA, "BB" -> BB, "CC" -> CC, "DD" -> DD, as you can see AA has some special rule for the translation. So in this case Enum.TryParse<A>("abc", true, out AEnum) would not serve the purpose. I can write some special codes to handle this exception value, and rest of values fall to use generic enum parser.

I have several enums with such exception rules, but if I come up with this type of codes

    public static T GetEnumValue<T>(this string stringValue) where T : struct, IComparable, IConvertible, IFormattable
    {
        if (typeof(T).IsEnum)
        {
            if (typeof(T) == typeof(A))
            {
                T myEnum;
                if (Enum.TryParse<T>(stringValue, true, out myEnum))
                {
                    return myEnum;
                }
                else
                {
                    // handle some special cases.
                    if (string.Compare(stringValue, "abc", StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        return A.AA;
                    }
                }
            }

            return default(T);
        }
        else
        {
            throw new Exception();
        }
    }

The code would not even compile, because compiler complains return value of that special case.

I strictly don't want to have attribute on my enum for some reason.

Anyone has good idea?

@BlueM I followed lots of suggestion how to apply generic to enum, `struct` is one of them. A.AA is just an item of the A enum. — hardywang, Apr 07 '14 at 20:11
Why not make a generic parser, and a concrete parser? Check for "abc" in the concrete parser, and if it's not there, call the generic one. — Caramiriel, Apr 07 '14 at 20:13
@BlueM `where T : System.Enum` will not work, see [Create Generic method constraining T to an Enum](http://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum) — Ulugbek Umirov, Apr 07 '14 at 20:18

score 1 · Accepted Answer · answered Apr 07 '14 at 20:11

1

The following line is ugly, but I believe will technically work for those special exceptions.

return (T)(object)A.AA;

answered Apr 07 '14 at 20:11

dvlsg

5,378
2
29
34

Indeed, it works. I agree it looks ugly, but functional. – hardywang Apr 07 '14 at 20:22

score 1 · Answer 2 · answered Apr 07 '14 at 20:15

1

Replace the following code:

if (string.Compare(stringValue, "abc", StringComparison.OrdinalIgnoreCase) == 0)
{
    return A.AA;
}

by

if (string.Compare(stringValue, "abc", StringComparison.OrdinalIgnoreCase) == 0)
{
    return (T)Enum.Parse(typeof(T), "AA");
}

answered Apr 07 '14 at 20:15

Ulugbek Umirov

12,719
3
23
31

I guess this could be another solution. – hardywang Apr 07 '14 at 20:26

score 0 · Answer 3 · answered Apr 07 '14 at 20:16

You could use Json.NET as your parser. With EnumMember, you can specify the exceptions to the rule. By default, it is case insensitive.

void Main()
{
    Console.WriteLine("abc".GetEnumValue<A>()); // AA
    Console.WriteLine("ABC".GetEnumValue<A>()); // AA
    Console.WriteLine("AA".GetEnumValue<A>());  // AA
    Console.WriteLine("Bb".GetEnumValue<A>());  // BB
}

[JsonConverter(typeof(StringEnumConverter))]
enum A
{
    [EnumMember(Value = "abc")]
    AA,
    BB,
    CC,
    DD
}
public static class Ext
{
    public static T GetEnumValue<T>(this string stringValue)
            where T : struct, IComparable, IConvertible, IFormattable
    {
        return JsonConvert.DeserializeObject<T>('"' + stringValue + '"');
    }
}

I forget to mention in my original post, I don't want attribute on my enum. I thought about this, I want to hand this enum to a party which disallow the party to know any underlying string value. — hardywang, Apr 07 '14 at 20:25

Generic Enum parser with some exception rule

3 Answers3