Recently, I was working out some details to include in our applications framework when I encountered some old school enum
stuff that I'd like to share with you. It's all about using char
implicitly as sort of the underlying type of an enum
and why you might want that.
The Story
As I was working on one of the modules we need in our application, I had to figure out a way to store a person's gender. As it turns out, we don't have any data in the database specifying a list of genders. As this is all about what gender is on someone's passport, we only needed two values (obviously 'male
' and 'female
') and we decided to only store the first character of these values in the database. The reason we didn't want to have a Gender
table in our database was because of clarity. We have introduced this rule, saying that all primary keys should be of the SQL type uniqueidentifier (.NET type Guid
) and having a foreign key for gender would result in storing a Guid
for each and every gender in the database, which would not only be overkill, but would also make things complicated.
So on the database side, we had a char(1)
column. But that's not what you want throughout your .NET code. Having an enum
for this scenario is the obvious choice and that is what I went for. Luckily Silverlight is very well equipped for data binding enum
types. There was one possible issue here. .NET enum
s only support int
types as their underlying type...
...or do they? Obviously specifying something like enum Gender
: char
would not compile, but what about this:
public enum Gender
{
Female = 'f',
Male = 'm'
}
This is actually valid. But what happens then? Is char
now the underlying type for this enum
? Let's find out. I ran the following code to find out:
MessageBox.Show(string.Format("Enum underlying type: {0}",
Enum.GetUnderlyingType(typeof(Gender)).Name));
As it turns out, the underlying type is Int32
. Hmmm, would this actually work? What value is it actually storing?
I expanded my code to the following:
MessageBox.Show(string.Format("Enum underlying type: {0}\r\n" +
"Enum value as int: {1}\r\n" +
"Enum value as char: {2}",
Enum.GetUnderlyingType(typeof(Gender)).Name,
((int)_person.Gender).ToString(),
((char)_person.Gender).ToString()
));
Now it would show me the int
value and the char
value casts for the selected gender value. In this case _person.Gender
was Gender.Male
. The actual int
that was stored was 109
, which is the byte
value of the 'm
' char
. The ToString
method on the char
cast returned the 'm
' char
.
That's just great. Now I can store my Gender enum
values by casting them to char
at some point. But how about loading it pack into the Gender enum
? As it turns out, you are allowed to cast this both ways, so something like this works:
_person.Gender = (Gender)genderCharTextBox.Text[0];
Duality rocks, man! So now we can store enum
types without an underlying model with ease. Simple but powerful stuff, which I hope helps you out.
I've uploaded a simple project, which I used to test all this, here.