Add a non-generic version of Enum.TryParse

[yufeih]

These are the methods in Enum class related to string parsing.

public static object Parse(Type enumType, string value);
public static object Parse(Type enumType, string value, bool ignoreCase);

public static bool TryParse<TEnum>(string value, out TEnum result) 
where TEnum : struct;
public static bool TryParse<TEnum>(string value, bool ignoreCase, out TEnum result) 
where TEnum : struct;

Apparently Parse is exposed only in non-generic form, while TryParse is only exposed in generic form. This is somewhat inconsistent.

It is simple enough to call a non-generic method in a generic method, but not the other way around. So Parse can be made generic using the following helper. But it is a lot harder to wrap TryParse into TryParse(Type enumType) without reflection calls.

public static TEnum Parse<TEnum>(string value, bool ignoreCase)
{
    return Enum.Parse(typeof(TEnum), value, ignoreCase);
}

The suggestion is to add a non-generic Enum.TryParse method, the API signature would look like

public static bool TryParse(Type enumType, string value, out object result) 
public static bool TryParse(Type enumType, string value, bool ignoreCase, out object result) 

[ellismg]

Can you help me understand why you'd want the non generic version? What are the scenarios where you have an opaque type you know is an enum and a string and you need to parse it?

[yufeih]

It is mostly for serialization, where the type of the enum is reflected and not fixed in the code upfront.

[miloush]

I agree I would find that helpful too. If a string is entered by user or otherwise received and the call site expects or looks for particular type of enum, you currently have to try/catch Parse, use reflection or GetNames and search manually, not sure which is worse performance-wise.

You especially can't use the generic overloads if you know the nullable version of the enum type. That is perfect use for the suggested TryCatch overload: you get the enum type with Nullable.GetUnderlyingType and you want to parse that enum type or return null when it fails.

[terrajobst]

@ellismg are you opposed to having the non-generic version? I'm fine either way.

@KrzysztofCwalina @weshaggard any objections to the APIs as proposed?

[KrzysztofCwalina]

No objections. Makes sense.

[weshaggard]

agreed.

[SuperJMN]

I need this. I'm the author of OmniXAML (cross-platform XAML framework) and it would be useful to avoid extra calls like Enum.IsDefined

Parsing XAML requieres string values to be converted dynamically to their target types. When I want to convert to a Enum type, I know the type of the Enum and the string representation of the value that may or may not be a correct value, so a call like the propose (non-generic) should be added:

Enum.TryParse(Type enumType, string value)

[fruitbatinshades]

I need the same thing. In my use case I'm changing mixed property keys in a file format where they can add unknown keys for their own meta data. I read the property key and cast to the correct enum in a try/catch and only process the known ones. Being able to tryParse with a runtime type would help me out

[fruitbatinshades]

Can anyone see issues with this approach?

public static bool TryParseEnum(this string value, Type enumType,bool ignoreCase, out Enum enumValue) { if (Enum.IsDefined(enumType, value)) { enumValue = (Enum)Enum.Parse(enumType, value, ignoreCase); return true; } enumValue = null; return false; }

apart from not supporting flagged enums and I can't get markdown to indent the code :/

[yufeih]

It does not respect ignoreCase and is not optimal because it compares the value twice.