C#

<br />
PrintArg(0);<br />
PrintArg((int)0);<br />
PrintArg((Int16)0);<br />
PrintArg((short)0);<br />
PrintArg((Int32)0);<br />
PrintArg((long)0);<br />
PrintArg((Int64)0);<br />
PrintArg(1);<br />

<br />
.method public hidebysig static void  Main() cil managed<br />
{<br />
  .entrypoint<br />
  // Code size       85 (0x55)<br />
  .maxstack  1<br />
  IL_0000:  nop<br />
  IL_0001:  ldc.i4.0<br />
  IL_0002:  call       void Program::PrintArg(valuetype Foo)<br />
  IL_0007:  nop<br />
  IL_0008:  ldc.i4.0<br />
  IL_0009:  call       void Program::PrintArg(valuetype Foo)<br />
  IL_000e:  nop<br />
  IL_000f:  ldc.i4.0<br />
  IL_0010:  box        [mscorlib]System.Int16<br />
  IL_0015:  call       void Program::PrintArg(object)<br />
  IL_001a:  nop<br />
  IL_001b:  ldc.i4.0<br />
  IL_001c:  box        [mscorlib]System.Int16<br />
  IL_0021:  call       void Program::PrintArg(object)<br />
  IL_0026:  nop<br />
  IL_0027:  ldc.i4.0<br />
  IL_0028:  call       void Program::PrintArg(valuetype Foo)<br />
  IL_002d:  nop<br />
  IL_002e:  ldc.i4.0<br />
  IL_002f:  conv.i8<br />
  IL_0030:  box        [mscorlib]System.Int64<br />
  IL_0035:  call       void Program::PrintArg(object)<br />
  IL_003a:  nop<br />
  IL_003b:  ldc.i4.0<br />
  IL_003c:  conv.i8<br />
  IL_003d:  box        [mscorlib]System.Int64<br />
  IL_0042:  call       void Program::PrintArg(object)<br />
  IL_0047:  nop<br />
  IL_0048:  ldc.i4.1<br />
  IL_0049:  box        [mscorlib]System.Int32<br />
  IL_004e:  call       void Program::PrintArg(object)<br />
  IL_0053:  nop<br />
  IL_0054:  ret<br />
} // end of method Program::Main<br />

<br />
using System;<br />
<br />
enum Foo { Bar, None }<br />
class Program<br />
{<br />
    static void PrintArg(object x) <br />
    { <br />
        if (x is Foo) <br />
        { <br />
            PrintFooArg((Foo)x); <br />
            return; <br />
        } <br />
        Console.WriteLine(x.ToString()); <br />
    }<br />
    <br />
    static void PrintFooArg(Foo x) <br />
    { <br />
        Console.WriteLine(x.ToString()); <br />
    }<br />
<br />
    public static void Main()<br />
    {<br />
        PrintArg(0);<br />
        PrintArg((int)0);<br />
        PrintArg((Int16)0);<br />
        PrintArg((short)0);<br />
        PrintArg((Int32)0);<br />
        PrintArg((long)0);<br />
        PrintArg((Int64)0);<br />
        PrintArg(1);<br />
        PrintArg(Foo.Bar);<br />
    }<br />
}<br />

PrintArg(-0);

Console.WriteLine(0.GetType() == 1.GetType());

public object moo<br />
        {<br />
__get { return moo; }<br />
__set { moo = value; }<br />
}

For the C#-compiler, the token 0 is parsed just as a token of course; it depends on the context what the semantic will be. Nevertheless you can often just think of 0 as a int (= System.Int32) constant. For the following discussion, I've used this piece of code:

using System;

class Program
{
enum Foo { Bar, None }

static void PrintArg(object x) { Console.WriteLine("O {0}", x.ToString()); }
static void PrintArg(Foo x) { Console.WriteLine("F {0}", x.ToString()); }

public static void Main()
{
PrintArg(Foo.Bar);
PrintArg(Foo.None);

PrintArg((Foo)0);
PrintArg((Foo)1);

PrintArg(0); // Implicit cast to Foo.Bar
PrintArg(1);

PrintArg((int)0); // Implicit cast to Foo.Bar
PrintArg((int)1);

PrintArg((Int32)0); // Implicit cast to Foo.Bar
PrintArg((Int32)1);

PrintArg((Int16)0);
PrintArg((Int16)1);

PrintArg((Int64)0);
PrintArg((Int64)1);

PrintArg((object)0);
PrintArg((object)1);

}
}

You'll see the following as the output:

F Bar
F None
F Bar
F None
F Bar
O 1
F Bar
O 1
F Bar
O 1
O 0
O 1
O 0
O 1
O 0
O 1

Let's start with the first pair. Nothing weird in here; just a case of strong typing and a one-on-one match for a method to be called. Essentially, enums are first class citizens when it comes down to object typing. Behind the scenes, an enums is an int however (in the default case).

The second pair is the same as above; using an explicit cast from to the enum type. On the method overload resolution side of the story, there's no difference with the case above.

On to pair three. In here, something different happens. C# only allows implicit conversion of the decimal-integer-literal 0 to any enum (section 6.1.3 of the C# 2.0 standard); other literals don't have implicit conversions (so you need to do something like in case 2). Therefore, the first invocation will result in a call to the Bar argument method overload, while the second one doesn't. Any type, including value types likes an int, derives from System.Object, so the other overload is called (boxing happens though behind the scenes).

Pair four and pair five are the same since int and Int32 are equivalent in C# due to the built-in type mapping. Therefore, (int)0 and (Int32)0 are the same as just 0, resulting in the decimal-integer-literal 0, allowing implicit conversion to the underlying enum type. Output will be "F Bar", "O 1" again because of the reason aforementioned (6.1.3).

The cases represented by pairs six and seven do not match the rule above; although it's a bit subtle. Because we do a cast of 0 to Int16 in the first case, the compiler looks for the best overload for a PrintArg method with an Int16 parameter; since it's not an Int32, rule 6.1.3 doesn't hold, so we end up with the object parameter case. So, there no second-level implicit casting from the Int16 to Int32 to end up in the 6.1.3 case, as some might think. For case seven, it's the same (although there wouldn't be an implicit cast from Int64 to Int32 possible at all, so less doubt about this should be around).

The last two cases are self-explanatory. You tell the compiler to look for an object parameter, so it does.

To explain the philosophy behind rule 6.1.3, just think of enums as a value type with a typical "default" of 0. This makes simple initialization possible, without relying on the underlying enum's names:
Foo f = 0;
However,
Foo f = 1;
won't work. Furthermore, this corresponds to the underlying CLR strategy of all value types to be "all zeros" initialized, so C# allows developers to state this explicitly as they might expect to be possible.

This being said, one should obey to the design guidelines for frameworks. The following rule applies: "Do provide a value of zero on simple enums". As the matter in fact, the Foo enum in the sample doesn't follow this rule:
enum Foo
{
None = 0,
Bar
}
would have been much better. If you think about it this way, allowing only 0 assignment for enums perfectly makes sense.

-Bart

public object moo<br />
        {<br />
__get { return moo; }<br />
__set { moo = value; }<br />
}

Chadwick Posey wrote:

esoteric

Lois Griffin: Peter, it's great they picked your theme, but isn't it a little esoteric?
Peter Griffin: Esoteric...?
[Cut-scene: inside Peter's head]
Man 2: Could it mean sexy?
Man 3: I think it's a science term.
Man 4: Fellas, fellas, esoteric means delicious.
[Back to reality]
Peter Griffin: Lois, Who's the Boss? is not a food.
Brian Griffin: Swing and a miss.

public object moo<br />
        {<br />
__get { return moo; }<br />
__set { moo = value; }<br />
}

DataSet dataSet=new DataSet();
DataGrid1.DataSource=dataSet;

DataSet dataSet=new DataSet();
dataSet = (DataSet)DataGrid1.DataSource;

Keshav Kamat
India