Overloading a method in subclass (Enum vs int)

c#, derived-class, overloading

Solution

Yes, it does hide the Func(int) declared in class A.

Furthermore, please see enum (C# Reference)

The default underlying type of enumeration elements is int

You might also want to have a look at Polymorphism (C# Programming Guide)

EDIT

If you ere to change

Console.WriteLine(b.Func(0));          
Console.WriteLine(b.Func(1)); 
Console.WriteLine(b.Func(EnumType.First)); 

to

int i = 0;
Console.WriteLine(b.Func(i));          
Console.WriteLine(b.Func(1)); 
Console.WriteLine(b.Func(EnumType.First)); 

you will find that the output should be

Func(int)   
Func(int)   
Func(EnumType)

It would seem that 0 is implicitly casted to the default enum value if passed directly to the function call.

EDIT 2

I checked the IL code and it does seem that it implicitly casts the 0 to an enum

IL_0000: nop
IL_0001: newobj instance void ClassB::.ctor()
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: ldc.i4.0
IL_0009: callvirt instance string ClassB::Func(valuetype EnumType)
IL_000e: call void [mscorlib]System.Console::WriteLine(string)
IL_0013: nop
IL_0014: ldloc.0
IL_0015: ldc.i4.0
IL_0016: callvirt instance string ClassB::Func(valuetype EnumType)
IL_001b: call void [mscorlib]System.Console::WriteLine(string)
IL_0020: nop
IL_0021: call string [mscorlib]System.Console::ReadLine()
IL_0026: pop
IL_0027: ret

Problem

Why the following two code samples produce different output? Case 1 ``` enum EnumType { First, Second, Third } class ClassB { public string Func(int index) { return "Func(int)"; } public string Func(EnumType type) { return "Func(EnumType)"; } } class Program { static void Main(string[] args) { ClassB b = new ClassB(); Console.WriteLine(b.Func(0)); Console.WriteLine(b.Func(EnumType.First)); Console.ReadLine(); } } ``` Output: ``` Func(int) Func(EnumType) ``` Case 2 ``` enum EnumType { First, Second, Third } class ClassA { public string Func(int index) { return "Func(int)"; } } class ClassB : ClassA { public string Func(EnumType enumType) { return "Func(EnumType)"; } } class Program { static void Main(string[] args) { ClassB b = new ClassB(); Console.WriteLine(b.Func(0)); Console.WriteLine(b.Func(EnumType.First)); Console.ReadLine(); } } ``` Output: ``` Func(EnumType) Func(EnumType) ``` I am puzzled. Does it mean that Func(EnumType) hides Func(int) declared in the base? If this is the case then why literal 0 is implicitly casted to EnumType in the second case without a warning? EDIT: There is even more interesting behavior when I try ``` Console.WriteLine(b.Func(0)); Console.WriteLine(b.Func(1)); Console.WriteLine(b.Func(EnumType.First)); ``` What is your guess the output should look like? here it is: ``` Func(EnumType) Func(int) Func(EnumType) ``` Any ideas why 0 and 1 are treated differently? EDIT 2: It turns out that literal 0 indeed has special meaning in C#. Here and here I found an excellent description of this behavior (see the accepted answers).

Original source

Related problems