Question

Given the code below, is there any possiblity the int cast could throw an exception?

        static void foo(Type typeEnum)
        {
            if (typeEnum.IsEnum)
            {
                foreach (var enumVal in Enum.GetValues(typeEnum))
                {
                    var _val = (int)enumVal;                      
                }
            }
        }

Answer 1

Yes, if the enum backing type is not int, like:

    public enum X : long
    {
        A,
        B,
        C
    }

This will throw. This is because the enum values are boxes as object, and you can’t cast ‘object’ to ‘int’ unless the contained value is actually an ‘int’.

You could alleviate this by doing a Convert.ToInt32() which will work for all backing types of int or smaller:

static void foo(Type typeEnum)
{
    if (typeEnum.IsEnum)
    {
        foreach (var enumVal in Enum.GetValues(typeEnum))
        {
            var _val = Convert.ToInt32(enumVal);                      
        }
    }
}

Or, if you want to assume int and just be safer, you can check the underlying type of the enum like:

if (Enum.GetUnderlyingType(typeEnum) != typeof(int))
{
    throw new ArgumentException("This method only accepts int enums.");
}

Alternatively, you could assume a type of long if signed or ulong if unsigned (you can have negative enum values, but tend to be rarer):

static void foo(Type typeEnum)
{
    if (typeEnum.IsEnum)
    {
        foreach (var enumVal in Enum.GetValues(typeEnum))
        {
            var _val = Convert.ToInt64(enumVal);                      
        }
    }
}

This is why it’s probably safer to make some assumptions and check them on the call. Anything you do to unbox the value has the potential of throwing or overflowing.

You could even go generic and have the user pass in the type they want to get out:

static IEnumerable<ToType> foo<ToType>(Type typeEnum)
{
    if (typeEnum.IsEnum)
    {
        foreach (var enumVal in Enum.GetValues(typeEnum))
        {
            yield return (ToType)Convert.ChangeType(enumVal, typeof(ToType));
        }
    }
}

So you could invoke this:

IEnumerable<int> values foo<int>(typeof(YourEnum));

Then if they get an exception, it falls on them to specify the right size type…