Enumerators

[Phil Martin]

Have you got that code handy in VB.Net? It might come in handy for you in the next few months. :) Tee hee hee.

[realJSOP]

That's okay - kick a guy when he's down... Do they even have enumerators in VB?

.45 ACP - because shooting twice is just silly
-----
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass..." - Dale Earnhardt, 1997
-----
"The staggering layers of obscenity in your statement make it a work of art on so many levels." - J. Jystad, 2001

[Tom Deketelaere]

John Simmons / outlaw programmer wrote:

Do they even have enumerators in VB?

Euhm yes ;P

John Simmons / outlaw programmer wrote:

That's okay - kick a guy when he's down...

Don't worry after a couple years you don't even feel the kicks anymore :sigh: ;P

[dojohansen]

I think I would prefer this

public static bool TryGetEnumValue<T>(object value, out T enumValue)
{
bool defined = Enum.IsDefined(typeof(T), value);
enumValue = (defined ? (T)value : default(T));
return defined;
}

with usage

SomeEnum v;
if (!TryGetEnumValue(4, out v))
throw new ...
else
...

The advantage is that this always tells you if the value is defined or not. With the original you'd get the value passed as "defaultValue" if the value tested is the default value OR if the value tested doesn't exist. Most of the time that doesn't really make sense - if the tested value is an argument from a caller for instance, the caller's intention might have been something quite different from using whatever enum member you've designated as the default.

modified on Tuesday, December 1, 2009 4:03 AM

[Simon Allaeys]

Why all the fuss about "starting programming a long time ago before the many of the rest of us"? I've been programming for 2 years now, and I wrote the folowing code snippit about one year ago:

public static bool TryParseEnum<TEnum>(int value, out TEnum result)
{
  result = default(TEnum);
  var type = typeof (TEnum);
  if (!type.IsEnum) return false;
  try
  {
    result = (TEnum) Enum.ToObject(type, value);
    return true;
  }
  catch
  {
    return false;
  }
}

public static bool TryParseEnum<TEnum>(string value, out TEnum result)
{
  result = default(TEnum);
  var type = typeof(TEnum);
  if (!type.IsEnum) return false;
  value = value.ToUpperInvariant();
  var names = Enum.GetNames(type);
  // Enum.IsDefined() is only available as case sensitive
  foreach (var name in names)
  {
    if (name.ToUpperInvariant() != value)
      continue;
    result = (TEnum)Enum.Parse(type, value, true);
    return true;
  }
  return false;
}

Advantages of this code: - you know if parsing succeeded (while you can't know when returning default values) - case insensitive

modified on Thursday, December 3, 2009 3:13 PM

[ColinBashBash]

That seems like a real good idea. Of course, being a programmer, I immediately try to "perfect" it. My long winded code ends up looking like this. (i wish i could add it as a static method to the Enum class)... i'm also playing with delegates just so that i can play with delegates...

public static class EnumExt {
public static bool TryParse<T>(object value, out T outputEnum) {
if (Enum.IsDefined(typeof(T), value)) {
outputEnum = (T)value;
return true;
} else {
outputEnum = default(T);
return false;
}
}
public static bool TryParse<T>(string value, out T outputEnum) {
string find = Array.Find<string>(Enum.GetNames(typeof(T)),
delegate(string s) { return String.Compare(s, value, true) == 0; });
if (find != null) {
outputEnum = (T)Enum.Parse(typeof(T), find);
return true;
} else {
outputEnum = default(T);
return false;
}
}
}

MyEnum example;
if (EnumExt.TryParse<MyEnum>(1, out example)) {
//do stuff
} else {
//do other stuff
}

[Simon Allaeys]

While using these methods I found a shortcoming... there is no support for flags! So this is how I improved it:

public static bool TryParseEnum(object value, out EnumType result)
{
result = default(EnumType);
if (value == null) return false;
var type = typeof (EnumType);
if (!type.IsEnum) return false;
int iValue;
return Int32.TryParse(value.ToString(), out iValue)
? TryParseEnum(iValue, out result)
: TryParseEnum(value.ToString(), out result);
}

public static bool TryParseEnum(int value, out EnumType result)
{
result = default(EnumType);
var type = typeof(EnumType);
if (!type.IsEnum) return false;
result = (EnumType)Enum.Parse(type, value.ToString());
// Verify if the result is valid,
// Enum.Parse might just return the input value, while this is not a defined value of the enum
if (result.ToString().Contains(", ") || Enum.IsDefined(type, result))
return true;
result = default(EnumType);
return false;
}

public static bool TryParseEnum(string value, out EnumType result)
{
result = default(EnumType);
if (string.IsNullOrEmpty(value)) return false;
var type = typeof(EnumType);
if (!type.IsEnum) return false;
value = value.ToUpperInvariant();
try
{
result = (EnumType)Enum.Parse(type, value, true);
return true;
}
catch (ArgumentException)
{
return false;
}
}

:edited: Edited the object method to use the two other methods, this should be more reliable for both normal enums and bit flag enums. Casting/parsing values which are non-numeric and non-string values is anyway not possible in .NET.

modified on Wednesday, February 10, 2010 6:31 AM