Overload Resolution in C# 4.0 using dynamic types

Question

I don't have access to the C# 4.0 preview yet. But I am curious, what does the C# 4.0 runtime do when invoking an overloaded method in the following case. Does it resolve to the generic overload ... or the specialized overload.

public class Foo<T>
{
  protected string BarImpl( T value ) { return "Bar(T) says: " + value.ToString(); }

  protected string BarImpl( int value ) { return "Bar(int) says: " + value.ToString(); }

  public string Bar( T value )
  {
    dynamic foo = this;
    return foo.BarImpl( value );
  }
}

public static void Main( string args[] )
{
  var f = new Foo<int>();

  Console.WriteLine( f.Bar( 0 ) );
}

Answer 1

Sam Ng has a great series of blog posts about this. I forget the exact details (and they may still change before release of course) but that blog series goes into quite a lot of depth, including generics stuff.

In general, my understanding that the result should (whenever possible) be the same as the result would be if you compiled the same code with just the dynamic expressions replaced by expressions of the type that the dynamic value has at execution time. (Statically-known types are preserved in the call site info.)

In this particular case, having just your code with .NET 4.0b1, the result is:

Bar(int) says: 0

However, having looked at this again (and checked which bit is actually dynamic) I'm slightly confused. I think it's one of those situations where I'd have to look very carefully at the spec to understand what the correct behaviour is. Unfortunately I don't know when the C# 4.0 spec will be available.

It's a tricky one to reason about, and I suspect the key part is whether at execution time the binder is able to work out that the value is of type T for the same T as the receiver, rather than type int. Because the receiver is dynamic in this case, the compiler doesn't do any overload resolution at all. Hmm. Tricky one, definitely.

Answer 2

Check out this blog post:

http://blog.davemorton.net/2009/05/dynamic-type-and-runtime-overload.html

His blog touches on exactly this kind of scenario and he compares the difference of the current overload resolution, to the way it'll be in .NET 4.0. Check it out...

Answer 3

I have another blog on a similar topic... this time with a caveat, and another small nuance that I find a little frightening. It is close to Halloween, after all:

http://blog.codinglight.com/2009/10/scary-halloween-style-c-40-code.html