Let me access explicit interface implementation members (or default implementations) directly in case there's only one candidate?

[voroninp]

Right now, if I implement interface method explicitly, or when I want to call the default implementation, I need to cast type to the interface:

(this as IFoo).Bar();

In case there's no ambiguity, and there's only one implementation of Bar() method, cannot compiler allow me accessing it without manually casting the type?

[AndersKehlet]

To make it look at bit nicer you can access interface members through a property

class MyClass : IFoo
{
    private IFoo Foo => this;
    
    void SomeMethod()
    {
        Foo.Bar();
    }
}

[voroninp]

That's how I usually do it =)

[timcassell]

#546

If it were implemented, you could do

private void Bar() : IFoo.Bar
{
}

this.Bar();

[CyrusNajmabadi]

cannot compiler allow me accessing it without manually casting the type?

No. The interface method may be reimplemented elsewhere (like in a derived class). So you have to call through the interface to ensure the right impl method is called.

[HaloFour]

Another method could be an analyzer that looks for the presence of a custom attribute and issues a diagnostic if the member doesn't implicitly implement any interface members. This is akin to Java's @Override annotation which emits an error if the annotated member doesn't actually override/implement a base member.

[huoyaoyuan]

So you have to call through the interface to ensure the right impl method is called.

An example for this:

class Foo : IFoo
{
    void IFoo.Bar() { ... }
    public void Baz() { ((IFoo)this).Bar(); } // Can call implementation in Foo2
}
class Foo2 : IFoo
{
    void IFoo.Bar() {  } // overrides
}

[voroninp]

@HaloFour , btw, if the primary purpose of the explicit interface implementation feature is NOT a disambiguation, then this documentation is somewhat misleading =P

If a class implements two interfaces that contain a member with the same signature, then implementing that member on the class will cause both interfaces to use that member as their implementation. But you might not want the same implementation to be called for both interfaces. To call a different implementation depending on which interface is in use, you can implement an interface member explicitly.

[CyrusNajmabadi]

, then this documentation is somewhat misleading =P

Feel free to raise this with the docs team.

Importantly, this does cover the main concern:

An explicit interface implementation is a class member that is only called through the specified interface.

That is the purpose. To provide impls only to be called through the interface.

[siegfriedpammer]

If the purpose of explicit interface implementations were disambiguation then C# would provide a mechanism to rename the interface member at implementation-site, like it's possible in VB.NET