Lack of override for implementing default interface methods can introduce errors

[jpobst]

When using default interface methods, the fact that classes implementing the interface do not override the interface method leads to subpar compile-time checking and IDE support.

For example, this typo is not caught by the compiler:

public interface IFoo
{
    string Bar() => "bar";
}

public class FooBar : IFoo
{
    public string Barr() => "blah";
}

Java catches this mistake using the @OverRide keyword:

public interface Foo
{
    default String bar() { return "bar"; }
}

public class FooBar implements Foo
{
    @Override
    public String barr() { return "blah"; }
}

results in:

Method does not override method from its superclass

Additionally this means that implementing default interface methods in a class does not participate in the IDE tooling one expects.

• If you type override in the implementing class, the default interface method does not appear in Intellisense.
• If you click the interface and choose "Implement interface" the default interface method is not generated for you.

[HaloFour]

I don't think that C# could change the override keyword to be allowed for use with interface implementations without potentially subtly changing existing code:

using System;

public interface IFoo {
    void M();
}

public class Bar {
    public virtual void M() => Console.WriteLine("Hello!");
}

public class Baz : Bar, IFoo {
    public void M() => Console.WriteLine("Goodbye!");
}

static class Program {
    public static void Main() {
        Bar b = new Baz();
        b.M();
    }
}

The above will print "Goodbye", but if you add override to Baz.M it will instead print "Hello".

But C# could take a similar tactic to Java in that an attribute could be used along with an analyzer that would ensure that the method did in fact implement an interface member.

I would agree that it sounds like the tooling needs some changes to work well with DIM. The default members should be discoverable.