Enumerators
-
In the spirit of the new charter of this forum - "wicked code" - I see this as wicked code... I started programming long before many of the rest of you. Over the years, I've grown to have a huge distrust of not only users and their antics, but also other programmers and their seeming apathy regarding ensuring that data is valid before trying to use it. One of the problems I encountered was storing and retrieving enumerator values in data sources, and preparing the code to gracefully handle manually values - either modified by the user, or incorrectly set or interpreted by the programmer. So I came up with this method that I have include i pretty much every program I write:
public static T IntToEnum<T>(int value, T defaultValue) { T enumValue = (Enum.IsDefined(typeof(T), value)) ? (T)(object)value : defaultValue; return enumValue; }The purpose of the method is to allow the programmer to initialize a data member of a specified enumerator type to a value contained in the ordinal list. The problem this method addresses is that if the programmer retrieves an enum ordinal value as an int type, and wants to initialize an enum data member, he really has no programmatic idea if the value represents a valid ordinal. He simply tries to set it, and hope for the best (handling an exception if the assignment goes sideways on him). This method allows the programmer to make the same attempt, but with controlled results and thereby avoiding the inevitable exception generated when an invalid ordinal value is used. Usage goes something like this:
enum SomeEnum { Zero=0, Five=5, Six=6, Eight=8 };
// this will result in the correct expected value - SomeEnum.Five
SomeEnum value = IntToEnum(5, SomeEnum.Zero);// this will result in SomeEnum.Zero because the value (4) isn't a valid ordinal in the enumerator
value = IntToEnum(4, SomeEnum.Zero);.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, 2001John Simmons / outlaw programmer wrote:
I started programming long before many of the rest of you.
I first programmed on this actual system[^] using machine code, fed in from the buttons on the front panel, or boot-loaded from paper tape; great fun!
-
John Simmons / outlaw programmer wrote:
I started programming long before many of the rest of you.
I first programmed on this actual system[^] using machine code, fed in from the buttons on the front panel, or boot-loaded from paper tape; great fun!
I did say "many" of the rest of you. :)
.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 -
I did say "many" of the rest of you. :)
.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 -
John Simmons / outlaw programmer wrote:
I started programming long before many of the rest of you.
I first programmed on this actual system[^] using machine code, fed in from the buttons on the front panel, or boot-loaded from paper tape; great fun!
Actually I've inferred the age of that machine from the grainy black and white photos. :)
Chris Meech I am Canadian. [heard in a local bar] In theory there is no difference between theory and practice. In practice there is. [Yogi Berra]
-
Actually I've inferred the age of that machine from the grainy black and white photos. :)
Chris Meech I am Canadian. [heard in a local bar] In theory there is no difference between theory and practice. In practice there is. [Yogi Berra]
Chris Meech wrote:
I've inferred the age of that machine from the grainy black and white photos.
To say nothing of the dress sense of those of us in the computer room. The pictures were taken round about 1965 and although I am not in any of them, I do remember the names of a few of my colleagues that are pictured.
-
In the spirit of the new charter of this forum - "wicked code" - I see this as wicked code... I started programming long before many of the rest of you. Over the years, I've grown to have a huge distrust of not only users and their antics, but also other programmers and their seeming apathy regarding ensuring that data is valid before trying to use it. One of the problems I encountered was storing and retrieving enumerator values in data sources, and preparing the code to gracefully handle manually values - either modified by the user, or incorrectly set or interpreted by the programmer. So I came up with this method that I have include i pretty much every program I write:
public static T IntToEnum<T>(int value, T defaultValue) { T enumValue = (Enum.IsDefined(typeof(T), value)) ? (T)(object)value : defaultValue; return enumValue; }The purpose of the method is to allow the programmer to initialize a data member of a specified enumerator type to a value contained in the ordinal list. The problem this method addresses is that if the programmer retrieves an enum ordinal value as an int type, and wants to initialize an enum data member, he really has no programmatic idea if the value represents a valid ordinal. He simply tries to set it, and hope for the best (handling an exception if the assignment goes sideways on him). This method allows the programmer to make the same attempt, but with controlled results and thereby avoiding the inevitable exception generated when an invalid ordinal value is used. Usage goes something like this:
enum SomeEnum { Zero=0, Five=5, Six=6, Eight=8 };
// this will result in the correct expected value - SomeEnum.Five
SomeEnum value = IntToEnum(5, SomeEnum.Zero);// this will result in SomeEnum.Zero because the value (4) isn't a valid ordinal in the enumerator
value = IntToEnum(4, SomeEnum.Zero);.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, 2001You could apply generics to this as well to reduce how many times you have to create this in your code. :D
public static U ToEnum<T, U>(T value, U defaultValue) { return (Enum.IsDefined(typeof(U), value)) ? (U)((object)value) : defaultValue; }And made into an extension method, if you so choose.
-
You could apply generics to this as well to reduce how many times you have to create this in your code. :D
public static U ToEnum<T, U>(T value, U defaultValue) { return (Enum.IsDefined(typeof(U), value)) ? (U)((object)value) : defaultValue; }And made into an extension method, if you so choose.
What's the point of type T? You might as well just use object and remove the unnecessary cast. Personally, I would also eliminate the repeated typeof(U) and cache the Type, but that's just me.
-
What's the point of type T? You might as well just use object and remove the unnecessary cast. Personally, I would also eliminate the repeated typeof(U) and cache the Type, but that's just me.
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.
-
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.
Oh, right, this is a method, not a class; I usually write a generic class and cache the Type.
-
In the spirit of the new charter of this forum - "wicked code" - I see this as wicked code... I started programming long before many of the rest of you. Over the years, I've grown to have a huge distrust of not only users and their antics, but also other programmers and their seeming apathy regarding ensuring that data is valid before trying to use it. One of the problems I encountered was storing and retrieving enumerator values in data sources, and preparing the code to gracefully handle manually values - either modified by the user, or incorrectly set or interpreted by the programmer. So I came up with this method that I have include i pretty much every program I write:
public static T IntToEnum<T>(int value, T defaultValue) { T enumValue = (Enum.IsDefined(typeof(T), value)) ? (T)(object)value : defaultValue; return enumValue; }The purpose of the method is to allow the programmer to initialize a data member of a specified enumerator type to a value contained in the ordinal list. The problem this method addresses is that if the programmer retrieves an enum ordinal value as an int type, and wants to initialize an enum data member, he really has no programmatic idea if the value represents a valid ordinal. He simply tries to set it, and hope for the best (handling an exception if the assignment goes sideways on him). This method allows the programmer to make the same attempt, but with controlled results and thereby avoiding the inevitable exception generated when an invalid ordinal value is used. Usage goes something like this:
enum SomeEnum { Zero=0, Five=5, Six=6, Eight=8 };
// this will result in the correct expected value - SomeEnum.Five
SomeEnum value = IntToEnum(5, SomeEnum.Zero);// this will result in SomeEnum.Zero because the value (4) isn't a valid ordinal in the enumerator
value = IntToEnum(4, SomeEnum.Zero);.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, 2001Nice. but, personally, i would replace the default parameter with a delegate.
-
Nice. but, personally, i would replace the default parameter with a delegate.
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 -
Oh, right, this is a method, not a class; I usually write a generic class and cache the Type.
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 :^)
-
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 :^)
-
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 -
In the spirit of the new charter of this forum - "wicked code" - I see this as wicked code... I started programming long before many of the rest of you. Over the years, I've grown to have a huge distrust of not only users and their antics, but also other programmers and their seeming apathy regarding ensuring that data is valid before trying to use it. One of the problems I encountered was storing and retrieving enumerator values in data sources, and preparing the code to gracefully handle manually values - either modified by the user, or incorrectly set or interpreted by the programmer. So I came up with this method that I have include i pretty much every program I write:
public static T IntToEnum<T>(int value, T defaultValue) { T enumValue = (Enum.IsDefined(typeof(T), value)) ? (T)(object)value : defaultValue; return enumValue; }The purpose of the method is to allow the programmer to initialize a data member of a specified enumerator type to a value contained in the ordinal list. The problem this method addresses is that if the programmer retrieves an enum ordinal value as an int type, and wants to initialize an enum data member, he really has no programmatic idea if the value represents a valid ordinal. He simply tries to set it, and hope for the best (handling an exception if the assignment goes sideways on him). This method allows the programmer to make the same attempt, but with controlled results and thereby avoiding the inevitable exception generated when an invalid ordinal value is used. Usage goes something like this:
enum SomeEnum { Zero=0, Five=5, Six=6, Eight=8 };
// this will result in the correct expected value - SomeEnum.Five
SomeEnum value = IntToEnum(5, SomeEnum.Zero);// this will result in SomeEnum.Zero because the value (4) isn't a valid ordinal in the enumerator
value = IntToEnum(4, SomeEnum.Zero);.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, 2001Nice 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. :) :)
-
John Simmons / outlaw programmer wrote:
return a valid ordinal
Which you can't actually guarantee/enforce...
How do you figure? If you pass in a default parameter of a given
enumtype (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 -
Nice. but, personally, i would replace the default parameter with a delegate.
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 -
How do you figure? If you pass in a default parameter of a given
enumtype (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, 2001I 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?
-
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?
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, 2001modified on Saturday, November 21, 2009 9:22 AM
-
In the spirit of the new charter of this forum - "wicked code" - I see this as wicked code... I started programming long before many of the rest of you. Over the years, I've grown to have a huge distrust of not only users and their antics, but also other programmers and their seeming apathy regarding ensuring that data is valid before trying to use it. One of the problems I encountered was storing and retrieving enumerator values in data sources, and preparing the code to gracefully handle manually values - either modified by the user, or incorrectly set or interpreted by the programmer. So I came up with this method that I have include i pretty much every program I write:
public static T IntToEnum<T>(int value, T defaultValue) { T enumValue = (Enum.IsDefined(typeof(T), value)) ? (T)(object)value : defaultValue; return enumValue; }The purpose of the method is to allow the programmer to initialize a data member of a specified enumerator type to a value contained in the ordinal list. The problem this method addresses is that if the programmer retrieves an enum ordinal value as an int type, and wants to initialize an enum data member, he really has no programmatic idea if the value represents a valid ordinal. He simply tries to set it, and hope for the best (handling an exception if the assignment goes sideways on him). This method allows the programmer to make the same attempt, but with controlled results and thereby avoiding the inevitable exception generated when an invalid ordinal value is used. Usage goes something like this:
enum SomeEnum { Zero=0, Five=5, Six=6, Eight=8 };
// this will result in the correct expected value - SomeEnum.Five
SomeEnum value = IntToEnum(5, SomeEnum.Zero);// this will result in SomeEnum.Zero because the value (4) isn't a valid ordinal in the enumerator
value = IntToEnum(4, SomeEnum.Zero);.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
