Ambiguous delegate construction

[richard-fine]

I'm on a project where we're migrating some API from primitive types to more domain-specific types. We want to provide implicit conversion so that code using the existing API is able to continue working without changes. In general this is working nicely, but we've run into an interesting case around delegates that I'm wondering if anyone could help me understand more clearly.

So, our old code is using int to represent a common concept (an object identifier). In some parts of our API we have a callback registration setup using a delegate, like this:

    public delegate void Handler(int objectId);
    public static void AddHandler(Handler a) { ... }

Users can then declare a method and register it as a handler:

void MyHandler(int objectId) => Console.WriteLine(objectId);
AddHandler(MyHandler);

So far so good. Now, in the new version of our API, we're introducing a dedicated type to represent the object identifier. We give it an implicit conversion from int so that customers who are storing these identifiers in int-typed fields don't get errors - we want them to have source-level compatibility (for now - eventually we'll remove the conversions and require they use the dedicated type exclusively). So we introduce:

struct ObjectId {
    public int Value;
    public static implicit operator ObjectId(int i) => new ObjectId{Value=i};
}

    public delegate void HandlerExplicit(ObjectId e);
    public static void AddHandler(HandlerExplicit b){}

We want to introduce a new overload of AddHandler, rather than changing the existing one, so that we also have binary compatibility, i.e. precompiled libraries using the API can still resolve references to and call the old method (which will then forward to the new method).

However, this doesn't quite work:

AddHandler(MyHandler);
// error CS0121: The call is ambiguous between the following methods or properties: 'AddHandler(Handler)' and 'AddHandler(HandlerExplicit)'

I'm surprised to see this, because if I try to explicitly use MyHandler to construct a Handler delegate instance:

AddHandler(new Handler(MyHandler));
// error CS0123: No overload for 'MyHandler(ObjectId)' matches delegate 'Handler'

That makes sense, because I wouldn't expect the delegate to do any conversion of parameters before invoking the method. But as such - why, when I don't specify the delegate type, is it considered ambiguous?

[jaredpar]

Can you post the entire code sample that does not compile? Following your post I come up with the following that compiles just fine:

class C
{
    void Repro()
    {
        AddHandler(MyHandler);
    }

    public struct ObjectId
    {
        public int Value;
        public static implicit operator ObjectId(int i) => new ObjectId { Value = i };
    }

    void MyHandler(int objectId) => Console.WriteLine(objectId);
    public delegate void Handler(int objectId);
    public delegate void HandlerExplicit(ObjectId e);
    public static void AddHandler(Handler a) { }
    public static void AddHandler(HandlerExplicit b) { }
}

[Tinister]

https://sharplab.io/#v2:D4AQTAjAsAUCDMACciDCsDetE+UkALIgLIAUAlNrljLnckcQJ4ASAhgHYAmANgKYAnUgHkARgCs+AYwAuASS6IA9hOnyu5RAF4AfMggBOUismyF5ANxV6ia/QCCXLu278hzF70GW7AXzt2CPoAbAyIjs6cXkKebohsmhiI/rS4QSAQoYThTrGCpHkCAKIAHgAOPACWUpUyiKKJyQEwKbBBXHz8AOZsMnxhhaSVHHUmauZWMG1IAM4yAgCusohipuqYsACQQcN1AGpsPAt8k9v4mYiVALYV1bXKZYK9SgIrqmZcQyOXmrqIHHwAO5vNYKRBJA5HfpaS7JSatOBIDrdXr9bKFUq3GoyETvdSIPg+KYwIA=

[333fred]

I believe this is a duplicate of #8615.

[jaredpar]

Yes that appears to be the case.

Method group conversions are a bit strange because it's an expression where implicit conversions can exist but those conversions result in an error. Essentially there is an implicit conversion from MyHandler to Handler it's just that the conversion results in an error. This conversion exists because for every parameter in MyHandler there is an implicit conversion from the parameter type to the parameter type in MyHandler. The actual conversion is an error though because the method group is not compatible with the delegate type.

The spec calls this out with the following:

Note that the existence of an implicit conversion from E to D does not guarantee that the compile-time application of the conversion will succeed without error

If that sounds a bit confusing ... that's because it is a bit confusing. For most other expressions the language would say there is no conversion as it plays better with overload resolution. There are other cases where conversions exist but in error but it's fairly small.

In this case though MyHandler is convertible to both Handler and HandlerExplicit hence the method call is ambiguous. This can be fixed by either:

1. Casting the expression explicitly to Handler
2. Removing the implicit conversion from int to ObjectId

[333fred]

Or 3: Use OverloadResolutionPriority(-1) on the AddHandler(Handler a) overload. This is probably the approach I'd take.

[333fred]

https://sharplab.io/#v2:D4AQTAjAsAUCDMACciDCsDetE+UkALIgLIAUAlNrljLnckcQJ4ASAhgHYAmANgKYAnUgHkARgCs+AYwAuASS6IA9hOnyu5RAF4AfMggBOUismyF5ANxV6ia/QCCXLu278hzF70GW7AXzsA2iAQAHQASgCuHDIAlgC2fCGoSnEADjFuAMqCAG4xUnwAziHCOYI8SmxcYUVKPBGxShwACgIxSm0yTKQAtBDkALp2CPoAbAyIjs6cXkKebohsmhiI/rS4I8HjhJNO84Kk+wIAogAeqTz5MTKIosurdrBrsCNcfPwA5mwyfBNHpDFospVGYNFYYC8kIUZAIIrJEGJTOpMLAAJAjQE3ABqbHqfHB6PwEHG8QuVxuSlSgm+HQRIPUAKBMU0ukQHD4AHc6UiFIgVji8dpEDFVuDnnAkG9Pt9fjsjmcyVJriJ6by+D4ITAgA