Enumerators

[Andrew Rissing]

True, you could just drop that. I just got generic happy. As for caching the typeof(U), since that is going to change per method instance - I don't know if you'd get anything by caching that. Plus, I'm not sure how you'd simply do that without adding a bit of overhead to the whole process. Typeof would be done at compile time, so it should be fairly efficient as is.

[PIEBALDconsult]

Oh, right, this is a method, not a class; I usually write a generic class and cache the Type.

[Graham Parkings]

Nice. but, personally, i would replace the default parameter with a delegate.

[realJSOP]

But why? The whole purpose of the default parameter is to force the method to return a valid ordinal instead of throwing an exception. Making it a take a delegate would, IMHO, add unnecessary obfuscation and maintenance issues.

.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

[longnights]

I am interested in the caching concept... Can you give us a small sample on how its implemented. Do you write two blocks of code, like a singleton - where you save a reference to the type and return it every other time... I am not entirely sure how its done... please share :^)

[PIEBALDconsult]

Singleton schmingleton; static classes are what Singletons hope to be when they grow up. I hold a static reference to the Type; see here[^].

[PIEBALDconsult]

John Simmons / outlaw programmer wrote:

return a valid ordinal

Which you can't actually guarantee/enforce...

[AECAEC]

Nice View of the LEO. My First Machine (beyound the accounting machines) was the Wrirlwind I per 1960. My First real Job was on it's child The Mighty AN/FSQ-7 (Sage) Then its child the AN/FSQ-32A The only computer that had an official certified plumber (it was water cooled) on the IBM maintenance roster. Calling them in on the weekends was a trial. They would sihg songs from the IBM Song Book. Ugh! Yes the IBM Song Book - I still have a copy. If you want to see it Google for it. :) :)

[realJSOP]

How do you figure? If you pass in a default parameter of a given enum type (in our case, SomeEnum.Zero), then the ordinal has to exist in order to even pass a valid parameter (otherwise, the code wouldn't even compile).

.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

[realJSOP]

Just so you know, I didn't 1-vote your message...

.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

[PIEBALDconsult]

I could still send in default(T) or any other value. You could check it, but what will you do if the value isn't that of one of the members? Your code has to work for bit-mapped enumerations too doesn't it?

[realJSOP]

At some point, you have to rely on the programmer to know wtf he's doing. :) The name of the method kinda gives away its intended use.

.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

modified on Saturday, November 21, 2009 9:22 AM

[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