Strangeness in C# compilation

[andrewducker]

Something I spent a couple of hours digging into today, and caused much strangeness. If you use C# then knowing this might save you having to do the same...

When working out which method to call the compiler works its way up the calling chain from subclass to baseclass looking for a method signature that fits. It stops looking as soon as it finds one. The problem arises because the literal 0 can be mapped onto an enum without any casting. Which means that if there's a subclass with a method on it that takes an enumeration as a parameter and a baseclass with a method that takes an integer the call will be made to the subclass, producing an unexpected result. This is only true with a literal 0 - passing in a variable will work fine.

Sample Code

public enum MyEnum
{
   Zero,
   One,
   Two
}

class MyBaseClass
{
   public string Something (int myInt)
   {
      return ("int" + myInt.ToString());
   }
}

class MySubClass : MyBaseClass
{
   public string Something(MyEnum myEnum)
   {
      return "enum" + ((int)myEnum).ToString();
   }
}

public partial class Form1 : Form
{
   private void button1_Click(object sender, EventArgs e)
   {
      MySubClass x = new MySubClass();
      MessageBox.Show(x.Something(1));
      MessageBox.Show(x.Something(0));
   }
}

This final bit of code will produce "int1" and "enum0".

Fix
The following code works just fine:

private void button1_Click(object sender, EventArgs e)
{
   MySubClass x = new MySubClass();
   int myCounter = 1;
   MessageBox.Show(x.Something(myCounter));
   myCounter = 0;
   MessageBox.Show(x.Something(myCounter));
}

Further Reading
For further info see the C# language specification, section 6.1.3

   C# Language Specification
      6.1.3 Implicit enumeration conversions
      An implicit enumeration conversion permits the decimal-integer-literal 0 to be converted to any enum-type.

Comments

[call-waiting.livejournal.com]

From the description from the spec, it sounds like an explicit cast ((int)0) should do the trick too, as the cast isn't directly an int lit and therefore shouldn't be converted.

That's pretty nasty though. Why only 0? As far as enums are concerned, there really shouldn't be anything special about the value 0. Still, could be worse, could be C++...

[andrewducker]

Sadly explicit casts of the literal 0 seem to have no effect whatsoever. As to why 0 casts silently to an enumeration (without so much as a warning), goodness only knows. Presumably someone thought it was necessary for something or other, but I have no idea what.

Personally, I'm generally against accessing lists via the array operator anyway, which is where I first detected this one. If the location matters then it should be stored in a named location, and if you need to iterate around the whole list then foreach should be used.

[channelpenguin.livejournal.com]

hmm, yeah I recall that one. I can't remember the why - I am tantalised by the though tthat I did read an explanation somewhere. maybe I just imagined it...

[andrewducker]

What's wrong with the explanation I gave? The answer should be clear from that and the additional reading at the bottom...

[martling.livejournal.com]

The question is why the additional reading says what it does. It seems like a stupid pointless special case, probably thrown in as a hack to make some other badly designed feature suck less.

[andrewducker]

Some hunting about on the internet later, I found the reason in a web forum:

The language designers wanted to avoid
constructs like "(SomeEnum)0", because enums may be
[Flags]-able, and thus they may be "0" w/out having
a literal with the value "0".

Consider this:

if ((val & SomeEnum.Foo) == 0) {
}

W/out this rule, the bool expression has to
be written like:

if ((val & SomeEnum.Foo) == (SomeEnum)0) {
}

Personally, I'd rather they'd make people take the slightly more explicit route, as it would make both that code easier to read and my code more likely to run!

[channelpenguin.livejournal.com]

I meant an explanantion of WHY they did it like that...

[channelpenguin.livejournal.com]

and yeah it is the flags - memory like a seive.