I'm glad you liked it, and I am in complete agreement about being able to constrain generics to enums. :-)

Thanks! That was helpful. I've exteded your idea in a more forgiving implementation:

<br>
<pre>

public static T GetEnumValueFromString<T>(string enumValueString, T defaulEnumValue)
{
T returnValue = defaulEnumValue;
if (typeof (T).IsEnum)
{
bool found = false;
if (new ArrayList(Enum.GetNames(typeof(T))).Contains(enumValueString))
{
returnValue = (T) Enum.Parse(typeof (T), enumValueString);
found = true;
}
else
{
string search = (enumValueString + "").ToUpper().Replace(" ", "").Replace("-", "");
FieldInfo[] fieldInfoList = typeof (T).GetFields(
BindingFlags.Public | BindingFlags.Static |
BindingFlags.FlattenHierarchy);

foreach (FieldInfo fi in fieldInfoList)
{
if ((fi.Name + ".").ToUpper().Contains(search))
{
returnValue = (T) fi.GetValue(typeof (T));
found = true;
break;
}
}
}
if (!found)
{
throw new NotSupportedException( String.Format( "Cannot cast string \"{0}\" to an enum value of type {1}.",
enumValueString, typeof(T).FullName) );
}
}
return returnValue;
}

</pre>

Oops, to trap null and empty tring, better change the 1st if statement to:

if (typeof(T).IsEnum && !String.IsNullOrEmpty(enumValueString))

Double oops... that was for constants rather than enums.

PLEASE DISREGARD

Well, here's a tip for you.
Enums are structs!
And you can use a struct in your constraint. Also the typeparameter is not limited to a single character.

my revised version would look like this:
public static TEnumType GetEnumValueFromString<TEnumType>(string enumValueString, TEnumType defaulEnumValue) where TEnumType: struct

We have now resticted the parameters that may be passed, and by the name of the typeparameter it is clear that we only want Enums.

You can define the constraint on all your generic code, which would provide a lot of cmpile time checking.

Secondly I am not quite sure what you are trying to achieve, if the point is to create an case-insensitive search, why not use

(T) Enum.Parse(typeof (T), enumValueString, true);

Note the second parameter.

Alternatly I found a way to compare the values of two enumerator values when one of them is a generic. I am stayng away from stringconversions because the name of an ENum is more likely to change than its' numeric value:

public bool Equals<TEnumType>(TEnumType value, KindOfEnum compareTo)
where TEnumType: struct
{
//need to cast it to enum first, direct cast won't compile
Enum castAsEnum = value as Enum;
//This cast will result in an nonexisting value if KindOfEnum does not have
//a matching value for the TEnumType value.
//Since I only want to know it they are equal, I do not care.
KindOfEnum castAsDesiredType = (KindOfEnum)castAsEnum;
//compare the values.
return (castAsDesiredType == compareTo);
}

Enums are also IConvertible, if you would like to further constrain your generic type.

Here is an example from a snippet which converts between two kinds of enums with the same values. ( No checks performed )



public class EnumConverter<sourceEnum,targetEnum> where sourceEnum:struct, IConvertible
where targetEnum:struct, IConvertible
{
public static targetEnum convert(sourceEnum source)
{

return (targetEnum) Enum.ToObject(typeof(targetEnum),source.ToInt32(null));
}
}