Casting ints to enums in C#

Question

There is something that I cannot understand in C#. You can cast an out-of-range `int` into an `enum` and the compiler does not flinch. Imagine this `enum`: ``` enum Colour { Red = 1, Green = 2, Blue = 3 } ``` Now, if you write: ``` Colour eco; eco = (Colour)17; ``` The compiler thinks that’s fine. And the runtime, too. Uh? Why did the C# team decide to make this possible? This decision misses the point of using enums, I think, in scenarios like this: ``` void DoSomethingWithColour(Colour eco) { //do something to eco. } ``` In a strong-typed language like C#, I would like to assume that `eco` will always hold a legal `Colour` value. But this is not the case. A programmer could call my method with a value of 17 assigned to `eco` (as in previous code snippet), so the code in my method must not assume that `eco` holds a legal `Colour` value. I need to test for it explicitly and handle the exceptional values as I please. Why is this? In my humble opinion, it would be much nicer if the comp…

Accepted Answer

Guessing about 'why' is always dangerous, but consider this:

```
enum Direction { North =1, East = 2, South = 4, West = 8 }
Direction ne = Direction.North | Direction.East;

int value = (int) ne; // value == 3
string text = ne.ToString();  // text == "3"
```

When the `[Flags]` attribute is put in front of the enum, that last line changes to

```
string text = ne.ToString();  // text == "North, East"
```

Casting ints to enums in C#

Solution

Problem