CODEWITHSUNDEEP
c#
Embedd_0913
Embedd_0913

Reputation: 16555

Why do we need to type cast an enum in C#

I have an enum like:

public enum Test:int
{
   A=1, 
   B=2
}

So here I know my enum is an int type but if I want to do something like following:

int a = Test.A;

this doesn't work.

If I have a class like:

public class MyTest
{
    public static int A =1;
}

I can say ,

int a = MyTest.A;

Here I don't need to cast A to int explicitly.

Upvotes: 11

Views: 2559

Answers (5)

Damien_The_Unbeliever
Damien_The_Unbeliever

Reputation: 239684

With your updated example:

public class MyTest
{
    public static int A =1;
}

And usage:

int a = MyTest.A;

That's not how enums look. Enums look more like (comments are places where we differ from a real enum):

public struct MyTest /* Of course, this isn't correct, because we'll inherit from System.ValueType. An enum should inherit from System.Enum */
{
    private int _value; /* Should be marked to be treated specially */
    private MyTest(int value) /* Doesn't need to exist, since there's some CLR fiddling */
    {
       _value = value;
    }

    public static explicit operator int(MyTest value) /* CLR provides conversions automatically */
    {
       return value._value;
    }
    public static explicit operator MyTest(int value) /* CLR provides conversions automatically */
    {
       return new MyTest(value);
    }

    public static readonly MyTest A = new MyTest(1); /* Should be const, not readonly, but we can't do a const of a custom type in C#. Also, is magically implicitly converted without calling a constructor */

    public static readonly MyTest B = new MyTest(2); /* Ditto */
}

Yes, you can easily get to the "underlying" int value, but the values of A and B are still strongly typed as being of type MyTest. This makes sure you don't accidentally use them in places where they're not appropriate.

Upvotes: 3

Jon Skeet
Jon Skeet

Reputation: 1500675

So here I know my enum is an int type

No, it's not. It has an underlying type of int, but it's a separate type. Heck, that's half the point of having enums in the first place - that you can keep the types separate.

When you want to convert between an enum value and its numeric equivalent, you cast - it's not that painful, and it keeps your code cleaner in terms of type safety. Basically it's one of those things where the rarity of it being the right thing to do makes it appropriate to make it explicit.

EDIT: One oddity that you should be aware of is that there is an implicit conversion from the constant value 0 to the enum type:

Test foo = 0;

In fact, in the MS implementation, it can be any kind of constant 0:

Test surprise = 0.0;

That's a bug, but one which it's too late to fix :)

I believe the rest for this implicit conversion was to make it simpler to check whether any bits are set in a flags enum, and other comparisons which would use "the 0 value". Personally I'm not a fan of that decision, but it's worth at least being aware of it.

Upvotes: 18

Dave New
Dave New

Reputation: 40032

You enum is of type Test. It is not int just because your enum has integers values.

You can cast your enum to get the int value:

int a = (int) Test.A;

Upvotes: 2

Olivier Jacot-Descombes
Olivier Jacot-Descombes

Reputation: 112372

The enum values are not of int type. int is the base type of the enum. The enums are technically ints but logically (from the perspective of the C# language) not. int (System.Int32) is the base type of all enums by default, if you don't explicitly specify another one.

Upvotes: 3

Science_Fiction
Science_Fiction

Reputation: 3433

"The underlying type specifies how much storage is allocated for each enumerator. However, an explicit cast is needed to convert from enum type to an integral type".

Upvotes: 5

Related Questions