C# Casting with objects to Enums

Question

This question relates to casting of enums within generic methods

Given an enum

public enum Crustaceans
{
    Frog = 1,
    Toad = 4
}

I can create an instance of my enum simply enough

short val = 4;
Crustaceans crusty = (Crustaceans) val;

However, if

short val = 4;
object obj = (object) val;
Crustaceans crusty = (Crustaceans)obj;

a runtime exception is thrown attempting to perform the initialisation of crusty.

Can anyone explain why this is happening, and why it is not legal to do such a thing.

Not that I really wanted to do this, but I cam across an issue when trying to get something similar happening with generics and effectively that is what is happening under the covers. i.e.

public T dosomething<T>(short val) where T : new()
{
    T result = (T)(object) val;
    return result;
}

So what I am attempting to do is have a generic function that works with enums and non-enums (not so critical-but would be nice) that can be set to a short value without throwing an exception and actually initialising the correct enum value.

Answer 1

Something like this probably will help you:

public T dosomething<T>(object o)
{
   T enumVal= (T)Enum.Parse(typeof(T), o.ToString());
   return enumVal;
}

But this will work only with enums, for clear reason of using Enum.Parse(..)

And use this like, for example:

object o = 4;
dosomething<Crustaceans>(o);

That will return Toad in your case.

Answer 2

In case of integral types boxed as objects the correct way to do the conversion is using Enum.ToObject method:

public T Convert<T>(object o)
{
   T enumVal= (T)Enum.ToObject(typeof(T), o);
   return enumVal;
}

Answer 3

There are cases when you can not use Generics (like in a WPF Converter when you get the value as an object). In this case you can not cast to int because the enum type may not be an int. This is a general way to do it without Generics. The Example is given inside a WPF Converter, but the code inside is general:

using System;
using System.Windows;
using System.Windows.Data;

.
.
.

public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
    var enumType = value.GetType();
    var underlyingType = Enum.GetUnderlyingType(enumType);
    var numericValue = System.Convert.ChangeType(value, underlyingType);
    return numericValue;
}

Answer 4

By default enum digit values have type = int. In your code you want to cast value that have short type to enum type. For that, you have to set short type to your enum values. This will work:

public enum Crustaceans : short // <--
{
    Frog = 1,
    Toad = 4
}

short  @short = 1;
object @object = @short;

var @enum = (Crustaceans)@object; // @enum = Crustaceans.Frog   

if you don't want to change default enum values type

public enum Crustaceans
{
    Frog = 1,
    Toad = 4
}

object @object = Crustaceans.Frog;

var @enum = (Crustaceans)@object; // @enum = Crustaceans.Frog

or

public enum Crustaceans
{
    Frog = 1,
    Toad = 4
}

int @integer= 1;

var @enum = (Crustaceans)@integer; // @enum = Crustaceans.Frog

Answer 5

Tigrin's answer will convert the string name of the enum to the enum - which may be what is desired, where as Hazzik's will not, which also may be what is desired. But if you want the functionality of Tigrin's answer, with the efficiency of Hazzik's answer (Tigrin's answer takes an enum, converts it to a string and then back again...), this code will do it:

    public static bool TryParseEnum<EnumType>(object obj, ref EnumType enumType) where EnumType : struct, System.IConvertible
    {
        if (obj != null)
        {
            try
            {
                string str = obj as string;
                if (str == null)
                {
                    enumType = (EnumType)Enum.ToObject(typeof(EnumType), obj);
                    return true;
                }
                else
                {
                    str = str.Trim();
                    if (str.Length > 0)//optimization to avoid throwing and catching in frequently occurring case
                    {
                        //if (!int.TryParse(str, out int unused))//ARRRRGGGG!!! Microsoft allows the string "2" to be parsed to the enum, which we never want.  Why would anyone want this???
                        {
                            enumType = (EnumType)Enum.Parse(typeof(EnumType), str, true);
                            return true;
                        }
                    }
                }
            }
            catch (Exception)
            {
            }
        }
        return false;
    }

Note the code in the commented out code: Tigrin's answer, and the code above, allow "string" representations of integers, e.g. "1", to be converted to an enum. The implementor has to decide if they want to allow that or not.

Answer 6

You can use this extension:

public static T ToEnum<T>(this object obj)
    {
        var objType = obj.GetType();
        if (typeof(T).IsEnum)
        {
            if (objType == typeof(string))
                return (T)Enum.Parse(typeof(T), obj.ToString());
            return (T)Enum.ToObject(typeof(T), obj);
        }
        if (objType == typeof(string))
            return (T)Enum.Parse(Nullable.GetUnderlyingType(typeof(T)), obj.ToString());
        return (T)Enum.ToObject(Nullable.GetUnderlyingType(typeof(T)), obj);
    }

Enum

public enum Crustaceans { Frog = 1, Toad = 4 }

Usage

Crustaceans x = "Toad".ToEnum<Crustaceans>();
Crustaceans y = 4.ToEnum<Crustaceans>();
if (x == y) 
{
    System.Console.WriteLine("Equale");
}