6

Possible Duplicate:
C# int, Int32 and enum's

It could be a rather basic / simpler question I am creating an enum in the following way.

Case 1 does compile perfectly. But Case 2 throws an error. To my understanding int and Int32 mean the same in C#.

Case 1

    [Flags]
    public enum MyEnum : int
    {
        Red = 0x1,
        Green = 0x2,
        Blue = 0x4
    }

Case 2

    [Flags]
    public enum MyEnum : Int32
    {
        Red = 0x1,
        Green = 0x2,
        Blue = 0x4
    }

What's the difference here and why C# doesn't compile the code when the enum's members are specified to be of Int32 type?

Community
  • 1
  • 1
SaravananArumugam
  • 3,680
  • 6
  • 33
  • 45
  • 1
    Duplicate: http://stackoverflow.com/questions/1813408/c-int-int32-and-enums – Brian R. Bondy Sep 23 '10 at 00:50
  • Interesting... I thought int and Int32 were perfectly equivalent to the compiler, but apparently it's not the case – Thomas Levesque Sep 23 '10 at 00:50
  • 1
    They are not even close to equivalent. `int` is a keyword, `Int32` is an ordinary identifier which happens to be the unqualified name of a primitive type defined in the `System` namespace. So, for example, I could create a class `MyNamespace.Int32`, but `MyNamespace.int` is a syntax error. – Ben Voigt Sep 23 '10 at 00:53
  • Well, you are nitpicking. int is a keyword, but it is an alias for Int32. So they are the same type. Even MS admits that it is "quirky" behavior, but is in fact by design. – Ed S. Sep 23 '10 at 00:57

1 Answers1

16

From a Microsoft bug report here:

Symptom
If you use System.Int16/Int32/Int64 instead of Short/Int/Long to declare Enum, it will get compilation error.

Root Cause
It's by design. Using value type alias is required exactly in Enum declaration.

It is "by design".

  1. The syntax is correct. C# specification explicitly states that the enum's underlying type must be byte, sbyte, short, ushort, int, uint, long or ulong.

  2. Although the underlying type of “Short” and "System.Int16" are one and the same, they are not as identical as you assume. The System.Int16 is a type, and the Short is a type keyword.

  3. ValueType is sealed. You cannot inherit from any class that derives from System.ValueType.

  4. But, it allows you to use the keyword to control. The intent is to prevent your using names of any types that derive from System.ValueType when declaring other types. The original intent is to provide a tightly controlled mechanism that allows you to declare types that inherit from System.ValueType. However, MSDN says "The C# type keywords and their aliases are interchangeable", which often let customers feel confused/inexplicable. They think it’s a compiler or grammar bug.

Business Impact / Customer Experience
Since the “Short” and "System.Int16" are the same one underlying type and can be interchangeable, many customers feel confused/inexplicable why it cannot be interchangeable in Enum declaration. They think it’s a compiler or grammar bug. The Voice of customers: This sounds like a small compiler bug (small becuase its easy to workaround). Here is what MSDN says "The C# type keywords and their aliases are interchangeable." In my view this is a real but tiny, compiler (or perhaps grammar) bug. The fact that the compiler lets you use "short" here and not "System.Int16" is a quirk of the compiler (perhaps not a bug, but a quirk).

Ed S.
  • 122,712
  • 22
  • 185
  • 265