RE: passing enum value as an argument

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
    ... | Like I said before, ultimately, the enum evaluates to a constant, so there ... I normally use Option Strict On to ensure type safety, ... | It may not be the case in the language you are using, ... | TakeSecondEnum--> FAILS ...
    (microsoft.public.dotnet.general)
  • Reflection of Enum and cannot get TypeOf original Type
    ... Using Reflection to get an Enumeration value that I pass to another DLL ... The checl always fails because it thinks the Enum if of Type FieldInfo ...
    (microsoft.public.dotnet.languages.csharp)
  • 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)