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;
}
}
}
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...
Convert.ToInt32 can still throw an OverflowException if the enum's value is too big to fit in an int.
int enum types, or the OP can always return a long.
Enums are strange beasts. They may inherit from long and still be enums.
I'm pretty sure this theoretical code would throw a cast exception should you take an enum that does this.
As James Michael Hare mentioned, enums can be longs. However, using Convert.ToInt32 is not good enough because you could still get an overflow exception. Imagine the following enum that has a value that is bigger than can even fit in an int:
public enum BigEnum : long
{
BigValue = (long)int.MaxValue + 5
}
In that case, there is no way to convert that value to an int because it is too big. However, you can use logic like this and it will not throw:
static void foo(Type typeEnum)
{
var underlyingType = Enum.GetUnderlyingType(typeEnum);
if (typeEnum.IsEnum)
{
foreach (var enumVal in Enum.GetValues(typeEnum))
{
var _val = Convert.ChangeType(enumVal, underlyingType);
}
}
}
It uses the Enum.GetUnderlyingType method which ensures that the call to ChangeType will be working with the correct type. (in fact, that MSDN page for GetUnderlyingType has sample code that does almost this exact thing my sample code does).
object (ChangeType returns object) that he can't cast back to int or long directly. Essentially, all this does is convert the boxed long back into a boxed long and leaves him in the same situation.Enum.GetValues actually returns an array of that particular enum type.
What's not mentioned is that the particular array is also castable to int[] if TEnum:int or TEnum:uint (CLR arrays for primitives are convertible regardless of signedness)
Otherwise to be defensive you can always use the Convert.ChangeType(object,Type) api to be safe.
As a result you can write your code to be like so:
static void foo(Type typeEnum)
{
if (typeEnum.IsEnum)
{
var array = Enum.GetValues(typeEnum)
int[] arrayAsInts = array as int[];
if(arrayAsInts != null)
{
foreach (var enumVal in arrayAsInts)
{
var _val = enumVal;
}
}
else
{
foreach (var enumVal in array)
{
var _val = Convert.ChangeType(enumVal,typeof(int));
}
}
}
}
GetValuesreturns an array. Implicitly typing could mean the compiler will chooseobjectwhich can't be directly cast toint. Why not remove the implicitvarand save yourself the headache?foreachthen. You can cast fromobjecttointas long as theobjectis truly boxing anint, just can't do a conversion cast.var. The compiler will happily insert casts that would normally be explicit and can fail at runtime without telling you. In particular in this case using anintiteration variable will compile and fail at runtime in the same cases in which this code fails. [Once again the lack of generics in .net 1 caused warts in C#]