I have a method with the following overloads:
string Call(string function, Dictionary<string, object> parameters, object body)
string Call(string function, Dictionary<string, object> parameters, JObject body)
Now I added another overload:
string Call(string function)
{
return Call(function, null, (JObject) null);
}
I added a cast to JObject
so the compiler knows which overload it should use. But Visual Studio tells me that the cast is redundant. But why isn't my call ambiguous without the cast?
But why isn't my call ambiguous without the cast?
Because the overload with the JObject
parameter is "better" than the overload with the object
parameter... because the conversion from null
to JObject
is "better" than the conversion from null
to object
.
JObject
is more specific than object
, because there's an implicit conversion from JObject
to object
, but not vice versa.
If the final parameter for the first method were string
instead (for example) then neither overload would be better than the other, and the call would be ambiguous without the cast.
See section 7.5.3 of the C# 5 specification for all the intricate details. In particular, section 7.5.3.5 ("better conversion target") is relevant here.
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