Type inference over IEnumerable<T>

Question

There are a few posts already on stack overflow about this sort of thing but not exactly the same - so apologies in advance if this is something that has already been answered.

Why does this not work:

public class MyBase { }

public class MyUtils
{
 public bool Foo<T> (T myObject) { return true; }
 public bool Foo (MyBase myBaseObject) { return false; }

 public void Go<T> (IEnumerable<T> items)
 {
  foreach (var item in items)
  {
   // this test fails
   Assert.IsFalse (Foo (item));
  }
 }
}

If I call Go() above and pass in a load of MyBase objects, each call to Foo will call the generic Foo (), which returns true.

new MyUtils ().Go (new MyBase[] { new MyBase (), new MyBase () });

Why does it not call the specialised MyBase version instead? If I call Foo (new MyBase ()) directly, it correctly infers which call to make. Is this because of the lack of covariance for collections in C#3, or am I just being silly and not doing this correctly?

Thanks!

Isaac

Answer 1

According to C# specifications (7.4.3.2), the non-generic method is better than the generic one, so it should be selected.

But, I think the generic one is picked up in your case, because it is called within a generic invocation context (the "foreach" loop).

Answer 2

It doesn't call the "specialized" one because the compiler choses which method to call when the program (which in this case, is the Go function) is compiled, not when it's run.

When the compiler is compiling the Go function, the only information it has is that there is some object of type T. It doesn't have any idea that you may at some later point in time supply it with an object of type MyBase. The only option it has is to choose the Foo<T> overload, and so it bakes that in to the compiled program.

If you want an application to choose overloads at run-time, and pick the best overload by looking at the object while the application is running, that's called "dynamic dispatch", and is only used by dynamic languages such as Ruby, Python, PHP, etc.

C#3 is fully static and doesn't support this. You'd have to write an if-statement in your code to check the type if you wanted it to work this way. C#4 on the other hand, has some dynamic support. If you were writing this code in C# 4, you could declare the 'Go' function as follows:

 public void Go<T> (IEnumerable<dynamic> items)

Then it would use dynamic dispatch at run-time to choose which overload is called, and would call the overload specialized to take MyBase