Assigning enums to integral types

[Pyrdacor]

Why is an explicit cast needed when assigning an enum value to a variable of its underlying integral type?

enum Color { Red, Green }
enum Animal : byte { Fish, Ape }

int color = Color.Red; // CS0266
byte animal = Animal.Ape; // CS0266

This feels like a weird unnecessary limitation which is most likely caused by old design choices. But wouldn't it be possible to just allow this? I mean the compiler could just add the explicit cast under the hood itself.

The whole working with enum values is much too complicated imo. For example flag enums are often used in binary data formats and therefore are often serialized as integral types like bytes. It is really a pain in the ... to add all those explicit casts even though the compiler totally knows the integral types at play. I mean the compiler can do all the checks for integral types but fails for enums which are basically named integral values.

Did I miss something? Is it planned to improved something in the field of enums in the near future?

[HaloFour]

Enums aren't supposed to be treated as raw values of the underlying type and I don't think it's worth making it easier to accidentally to do in order to remove an explicit cast from the uncommon use cases such as binary serialization.

[Pyrdacor]

Enums aren't supposed to be treated as raw values of the underlying type

This is not what I am aiming for. But it is obvious that the value range of an enum is at max the value range of the underlying type. Every possible value of an enum with underlying type int, is represented by the value of an int. That is basically what the underlying type expresses. So it should be totally valid to assign those values directly to an int. I can also assign a byte to an int but a byte is not treated as an int. The value range of int just includes all bytes. The same is true for the enum.

[CyrusNajmabadi]

The reason is so that the conversiom is done explicitly with thought from the user that this is the right thing to do. This is part of what enums are. They are but intended for going back and forth implicitly.

[Pyrdacor]

What do you mean by "accidentally"? Do you have an example where you could do this accidentally in a way that is somewhat harmful or leads to logical errors?

The binary serialization was just an example. It isn't by far the only place where you would assign an integral value to an enum or vice versa. In the current state of possibilities I even am forced to store enum values in some integral type when I have to perform some advanced logic on them.

Is the purpose of the underlying type solely the limitation of the possible values?

[Pyrdacor]

I wished there was a way in-between. Keeping it safe while still allow niche things. But I also have no clever idea. I can live with the current state. I had hope as you can already explicitly specify the underlying type. But I already supposed that it was just to limit the value range and for marshalling like HaloFour mentioned. There are a few things which are just relicts of the very early phase of C# so I hoped it is one of them. But your explanations seem reasonable so I'm fine with it.

[CyrusNajmabadi]

I wished there was a way in-between. Keeping it safe while still allow niche things

There is. Just cast to the underlying type. it's normally just like 5 chars: (int). Incredibly trivial, easy to read and understand, and bridges the two worlds extremely well :)

[siegfriedpammer]

That particular flavor would likely need to be generated via source generators as it would likely run afoul of Oracle's patent on class enums and couldn't be implemented as such in the language proper.

We only have to wait another 17 months for the patent to expire and then class enums could be implemented, right?

[HaloFour]

We only have to wait another 17 months for the patent to expire and then class enums could be implemented, right?

Theoretically, although I personally believe that discriminated unions could cover pretty much all of the use cases where such enums might be useful.

[Pyrdacor]

I never liked them in Java and I wouldn't vote for them. I rather would like something which can just inherit the primitive types and restrict or extend them in some way.