public enum Parts {
 Engine = 1,
 Wheels,
 Brakes
}
    class c
    {
        public static void Main()
        {
            try
            {
                Parts lineItem = (Parts)4;
                Console.WriteLine(lineItem);
            }
            catch
            {
                Console.WriteLine("Exception");
            }


            Console.ReadKey();
        }
    }

When this is used in a primary-expression within an instance constructor of a struct, it is classified as a variable. The type of the variable is the struct within which the usage occurs, and the variable represents the struct being constructed. The this variable of an instance constructor of a struct behaves exactly the same as an out parameter of the struct type—in particular, this means that the variable must be definitely assigned in every execution path of the instance constructor.

А>Не буду уточнять откуда вопросы, чтобы рекламы не было

А>    public enum Parts {
А> Engine = 1,
А> Wheels,
А> Brakes
А>}
А>    class c
А>    {
А>        public static void Main()
А>        {
А>            try
А>            {
А>                Parts lineItem = (Parts)4;
А>                Console.WriteLine(lineItem);
А>            }
А>            catch
А>            {
А>                Console.WriteLine("Exception");
А>            }


А>            Console.ReadKey();
А>        }
А>    }
А>

Each enum type has a corresponding integral type called the underlying type of the enum type. An enum type that does not explicitly declare an underlying type has an underlying type of int. An enum type’s storage format and range of possible values are determined by its underlying type. The set of values that an enum type can take on is not limited by its enum members. In particular, any value of the underlying type of an enum can be cast to the enum type and is a distinct valid value of that enum type.

А>                Parts lineItem = (Parts)4;
А>

4.1.9 Enumeration types
....
The set of values of the enumeration type is the same as the set of values of the underlying type. Values of the enumeration type are not restricted to the values of the named constants.

[Flags]
enum Flags
{
    First = 0,
    Second = 1,
    Third = 2
}

Flags f = (Flags) 4; // те же грабли и с той же стороны

Partition I, 8.5.2 Assemblies and scoping
....
The CTS supports an enum (also known as an enumeration type), an alternate name for an existing type. For
the purposes of matching signatures, an enum shall not be the same as the underlying type. Instances of an
enum, however, shall be assignment-compatible with the underlying type, and vice versa. That is, no cast
(see §8.3.3) or coercion (see §8.3.2) is required to convert from the enum to the underlying type, nor are they
required from the underlying type to the enum.

Partition II, 14.3 Enums
....
Unlike Pascal, the CLI does not provide a guarantee that values of the enum type are integers
corresponding to one of the symbols. In fact, the CLS (see Partition I, CLS) defines a convention for using
enums to represent bit flags which can be combined to form integral value that are not named by the enum type
itself.
....
For binding purposes (e.g., for locating a method definition from the method reference used to call it) enums
shall be distinct from their underlying type. For all other purposes, including verification and execution of
code, an unboxed enum freely interconverts with its underlying type.

class A
{
    static void Main()
    {
        object x = new int[] { 1, 2, 3 };
        E[] y = (E[])x;

        object a = 1;
        E b = (E)a;
    }
}

enum E{}