What are the rules regarding function Overloading?
I have the following code:
public T genericFunc<T>() where T : Component, new()
{
T result = new T();
overloadedFunction( result );
}
private overloadedFunction ( Component c ) // catch all function
private overloadedFunction ( DerivedFromComponent dfc) // specific function
when I call the above code with:
genericFunc<DerivedFromComponent>();
I expect the more specific overloadedFunction to be called, however the catch all function is called instead, why is this?. When stepping through the above code the type T is indeed DerivedFromComponent, I thought that the CLR picked the best possible match at runtime!
The compiler performs overload resolution within genericFunc
when that method is compiled. At that point it doesn't know what type argument you're going to provide, so it only knows that it can call the first of your overloads.
Your example using generics makes life more complicated, but overloads are always resolved at compile-time (assuming you're not using dynamic
).
A simple example not using generics:
void Foo(string text) { }
void Foo(object o) {}
...
object x = "this is a string";
Foo(x);
would call the second overload, because the compile-time type of x
is just object.
For more on this, read my recent article on overloading.
Jon Skeet is right on with regard to the fact that overload resolution is determined at compile time. I thought I'd add another answer that was not the point of your question but interesting to note nonetheless.
In C# 4, the dynamic keyword can be used to defer the overload resolution until runtime. Consider the following snippet which prints:
Base!
Derived!
class Base {
}
class Derived : Base {
}
void DoSomething(Base x) {
Console.WriteLine("Base!");
}
void DoSomething(Derived x) {
Console.WriteLine("Derived!");
}
void DoSomething<T>() where T: Base, new() {
dynamic x = new T();
DoSomething(x);
}
void Main()
{
DoSomething<Base>();
DoSomething<Derived>();
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With