Re: passing enum value as an argument

Madestro,
|I am not sure what language you are coding in, but at least in VB.NET you
are
| incorrect. Here are the TRUE results:

| Like I said before, ultimately, the enum evaluates to a constant, so there
| is really no "type safety" here

Your statement is True, if and only if, you are using Option Strict Off.

If you use Option Strict On, than Enums are type safe as Jon suggests.

I normally use Option Strict On to ensure type safety, by having compile
time errors, rather then hard to find runtime time errors as your sample
potentially is.

Remember that Option Strict Off is the default and it allows (potentially
dangerous) implicit casts, such as your example of the SecondEnum value to a
FirstEnum type.

| It may not be the case in the language you are using, but it certainly is
| the case with VB.NET. Try it, you will see.
Try your example with Option Strict On...

Hope this helps
Jay

"Madestro" <me_no_like_spam_juanDOTromero@bowneDOTcom> wrote in message
news:BA715744-5467-4F04-B142-FB51798C8BF9@xxxxxxxxxxxxxxxx
|I am not sure what language you are coding in, but at least in VB.NET you
are
| incorrect. Here are the TRUE results:
|
| TakeFirstEnum(Foo) --> FAILS
| TakeFirstEnum(FirstEnum.Foo) --> SUCCEEDS
| TakeSecondEnum(Fred) --> FAILS
| TakeSecondEnum(SecondEnum.Fred) --> SUCCEEDS
|
| TakeFirstEnum(Fred) --> FAILS
| TakeFirstEnum(SecondEnum.Fred) --> SUCCEEDS
| TakeSecondEnum(Foo) --> FAILS
| TakeSecondEnum(FirstEnum.Foo) --> SUCCEEDS
|
| Like I said before, ultimately, the enum evaluates to a constant, so there
| is really no "type safety" here, except for the type of the constant and
the
| range of valid values the enum provides. Because of this, I could call the
| first function with a value from the second Enum so long as it evaluates
to a
| value within the range of the first Enum. What I cannot do however is call
| one of the values of the Enum without fully qualifying it because once
again,
| like I said before) you would run into ambiguity problems.
|
| It may not be the case in the language you are using, but it certainly is
| the case with VB.NET. Try it, you will see.
|
| --
| Juan Romero
| -----------------------------------------
| The successful person has the habit of doing the things failures don't
like
| to do.
| E.M. Gray
|
|
| "Jon Skeet [C# MVP]" wrote:
|
| > Madestro <me_no_like_spam_juanDOTromero@bowneDOTcom> wrote:
| > > That is exactly the point. I encourage Enums. Going back to the
question, the
| > > user is trying to use them without fully qualifying them which in turn
| > > results in "defeat of the purpose" like I mentioned before.
| >
| > But it *doesn't* defeat the purpose. It doesn't stop the compiler from
| > noticing if he's trying to pass in a value which isn't in the enum. It
| > doesn't stop the compiler from noticing if he's trying to pass in a
| > value from another enum, whether explicitly or not.
| >
| > If you had two enums, FirstEnum with values Foo, Bar, Baz and
| > SecondEnum with values Fred, George, Harry, and two methods:
| >
| > TakeFirstEnum (FirstEnum x)
| > TakeSecondEnum (SecondEnum y)
| >
| > then the following would be valid calls:
| > TakeFirstEnum(Foo)
| > TakeFirstEnum(FirstEnum.Foo)
| > TakeSecondEnum(Fred)
| > TakeSecondEnum(SecondEnum.Fred)
| >
| >
| > and the following would be invalid calls:
| > TakeFirstEnum(Fred)
| > TakeFirstEnum(SecondEnum.Fred)
| > TakeSecondEnum(Foo)
| > TakeSecondEnum(FirstEnum.Foo)
| >
| > So there's still just as much type safety there as there was before -
| > which would *not* be the case if he'd just gone with ints rather than
| > enums in the first place. For that reason, I fail to see how it defeats
| > the purpose.
| >
| > The only times it would cause potential for confusion would be where
| > there was an overloaded method where the differing parameter types were
| > both enums. In that case, the compiler could force the developer to
| > explicitly state which enum he wanted to use.
| >
| > --
| > Jon Skeet - <skeet@xxxxxxxxx>
| > http://www.pobox.com/~skeet
| > If replying to the group, please do not mail me too
| >


.

Relevant Pages

  • Re: passing enum value as an argument
    ... >> safety at all (at compile time) when you've got option strict turned ... the whole point of enums - because that dismisses type safety as being ... For you to get the benefits of an Enum, ... > Dim SomeVariable as Juan ...
    (microsoft.public.dotnet.general)
  • Re: C# Enums - Feature or deficiency
    ... The C# enum is a "poor cousin", just because it won't break type safety for ... Lew, using an enum as the ordinal type for indexing an array doesn't ... compromise type safety, and it can even increase it. ...
    (microsoft.public.dotnet.languages.csharp)
  • Re: C# Enums - Feature or deficiency
    ... The C# enum is a "poor cousin", just because it won't break type safety for your convenience? ... It's not idiomatic C# to index arrays with enum types, ...
    (microsoft.public.dotnet.languages.csharp)
  • RE: passing enum value as an argument
    ... TakeSecondEnum--> FAILS ... TakeSecondEnum--> SUCCEEDS ... Like I said before, ultimately, the enum evaluates to a constant, so there ... is really no "type safety" here, except for the type of the constant and the ...
    (microsoft.public.dotnet.general)
  • Am I the only one who would love these extentions? - Python 3.0 proposals (long)
    ... I would like to propose some extentions to the language, ... for-as loop, until loop, unconditional loop, one line if-else, etc. ... Hex strings. ... Enum type. ...
    (comp.lang.python)
Loading