Method overload resolution using dynamic argument

Question

This may have been answered before. I see many "dynamic method overload resolution" questions, but none that deal specifically with passing a dynamic argument. In the following code, in Test, the last call to M cannot be resolved (it doesn't compile). The error is: the call is ambiguous between [the first two overloads of M].

static void M(Func<int> f) { }
static void M(Func<string> f) { }
static void M(Func<dynamic> f) { }

static dynamic DynamicObject() {
    return new object();
}

static void Test() {
    M(() => 0);
    M(() => "");
    M(() => DynamicObject()); //doesn't compile
}

1. Why, since the type isn't statically known, does it not resolve to the overload accepting dynamic?
2. Is it even possible for an overloaded method to use dynamic?
3. What is the best way to resolve this?

Answer 1

The problem here is type inference. The compiler is trying to find out which overload to use based on the argument, but it's also trying to find out what the type of the argument is based on the chosen overload. In the case of M(() => DynamicObject()), the process goes something like this:

1. The argument to the method is a lambda with zero parameters. This gives us all three overloads as possibilities.
2. The body of the lambda returns dynamic. Because there is an implicit conversion from dynamic to any other type, we now know all three overloads are good.
3. Try choosing the best overload. In most cases, “best” means the most derived type. Because both int and string derive from object, the overloads with int and string are considered best.
4. We now have two “best” overloads, which means the compiler can't actually choose one of them. The compilation fails.

Now, regarding possible solutions to your problem:

1. Make the type of the lambda explicit, either using cast or typed local variable:

   M((Func<dynamic>)(() => DynamicObject()));
   

   or

   Func<dynamic> f = () => DynamicObject();
   M(f);
   

2. Rename the dynamic overload to something like DynamicM. This way, you don't have to deal with overload resolution.

3. This one feels somewhat wrong to me: make sure the dynamic overload is the only one that fits, by casting to object:

   M(() => (object)DynamicObject())