Question

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.

Answer 1

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.