Method overload resolution using dynamic argument

8
votes

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?
2
c#dynamicoverloadingoverload-resolution
Wouldn't you be better off using a generic here? It would still be ambiguous as is (bear in mind a dynamic can be A and can be B, how does the compiler know which to call?). But if you wanted I think you could change the methods to static void M<T>(Func<DataTime, T> f) where T : A and static void M<T>(Func<DataTime, T> f) where T : B and I think that would allow the overloading? - Certainly all of the method calls in Test should be ok? - Smudge202
The example is contrived, but the one part that accurately reflects my dilemma is passing dynamic to an overloaded method. How is that best resolved? - Daniel
As above - don't. How can you overload an object that can be anything? - Smudge202
@Smudge: of course you can have an overload accepting object. See Tigran's working example. - Daniel
Don't do that! Use a generic instead! - Peter Olson

2 Answers

5
votes

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())
1
votes

From the definition in MSDN:

dynamic

Type dynamic behaves like type object in most circumstances. However, operations that contain expressions of type dynamic are not resolved or type checked by the compiler. The compiler packages together information about the operation, and that information is later used to evaluate the operation at run time. As part of the process, variables of type dynamic are compiled into variables of type object. Therefore, type dynamic exists only at compile time, not at run time

So dynamic doesn't exist when you compile, cause it needs to convert it into destination *type*, and that's why is not able to resolve it. What is destination type ?

In fact if you do something like this: 

static void M(Func<int> f) { }
static void M(Func<string> f) { }
static void M(Func<object> f) { } // could be also declared like dynamic here, works by the way

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

static void Test()
{
    M(() => 0);
    M(() => "");
    M(() => DynamicObject());
}

It perfectly works as you want, as object is present like a type already at compile time, in difference of dynamic type which have to be converted.